class Doing::WWID

Main “What Was I Doing” methods

Attributes

additional_configs[R]
config[RW]
config_file[RW]
content[R]
current_section[R]
default_option[RW]
doing_file[R]

Public Class Methods

new() click to toggle source

Initializes the object.

# File lib/doing/wwid.rb, line 25
def initialize
  @timers = {}
  @recorded_items = []
  @content = Items.new
  Doing.auto_tag = true
end

Public Instance Methods

act_on(items, opt) click to toggle source

Perform actions on a set of entries. If no valid action is included in the opt hash and the terminal is a TTY, a menu will be presented

@param items [Array] Array of Items to affect @param opt [Hash] Options and actions to perform

@option opt [Boolean] :editor @option opt [Boolean] :delete @option opt [String] :tag @option opt [Boolean] :flag @option opt [Boolean] :finish @option opt [Boolean] :cancel @option opt [Boolean] :archive @option opt [String] :output @option opt [String] :save_to @option opt [Boolean] :again @option opt [Boolean] :resume

# File lib/doing/wwid.rb, line 946
def act_on(items, opt)
  opt ||= {}
  actions = %i[editor delete tag flag finish cancel archive output save_to again resume]
  has_action = false
  single = items.count == 1

  actions.each do |a|
    if opt[a]
      has_action = true
      break
    end
  end

  unless has_action
    actions = [
      'add tag',
      'remove tag',
      'autotag',
      'cancel',
      'delete',
      'finish',
      'flag',
      'archive',
      'move',
      'edit',
      'output formatted'
    ]

    actions.concat(['resume/repeat', 'begin/reset']) if items.count == 1

    choice = Prompt.choose_from(actions,
                                prompt: 'What do you want to do with the selected items? > ',
                                multiple: true,
                                sorted: false,
                                fzf_args: ["--height=#{actions.count + 3}", '--tac', '--no-sort', '--info=hidden'])
    return unless choice

    to_do = choice.strip.split(/\n/)
    to_do.each do |action|
      case action
      when /resume/
        opt[:resume] = true
      when /reset/
        opt[:reset] = true
      when /autotag/
        opt[:autotag] = true
      when /(add|remove) tag/
        type = action =~ /^add/ ? 'add' : 'remove'
        raise InvalidArgument, "'add tag' and 'remove tag' can not be used together" if opt[:tag]

        tags = type == 'add' ? all_tags(@content) : all_tags(items)

        puts "#{yellow}Separate multiple tags with spaces, hit tab to complete known tags#{type == 'add' ? ', include values with tag(value)' : ''}"
        puts "#{boldgreen}Available tags: #{boldwhite}#{tags.sort.map(&:add_at).join(', ')}" if type == 'remove'
        tag = Prompt.read_line(prompt: "Tags to #{type}", completions: tags)

        # print "#{yellow("Tag to #{type}: ")}#{reset}"
        # tag = $stdin.gets
        next if tag =~ /^ *$/

        opt[:tag] = tag.strip.sub(/^@/, '')
        opt[:remove] = true if type == 'remove'
      when /output formatted/
        plugins = Plugins.available_plugins(type: :export).sort
        output_format = Prompt.choose_from(plugins,
                                           prompt: 'Which output format? > ',
                                           fzf_args: [
                                             "--height=#{plugins.count + 3}",
                                             '--tac',
                                             '--no-sort',
                                             '--info=hidden'
                                           ])
        next if output_format =~ /^ *$/

        raise UserCancelled unless output_format

        opt[:output] = output_format.strip
        res = opt[:force] ? false : Prompt.yn('Save to file?', default_response: 'n')
        if res
          # print "#{yellow('File path/name: ')}#{reset}"
          # filename = $stdin.gets.strip
          filename = Prompt.read_line(prompt: 'File path/name')
          next if filename.empty?

          opt[:save_to] = filename
        end
      when /archive/
        opt[:archive] = true
      when /delete/
        opt[:delete] = true
      when /edit/
        opt[:editor] = true
      when /finish/
        opt[:finish] = true
      when /cancel/
        opt[:cancel] = true
      when /move/
        section = choose_section.strip
        opt[:move] = section.strip unless section =~ /^ *$/
      when /flag/
        opt[:flag] = true
      end
    end
  end

  if opt[:resume] || opt[:reset]
    raise InvalidArgument, 'resume and restart can only be used on a single entry' if items.count > 1

    item = items[0]
    if opt[:resume] && !opt[:reset]
      repeat_item(item, { editor: opt[:editor] }) # hooked
    elsif opt[:reset]
      res = Prompt.enter_text('Start date (blank for current time)', default_response: '')
      if res =~ /^ *$/
        date = Time.now
      else
        date = res.chronify(guess: :begin)
      end

      res = if item.tags?('done', :and) && !opt[:resume]
              opt[:force] ? true : Prompt.yn('Remove @done tag?', default_response: 'y')
            else
              opt[:resume]
            end
      old_item = item.clone
      new_entry = reset_item(item, date: date, resume: res)
      @content.update_item(item, new_entry)
      Hooks.trigger :post_entry_updated, self, new_entry, old_item
    end
    write(@doing_file)

    return
  end

  if opt[:delete]
    delete_items(items, force: opt[:force]) # hooked
    return
  end

  if opt[:flag]
    tag = Doing.setting('marker_tag', 'flagged')
    items.map! do |i|
      old_item = i.clone
      i.tag(tag, date: false, remove: opt[:remove], single: single)
      Hooks.trigger :post_entry_updated, self, i, old_item
    end
  end

  if opt[:finish] || opt[:cancel]
    tag = 'done'
    items.map! do |i|
      if i.should_finish?
        old_item = i.clone
        should_date = !opt[:cancel] && i.should_time?
        i.tag(tag, date: should_date, remove: opt[:remove], single: single)
        Hooks.trigger :post_entry_updated, self, i, old_item
      end
    end
  end

  if opt[:autotag]
    items.map! do |i|
      new_title = autotag(i.title)
      if new_title == i.title
        logger.count(:skipped, level: :debug, message: '%count unchaged %items')
        # logger.debug('Autotag:', 'No changes')
      else
        logger.count(:added_tags)
        logger.write(items.count == 1 ? :info : :debug, 'Tagged:', new_title)
        old_item = i.clone
        i.title = new_title
        Hooks.trigger :post_entry_updated, self, i, old_item
      end
    end
  end

  if opt[:tag]
    tag = opt[:tag]
    items.map! do |i|
      old_item = i.clone
      i.tag(tag, date: false, remove: opt[:remove], single: single)
      i.expand_date_tags(Doing.setting('date_tags'))
      Hooks.trigger :post_entry_updated, self, i, old_item
    end
  end

  if opt[:archive] || opt[:move]
    section = opt[:archive] ? 'Archive' : guess_section(opt[:move])
    items.map! do |i|
      old_item = i.clone
      i.move_to(section, label: true)
      Hooks.trigger :post_entry_updated, self, i, old_item
    end
  end

  write(@doing_file)

  if opt[:editor]
    edit_items(items) # hooked

    write(@doing_file)
  end

  return unless opt[:output]

  items.each { |i| i.title = "#{i.title} @section(#{i.section})" }

  export_items = Items.new
  export_items.concat(items)
  export_items.add_section(Section.new('Export'), log: false)
  options = { section: 'All' }

  if opt[:output] =~ /doing/
    options[:output] = 'template'
    options[:template] = '- %date | %title%note'
  else
    options[:output] = opt[:output]
    options[:template] = opt[:template] || nil
  end

  output = list_section(options, items: export_items) # hooked

  if opt[:save_to]
    file = File.expand_path(opt[:save_to])
    if File.exist?(file)
      # Create a backup copy for the undo command
      FileUtils.cp(file, "#{file}~")
    end

    File.open(file, 'w+') do |f|
      f.puts output
    end

    logger.warn('File written:', file)
  else
    Doing::Pager.page output
  end
end
add_item(title, section = nil, opt) click to toggle source

Adds an entry

@param title [String] The entry title @param section [String] The section to add to @param opt [Hash] Additional Options

@option opt :date [Date] item start date @option opt :note [Array] item note (will be converted if value is String) @option opt :back [Date] backdate @option opt :timed [Boolean] new item is timed entry, marks previous entry as @done @option opt :done [Date] If set, adds a @done tag to new entry

# File lib/doing/wwid.rb, line 348
def add_item(title, section = nil, opt)
  opt ||= {}
  section ||= Doing.setting('current_section')
  @content.add_section(section, log: false)
  opt[:back] ||= opt[:date] ? opt[:date] : Time.now
  opt[:date] ||= Time.now
  note = Note.new
  opt[:timed] ||= false

  note.add(opt[:note]) if opt[:note]

  title = [title.strip.cap_first]
  title = title.join(' ')

  if Doing.auto_tag
    title = autotag(title)
    title.add_tags!(Doing.setting('default_tags')) if Doing.setting('default_tags').good?
  end

  title.compress!
  entry = Item.new(opt[:back], title.strip, section)

  if opt[:done] && entry.should_finish?
    if entry.should_time?
      entry.tag('done', value: opt[:done])
    else
      entry.tag('done')
    end
  end

  entry.note = note

  items = @content.clone
  if opt[:timed]
    items.reverse!
    items.each_with_index do |i, x|
      next if i.title =~ / @done/

      finish_date = verify_duration(i.date, opt[:back], title: i.title)
      items[x].tag('done', value: finish_date.strftime('%F %R'))
      break
    end
  end

  Hooks.trigger :pre_entry_add, self, entry

  @content.push(entry)
  # logger.count(:added, level: :debug)
  logger.info('New entry:', %(added "#{entry.date.relative_date}: #{entry.title}" to #{section}))

  Hooks.trigger :post_entry_added, self, entry
  entry
end
add_with_editor(**options) click to toggle source
# File lib/doing/wwid.rb, line 313
def add_with_editor(**options)
  raise MissingEditor, 'No EDITOR variable defined in environment' if Util.default_editor.nil?

  input = options[:date].strftime('%F %R | ')
  input += options[:title]
  input += "\n#{options[:note]}" if options[:note]
  input = fork_editor(input).strip

  d, title, note = format_input(input)
  raise EmptyInput, 'No content' if title.empty?

  if options[:ask]
    ask_note = Doing::Prompt.read_lines(prompt: 'Add a note')
    note.add(ask_note) unless ask_note.empty?
  end

  date = d.nil? ? options[:date] : d
  finish = options[:finish_last] || false
  add_item(title.cap_first, options[:section], { note: note, back: date, timed: finish })
  write(@doing_file)
end
all_tags(items, opt: {}, counts: false) click to toggle source
# File lib/doing/wwid.rb, line 583
def all_tags(items, opt: {}, counts: false)
  if counts
    all_tags = {}
    items.each do |item|
      item.tags.each do |tag|
        if all_tags.key?(tag.downcase)
          all_tags[tag.downcase] += 1
        else
          all_tags[tag.downcase] = 1
        end
      end
    end

    all_tags.sort_by { |tag, count| count }
  else
    all_tags = []
    items.each { |item| all_tags.concat(item.tags.map(&:downcase)).uniq! }
    all_tags.sort
  end
end
archive(section = Doing.setting('current_section'), options) click to toggle source

Move entries from a section to Archive or other specified section

@param section [String] The source section @param options [Hash] Options

# File lib/doing/wwid.rb, line 1730
def archive(section = Doing.setting('current_section'), options)
  options ||= {}
  count       = options[:keep] || 0
  destination = options[:destination] || 'Archive'
  tags        = options[:tags] || []
  bool        = options[:bool] || :and

  section = choose_section if section.nil? || section =~ /choose/i
  archive_all = section =~ /^all$/i # && !(tags.nil? || tags.empty?)
  section = guess_section(section) unless archive_all

  @content.add_section(destination, log: true)
  # add_section(Section.new('Archive')) if destination =~ /^archive$/i && !@content.section?('Archive')

  destination = guess_section(destination)

  if @content.section?(destination) && (@content.section?(section) || archive_all)
    do_archive(section, destination, { count: count, tags: tags, bool: bool, search: options[:search], label: options[:label], before: options[:before], after: options[:after], from: options[:from] })
    write(doing_file)
  else
    raise InvalidArgument, 'Either source or destination does not exist'
  end
end
autotag(string) click to toggle source

Uses 'autotag' configuration to turn keywords into tags for time tracking. Does not repeat tags in a title, and only converts the first instance of an untagged keyword

@param string [String] The text to tag

# File lib/doing/wwid.rb, line 1956
def autotag(string)
  return unless string
  return string unless Doing.auto_tag

  original = string.dup
  text = string.dup

  current_tags = text.scan(/@\w+/).map { |t| t.sub(/^@/, '') }
  tagged = {
    whitelisted: [],
    synonyms: [],
    transformed: [],
    replaced: []
  }

  Doing.setting('autotag.whitelist').each do |tag|
    next if text =~ /@#{tag}\b/i

    text.sub!(/(?<= |\A)(#{tag.strip})(?= |\Z)/i) do |m|
      m.downcase! unless tag =~ /[A-Z]/
      tagged[:whitelisted].push(m)
      "@#{m}"
    end
  end

  Doing.setting('autotag.synonyms').each do |tag, v|
    v.each do |word|
      word = word.wildcard_to_rx
      next unless text =~ /\b#{word}\b/i

      unless current_tags.include?(tag) || tagged[:whitelisted].include?(tag)
        tagged[:synonyms].push(tag)
        tagged[:synonyms] = tagged[:synonyms].uniq
      end
    end
  end

  if Doing.setting('autotag.transform')
    Doing.setting('autotag.transform').each do |tag|
      next unless tag =~ /\S+:\S+/

      if tag =~ /::/
        rx, r = tag.split(/::/)
      else
        rx, r = tag.split(/:/)
      end

      flag_rx = %r{/([r]+)$}
      if r =~ flag_rx
        flags = r.match(flag_rx)[1].split(//)
        r.sub!(flag_rx, '')
      end
      r.gsub!(/\$/, '\\')
      rx.sub!(/^@?/, '@')
      regex = Regexp.new("(?<= |\\A)#{rx}(?= |\\Z)")

      text.sub!(regex) do
        m = Regexp.last_match
        new_tag = r

        m.to_a.slice(1, m.length - 1).each_with_index do |v, idx|
          new_tag.gsub!("\\#{idx + 1}", v)
        end
        # Replace original tag if /r
        if flags&.include?('r')
          tagged[:replaced].concat(new_tag.split(/ /).map { |t| t.sub(/^@/, '') })
          new_tag.split(/ /).map { |t| t.sub(/^@?/, '@') }.join(' ')
        else
          tagged[:transformed].concat(new_tag.split(/ /).map { |t| t.sub(/^@/, '') })
          tagged[:transformed] = tagged[:transformed].uniq
          m[0]
        end
      end
    end
  end

  logger.debug('Autotag:', "whitelisted tags: #{tagged[:whitelisted].log_tags}") unless tagged[:whitelisted].empty?
  logger.debug('Autotag:', "synonyms: #{tagged[:synonyms].log_tags}") unless tagged[:synonyms].empty?
  logger.debug('Autotag:', "transforms: #{tagged[:transformed].log_tags}") unless tagged[:transformed].empty?
  logger.debug('Autotag:', "transform replaced: #{tagged[:replaced].log_tags}") unless tagged[:replaced].empty?

  tail_tags = tagged[:synonyms].concat(tagged[:transformed])
  tail_tags.sort!
  tail_tags.uniq!

  text.add_tags!(tail_tags) unless tail_tags.empty?

  if text == original
    logger.debug('Autotag:', "no change to \"#{text.strip}\"")
  else
    new_tags = tagged[:whitelisted].concat(tail_tags).concat(tagged[:replaced])
    logger.debug('Autotag:', "added #{new_tags.log_tags} to \"#{text.strip}\"")
    logger.count(:autotag, level: :info, count: 1, message: 'autotag updated %count %items')
  end

  text.dedup_tags
end
choose_section(include_all: false) click to toggle source

Generate a menu of sections and allow user selection

@return [String] The selected section name

# File lib/doing/wwid.rb, line 1570
def choose_section(include_all: false)
  options = @content.section_titles.sort
  options.unshift('All') if include_all
  choice = Prompt.choose_from(options, prompt: 'Choose a section > ', fzf_args: ['--height=60%'])
  choice ? choice.strip : choice
end
choose_section_tag() click to toggle source

Generate a menu of sections and tags and allow user selection

@return [String] The selected section or tag name

# File lib/doing/wwid.rb, line 1595
def choose_section_tag
  options = @content.section_titles.sort
  options.concat(@content.all_tags.sort.map { |t| "@#{t}" })
  choice = Prompt.choose_from(options, prompt: 'Choose a section or tag > ', fzf_args: ['--height=60%'])
  choice ? choice.strip : choice
end
choose_tag(section = 'All', items: nil, include_all: false) click to toggle source

Generate a menu of tags and allow user selection

@return [String] The selected tag name

# File lib/doing/wwid.rb, line 1582
def choose_tag(section = 'All', items: nil, include_all: false)
  items ||= @content.in_section(section)
  tags = all_tags(items, counts: true).map { |t, c| "@#{t} (#{c})" }
  tags.unshift('No tag filter') if include_all
  choice = Prompt.choose_from(tags, sorted: false, multiple: true, prompt: 'Choose tag(s) > ', fzf_args: ['--height=60%'])
  choice ? choice.split(/\n/).map { |t| t.strip.sub(/ \(.*?\)$/, '')}.join(' ') : choice
end
choose_view() click to toggle source

Generate a menu of views and allow user selection

@return [String] The selected view name

# File lib/doing/wwid.rb, line 1616
def choose_view
  choice = Prompt.choose_from(views.sort, prompt: 'Choose a view > ', fzf_args: ['--height=60%'])
  choice ? choice.strip : choice
end
configure(filename = nil) click to toggle source

Load configuration files and updated the @settings attribute with a Doing::Configuration object

@param filename [String] (optional) path to alternative config file

# File lib/doing/wwid.rb, line 2220
def configure(filename = nil)
  logger.benchmark(:configure, :start)

  if filename
    Doing.config_with(filename, { ignore_local: true })
  elsif ENV['DOING_CONFIG']
    Doing.config_with(ENV['DOING_CONFIG'], { ignore_local: true })
  end

  logger.benchmark(:configure, :finish)

  Doing.set('backup_dir', ENV['DOING_BACKUP_DIR']) if ENV['DOING_BACKUP_DIR']
end
create(filename = nil) click to toggle source

Create a new doing file

# File lib/doing/wwid.rb, line 118
def create(filename = nil)
  filename = @doing_file if filename.nil?
  return if File.exist?(filename) && File.stat(filename).size.positive?

  FileUtils.mkdir_p(File.dirname(filename)) unless File.directory?(File.dirname(filename))

  File.open(filename, 'w+') do |f|
    f.puts "#{Doing.setting('current_section')}:"
  end
end
dedup(items, no_overlap: false) click to toggle source

Remove items from an array that already exist in @content based on start and end times

@param items [Array] The items to deduplicate @param no_overlap [Boolean] Remove items with overlapping time spans

# File lib/doing/wwid.rb, line 411
def dedup(items, no_overlap: false)
  items.delete_if do |item|
    duped = false
    @content.each do |comp|
      duped = no_overlap ? item.overlapping_time?(comp) : item.same_time?(comp)
      break if duped
    end
    logger.count(:skipped, level: :debug, message: '%count overlapping %items') if duped
    # logger.log_now(:debug, 'Skipped:', "overlapping entry: #{item.title}") if duped
    duped
  end
end
delete_items(items, force: false) click to toggle source
# File lib/doing/wwid.rb, line 826
def delete_items(items, force: false)
  items.slice(0, 5).each { |i| puts i.to_pretty } unless force
  puts softpurple("+ #{items.size - 5} additional #{'item'.to_p(items.size - 5)}") if items.size > 5 && !force

  res = force ? true : Prompt.yn("Delete #{items.size} #{'item'.to_p(items.size)}?", default_response: 'y')
  return unless res

  items.each { |i| Hooks.trigger :post_entry_removed, self, @content.delete_item(i, single: items.count == 1) }
  write(@doing_file)
end
edit_items(items) click to toggle source
# File lib/doing/wwid.rb, line 837
    def edit_items(items)
      items.sort_by! { |i| i.date }
      editable_items = []

      items.each do |i|
        editable = "#{i.date.strftime('%F %R')} | #{i.title}"
        old_note = i.note ? i.note.strip_lines.join("\n") : nil
        editable += "\n#{old_note}" unless old_note.nil?
        editable_items << editable
      end
      divider = "-----------"
      notice =<<~EONOTICE
      # - You may delete entries, but leave all divider lines (---) in place.
      # - Start and @done dates replaced with a time string (yesterday 3pm) will
      #   be parsed automatically. Do not delete the pipe (|) between start date
      #   and entry title.
      EONOTICE
      input =  "#{editable_items.map(&:strip).join("\n#{divider}\n")}\n\n#{notice}"

      new_items = fork_editor(input).split(/^#{divider}/).map(&:strip)

      new_items.each_with_index do |new_item, i|
        input_lines = new_item.split(/[\n\r]+/).delete_if(&:ignore?)
        first_line = input_lines[0]&.strip

        if first_line.nil? || first_line =~ /^#{divider.strip}$/ || first_line.strip.empty?
          deleted = @content.delete_item(items[i], single: new_items.count == 1)
          Hooks.trigger :post_entry_removed, self, deleted
          Doing.logger.info('Deleted:', deleted.title)
        else
          date, title, note = format_input(new_item)

          note.map!(&:strip)
          note.delete_if(&:ignore?)
          item = items[i]
          old_item = item.clone
          item.date = date || items[i].date
          item.title = title
          item.note = note
          if (item.equal?(old_item))
            Doing.logger.count(:skipped, level: :debug)
          else
            Doing.logger.count(:updated)
            Hooks.trigger :post_entry_updated, self, item, old_item
          end
        end
      end
    end
edit_last(section: 'All', options: {}) click to toggle source

Edit the last entry

@param section [String] The section, default “All”

# File lib/doing/wwid.rb, line 1389
def edit_last(section: 'All', options: {})
  options[:section] = guess_section(section)

  item = last_entry(options)

  if item.nil?
    logger.debug('Skipped:', 'No entries found')
    return
  end

  old_item = item.clone
  content = ["#{item.date.strftime('%F %R')} | #{item.title.dup}"]
  content << item.note.strip_lines.join("\n") unless item.note.empty?
  new_item = fork_editor(content.join("\n"))
  date, title, note = format_input(new_item)
  date ||= item.date

  if title.nil? || title.empty?
    logger.debug('Skipped:', 'No content provided')
  elsif title == item.title && note.equal?(item.note) && date.equal?(item.date)
    logger.debug('Skipped:', 'No change in content')
  else
    item.date = date unless date.nil?
    item.title = title
    item.note.add(note, replace: true)
    logger.info('Edited:', item.title)
    Hooks.trigger :post_entry_updated, self, item, old_item

    write(@doing_file)
  end
end
filter_items(items = Items.new, opt: {}) click to toggle source

Filter items based on search criteria

@param items [Array] The items to filter (if empty, filters all items) @param opt [Hash] The filter parameters

@option opt [String] :section ('all') @option opt [Boolean] :unfinished (false) @option opt [Array or String] :tag ([]) Array or comma-separated string @option opt [Symbol] :tag_bool (:and) :and, :or, :not @option opt [String] :search ('') string, optional regex with /string/ @option opt [Array] :date_filter (nil) [[Time]start, [Time]end] @option opt [Boolean] :only_timed (false) @option opt [String] :before (nil) Date/Time string, unparsed @option opt [String] :after (nil) Date/Time string, unparsed @option opt [Boolean] :today (false) limit to entries from today @option opt [Boolean] :yesterday (false) limit to entries from yesterday @option opt [Number] :count (0) max entries to return @option opt [String] :age (new) 'old' or 'new' @option opt [Array] :val (nil) Array of tag value queries

# File lib/doing/wwid.rb, line 666
def filter_items(items = Items.new, opt: {})
  logger.benchmark(:filter_items, :start)
  time_rx = /^(\d{1,2}+(:\d{1,2}+)?( *(am|pm))?|midnight|noon)$/i

  if items.nil? || items.empty?
    section = opt[:section] ? guess_section(opt[:section]) : 'All'
    items = section =~ /^all$/i ? @content.clone : @content.in_section(section)
  end

  if !opt[:time_filter]
    opt[:time_filter] = [nil, nil]
    if opt[:from] && !opt[:date_filter]
      if opt[:from][0].is_a?(String) && opt[:from][0] =~ time_rx
        opt[:time_filter] = opt[:from]
      elsif opt[:from][0].is_a?(Time)
        opt[:date_filter] = opt[:from]
      end
    end
  end

  if opt[:before].is_a?(String) && opt[:before] =~ time_rx
    opt[:time_filter][1] = opt[:before]
    opt[:before] = nil
  end

  if opt[:after].is_a?(String) && opt[:after] =~ time_rx
    opt[:time_filter][0] = opt[:after]
    opt[:after] = nil
  end

  items.sort_by! { |item| [item.date, item.title.downcase] }.reverse

  filtered_items = items.select do |item|
    keep = true
    if opt[:unfinished]
      finished = item.tags?('done', :and)
      finished = opt[:not] ? !finished : finished
      keep = false if finished
    end

    if keep && opt[:val]&.count&.positive?
      bool = opt[:bool].normalize_bool if opt[:bool]
      bool ||= :and
      bool = :and if bool == :pattern

      val_match = opt[:val].nil? || opt[:val].empty? ? true : item.tag_values?(opt[:val], bool)
      keep = false unless val_match
      keep = opt[:not] ? !keep : keep
    end

    if keep && opt[:tag]
      opt[:tag_bool] = opt[:bool].normalize_bool if opt[:bool]
      opt[:tag_bool] ||= :and
      tag_match = opt[:tag].nil? || opt[:tag].empty? ? true : item.tags?(opt[:tag], opt[:tag_bool])
      keep = false unless tag_match
      keep = opt[:not] ? !keep : keep
    end

    if keep && opt[:search]
      search_match = if opt[:search].nil? || opt[:search].empty?
                       true
                     else
                       item.search(opt[:search], case_type: opt[:case].normalize_case)
                     end

      keep = false unless search_match
      keep = opt[:not] ? !keep : keep
    end

    if keep && opt[:date_filter]&.length == 2
      start_date = opt[:date_filter][0]
      end_date = opt[:date_filter][1]

      in_date_range = if end_date
                        item.date >= start_date && item.date <= end_date
                      else
                        item.date.strftime('%F') == start_date.strftime('%F')
                      end
      keep = false unless in_date_range
      keep = opt[:not] ? !keep : keep
    end

    if keep && opt[:time_filter][0] || opt[:time_filter][1]
      start_string = if opt[:time_filter][0].nil?
                       "#{item.date.strftime('%Y-%m-%d')} 12am"
                     else
                       "#{item.date.strftime('%Y-%m-%d')} #{opt[:time_filter][0]}"
                     end
      start_time = start_string.chronify(guess: :begin)

      end_string = if opt[:time_filter][1].nil?
                     "#{item.date.to_datetime.next_day.strftime('%Y-%m-%d')} 12am"
                   else
                     "#{item.date.strftime('%Y-%m-%d')} #{opt[:time_filter][1]}"
                   end
      end_time = end_string.chronify(guess: :end)

      in_time_range = item.date >= start_time && item.date <= end_time
      keep = false unless in_time_range
      keep = opt[:not] ? !keep : keep
    end

    keep = false if keep && opt[:only_timed] && !item.interval

    if keep && opt[:tag_filter]
      keep = item.tags?(opt[:tag_filter]['tags'], opt[:tag_filter]['bool'])
      keep = opt[:not] ? !keep : keep
    end

    if keep && opt[:before]
      before = opt[:before]
      if before =~ time_rx
        cutoff = "#{item.date.strftime('%Y-%m-%d')} #{before}".chronify(guess: :begin)
      elsif before.is_a?(String)
        cutoff = before.chronify(guess: :begin)
      else
        cutoff = before
      end
      keep = cutoff && item.date <= cutoff
      keep = opt[:not] ? !keep : keep
    end

    if keep && opt[:after]
      after = opt[:after]
      if after =~ time_rx
        cutoff = "#{item.date.strftime('%Y-%m-%d')} #{after}".chronify(guess: :end)
      elsif after.is_a?(String)
        cutoff = after.chronify(guess: :end)
      else
        cutoff = after
      end
      keep = cutoff && item.date >= cutoff
      keep = opt[:not] ? !keep : keep
    end

    if keep && opt[:today]
      keep = item.date >= Date.today.to_time && item.date < Date.today.next_day.to_time
      keep = opt[:not] ? !keep : keep
    elsif keep && opt[:yesterday]
      keep = item.date >= Date.today.prev_day.to_time && item.date < Date.today.to_time
      keep = opt[:not] ? !keep : keep
    end

    keep
  end
  count = opt[:count].to_i&.positive? ? opt[:count].to_i : filtered_items.count

  output = Items.new

  if opt[:age] && opt[:age].normalize_age == :oldest
    output.concat(filtered_items.slice(0, count).reverse)
  else
    output.concat(filtered_items.reverse.slice(0, count))
  end

  logger.benchmark(:filter_items, :finish)

  output
end
fork_editor(input = '', message: :default) click to toggle source

Create a process for an editor and wait for the file handle to return

@param input [String] Text input for editor

# File lib/doing/wwid.rb, line 134
def fork_editor(input = '', message: :default)
  # raise NonInteractive, 'Non-interactive terminal' unless $stdout.isatty || ENV['DOING_EDITOR_TEST']

  raise MissingEditor, 'No EDITOR variable defined in environment' if Util.default_editor.nil?

  tmpfile = Tempfile.new(['doing', '.md'])

  File.open(tmpfile.path, 'w+') do |f|
    f.puts input
    unless message.nil?
      f.puts message == :default ? "# The first line is the entry title, any lines after that are added as a note" : message
    end
  end

  pid = Process.fork { system("#{Util.editor_with_args} #{tmpfile.path}") }

  trap('INT') do
    begin
      Process.kill(9, pid)
    rescue StandardError
      Errno::ESRCH
    end
    tmpfile.unlink
    tmpfile.close!
    exit 0
  end

  Process.wait(pid)

  begin
    if $?.exitstatus == 0
      input = IO.read(tmpfile.path)
    else
      exit_now! 'Cancelled'
    end
  ensure
    tmpfile.close
    tmpfile.unlink
  end

  input.split(/\n/).delete_if(&:ignore?).join("\n")
end
format_input(input) click to toggle source

Takes a multi-line string and formats it as an entry

@param input [String] The string to parse

@return [Array] [[String]title, [Note]note]

# File lib/doing/wwid.rb, line 184
def format_input(input)
  raise EmptyInput, 'No content in entry' if input.nil? || input.strip.empty?

  input_lines = input.split(/[\n\r]+/).delete_if(&:ignore?)
  title = input_lines[0]&.strip
  raise EmptyInput, 'No content in first line' if title.nil? || title.strip.empty?

  date = nil
  iso_rx = /\d{4}-\d\d-\d\d \d\d:\d\d/
  date_rx = /^(?:\s*- )?(?<date>.*?) \| (?=\S)/

  raise EmptyInput, 'No content' if title.sub(/^.*?\| */, '').strip.empty?

  title.expand_date_tags(Doing.setting('date_tags'))

  if title =~ date_rx
    m = title.match(date_rx)
    d = m['date']
    date = if d =~ iso_rx
             Time.parse(d)
           else
             d.chronify(guess: :begin)
           end
    title.sub!(date_rx, '').strip!
  end

  note = Note.new
  note.add(input_lines[1..-1]) if input_lines.length > 1
  # If title line ends in a parenthetical, use that as the note
  if note.empty? && title =~ /\s+\(.*?\)$/
    title.sub!(/\s+\((?<note>.*?)\)$/) do
      m = Regexp.last_match
      note.add(m['note'])
      ''
    end
  end

  note.strip_lines!
  note.compress

  [date, title, note]
end
fuzzy_filter_items(items, opt: {}) click to toggle source
# File lib/doing/wwid.rb, line 616
def fuzzy_filter_items(items, opt: {})
  scannable = items.map.with_index { |item, idx| "#{item.title} #{item.note.join(' ')}".gsub(/[|*?!]/, '') + "|#{idx}"  }.join("\n")

  fzf_args = [
    '--multi',
    %(--filter="#{opt[:search].sub(/^'?/, "'")}"),
    '--no-sort',
    '-d "\|"',
    '--nth=1'
  ]
  if opt[:case]
    fzf_args << case opt[:case].normalize_case
                when :sensitive
                  '+i'
                when :ignore
                  '-i'
                end
  end
  # fzf_args << '-e' if opt[:exact]
  # puts fzf_args.join(' ')
  res = `echo #{Shellwords.escape(scannable)}|#{Prompt.fzf} #{fzf_args.join(' ')}`
  selected = Items.new
  res.split(/\n/).each do |item|
    idx = item.match(/\|(\d+)$/)[1].to_i
    selected.push(items[idx])
  end
  selected
end
get_diff(filename = nil) click to toggle source
# File lib/doing/wwid.rb, line 2234
def get_diff(filename = nil)
  configure if Doing.settings.nil?

  filename ||= Doing.setting('doing_file')
  init_doing_file(filename)
  current_content = @content.clone
  backup_file = Util::Backup.last_backup(filename, count: 1)
  raise DoingRuntimeError, 'No undo history to diff' if backup_file.nil?

  backup = WWID.new
  backup.config = Doing.settings
  backup.init_doing_file(backup_file)
  current_content.diff(backup.content)
end
get_interval(item, formatted: true, record: true) click to toggle source

Gets the interval between entry's start date and @done date

@param item [Item] The entry @param formatted [Boolean] Return human readable time (default seconds) @param record [Boolean] Add the interval to the total for each tag

@return Interval in seconds, or [d, h, m] array if formatted is true. False if no end date or interval is 0

# File lib/doing/wwid.rb, line 2201
def get_interval(item, formatted: true, record: true)
  if item.interval
    seconds = item.interval
    record_tag_times(item, seconds) if record
    return seconds.positive? ? seconds : false unless formatted

    return seconds.positive? ? seconds.time_string(format: :clock) : false
  end

  false
end
get_view(title) click to toggle source

Gets a view from configuration

@param title [String] The title of the view to retrieve

# File lib/doing/wwid.rb, line 1626
def get_view(title)
  return Doing.setting(['views', title], nil)

  false
end
guess_section(frag, guessed: false, suggest: false) click to toggle source

Attempt to match a string with an existing section

@param frag [String] The user-provided string @param guessed [Boolean] already guessed and failed

# File lib/doing/wwid.rb, line 242
def guess_section(frag, guessed: false, suggest: false)
  return 'All' if frag =~ /^all$/i
  frag ||= Doing.setting('current_section')

  return frag.cap_first if @content.section?(frag)

  section = nil
  re = frag.to_rx(distance: 2, case_type: :ignore)
  sections.each do |sect|
    next unless sect =~ /#{re}/i

    logger.debug('Match:', %(Assuming "#{sect}" from "#{frag}"))
    section = sect
    break
  end

  return section if suggest

  unless section || guessed
    alt = guess_view(frag, guessed: true, suggest: true)
    if alt
      meant_view = Prompt.yn("#{boldwhite("Did you mean")} `#{yellow("doing view #{alt}")}#{boldwhite}`?", default_response: 'n')

      raise WrongCommand.new("run again with #{"doing view #{alt}".boldwhite}", topic: 'Try again:') if meant_view

    end

    res = Prompt.yn("#{boldwhite}Section #{frag.yellow}#{boldwhite} not found, create it", default_response: 'n')

    if res
      @content.add_section(frag.cap_first, log: true)
      write(@doing_file)
      return frag.cap_first
    end

    raise InvalidSection.new("unknown section #{frag.bold.white}", topic: 'Missing:')
  end
  section ? section.cap_first : guessed
end
guess_view(frag, guessed: false, suggest: false) click to toggle source

Attempt to match a string with an existing view

@param frag [String] The user-provided string @param guessed [Boolean] already guessed

# File lib/doing/wwid.rb, line 288
def guess_view(frag, guessed: false, suggest: false)
  views.each { |view| return view if frag.downcase == view.downcase }
  view = false
  re = frag.to_rx(distance: 2, case_type: :ignore)
  views.each do |v|
    next unless v =~ /#{re}/i

    logger.debug('Match:', %(Assuming "#{v}" from "#{frag}"))
    view = v
    break
  end
  unless view || guessed
    alt = guess_section(frag, guessed: true, suggest: true)

    raise InvalidView.new(%(unknown view #{frag.bold.white}), topic: 'Missing:') unless alt

    meant_view = Prompt.yn("Did you mean `doing show #{alt}`?", default_response: 'n')

    raise WrongCommand.new("run again with #{"doing show #{alt}".yellow}", topic: 'Try again:') if meant_view

    raise InvalidView.new(%(unknown view #{alt.bold.white}), topic: 'Missing:')
  end
  view
end
import(paths, opt) click to toggle source

Imports external entries

@param paths [String] Path to JSON report file @param opt [Hash] Additional Options

# File lib/doing/wwid.rb, line 430
def import(paths, opt)
  opt ||= {}
  Plugins.plugins[:import].each do |_, options|
    next unless opt[:type] =~ /^(#{options[:trigger].normalize_trigger})$/i

    if paths.count.positive?
      paths.each do |path|
        options[:class].import(self, path, options: opt)
      end
    else
      options[:class].import(self, nil, options: opt)
    end
    break
  end
end
init_doing_file(path = nil) click to toggle source

Initializes the doing file.

@param path [String] Override path to a doing file, optional

# File lib/doing/wwid.rb, line 55
def init_doing_file(path = nil)
  @doing_file =  File.expand_path(Doing.setting('doing_file'))

  if path.nil?
    create(@doing_file) unless File.exist?(@doing_file)
    input = IO.read(@doing_file)
    input = input.force_encoding('utf-8') if input.respond_to? :force_encoding
    logger.debug('Read:', "read file #{@doing_file}")
  elsif File.exist?(File.expand_path(path)) && File.file?(File.expand_path(path)) && File.stat(File.expand_path(path)).size.positive?
    @doing_file = File.expand_path(path)
    input = IO.read(File.expand_path(path))
    input = input.force_encoding('utf-8') if input.respond_to? :force_encoding
    logger.debug('Read:', "read file #{File.expand_path(path)}")
  elsif path.length < 256
    @doing_file = File.expand_path(path)
    create(path)
    input = IO.read(File.expand_path(path))
    input = input.force_encoding('utf-8') if input.respond_to? :force_encoding
    logger.debug('Read:', "read file #{File.expand_path(path)}")
  end

  @other_content_top = []
  @other_content_bottom = []

  section = nil
  lines = input.split(/[\n\r]/)

  lines.each do |line|
    next if line =~ /^\s*$/

    if line =~ /^(\S[\S ]+):\s*(@\S+\s*)*$/
      section = Regexp.last_match(1)
      @content.add_section(Section.new(section, original: line), log: false)
    elsif line =~ /^\s*- (\d{4}-\d\d-\d\d \d\d:\d\d) \| (.*)/
      if section.nil?
        section = 'Uncategorized'
        @content.add_section(Section.new(section, original: 'Uncategorized:'), log: false)
      end

      date = Regexp.last_match(1).strip
      title = Regexp.last_match(2).strip
      item = Item.new(date, title, section)
      @content.push(item)
    elsif @content.count.zero?
      # if content[section].items.length - 1 == current
      @other_content_top.push(line)
    elsif line =~ /^\S/
      @other_content_bottom.push(line)
    else
      prev_item = @content.last
      prev_item.note = Note.new unless prev_item.note

      prev_item.note.add(line)
      # end
    end
  end

  Hooks.trigger :post_read, self
end
interactive(opt) click to toggle source

Display an interactive menu of entries

@param opt [Hash] Additional options

Options hash is shared with filter_items and act_on

# File lib/doing/wwid.rb, line 893
def interactive(opt)
  opt ||= {}
  opt[:section] = opt[:section] ? guess_section(opt[:section]) : 'All'

  search = nil

  if opt[:search]
    search = opt[:search]
    search.sub!(/^'?/, "'") if opt[:exact]
    opt[:search] = search
  end

  # opt[:query] = opt[:search] if opt[:search] && !opt[:query]
  opt[:query] = "!#{opt[:query]}" if opt[:query] && opt[:not]
  opt[:multiple] = true
  opt[:show_if_single] = true
  filter_options = %i[after before case date_filter from fuzzy not search section val].each_with_object({}) {
    |k, hsh| hsh[k] = opt[k]
  }
  items = filter_items(Items.new, opt: filter_options)

  menu_options = %i[search query exact multiple show_if_single menu sort case].each_with_object({}) {
    |k, hsh| hsh[k] = opt[k]
  }

  selection = Prompt.choose_from_items(items, include_section: opt[:section] =~ /^all$/i, **menu_options)

  raise NoResults, 'no items selected' if selection.nil? || selection.empty?

  act_on(selection, opt)
end
last(times: true, section: nil, options: {}) click to toggle source

Show the last entry

@param times (Bool) Show times @param section [String] Section to pull from, default Currently

# File lib/doing/wwid.rb, line 1908
def last(times: true, section: nil, options: {})
  section = section.nil? || section =~ /all/i ? 'All' : guess_section(section)
  cfg = Doing.setting(['templates', options[:config_template]]).deep_merge(Doing.setting('templates.default'), { extend_existing_arrays: true, sort_merged_arrays: true }).deep_merge({
    'wrap_width' => Doing.setting('wrap_width', 0),
    'date_format' => Doing.setting('default_date_format'),
    'order' => Doing.setting('order', :asc),
    'tags_color' => Doing.setting('tags_color'),
    'duration' => Doing.setting('duration'),
    'interval_format' => Doing.setting('interval_format')
  }, { extend_existing_arrays: true, sort_merged_arrays: true })
  options[:duration] ||= cfg['duration'] || false
  options[:interval_format] ||= cfg['interval_format'] || 'text'

  opts = {
    case: options[:case],
    config_template: 'last',
    count: 1,
    delete: options[:delete],
    duration: options[:duration],
    format: cfg['date_format'],
    interval_format: options[:interval_format],
    not: options[:negate],
    section: section,
    template: options[:template] || cfg['template'],
    times: times,
    val: options[:val],
    wrap_width: cfg['wrap_width']
  }

  if options[:tag]
    opts[:tag_filter] = {
      'tags' => options[:tag],
      'bool' => options[:tag_bool]
    }
  end

  opts[:search] = options[:search] if options[:search]

  list_section(opts)
end
last_entry(opt) click to toggle source

Get the last entry

@param opt [Hash] Additional Options

# File lib/doing/wwid.rb, line 558
def last_entry(opt)
  opt ||= {}
  opt[:tag_bool] ||= :and
  opt[:section] ||= Doing.setting('current_section')

  items = filter_items(Items.new, opt: opt)

  logger.debug('Filtered:', "Parameters matched #{items.count} entries")

  if opt[:interactive]
    last_entry = Prompt.choose_from_items(items, include_section: opt[:section] =~ /^all$/i,
      menu: true,
      header: '',
      prompt: 'Select an entry > ',
      multiple: false,
      sort: false,
      show_if_single: true
     )
  else
    last_entry = items.max_by { |item| item.date }
  end

  last_entry
end
last_note(section = 'All') click to toggle source

Return the content of the last note for a given section

@param section [String] The section to retrieve from, default All

# File lib/doing/wwid.rb, line 452
def last_note(section = 'All')
  section = guess_section(section)

  last_item = last_entry({ section: section })

  raise NoEntryError, 'No entry found' unless last_item

  logger.log_now(:info, 'Edit note:', last_item.title)

  note = last_item.note&.to_s || ''
  "#{last_item.title}\n# EDIT BELOW THIS LINE ------------\n#{note}"
end
list_date(dates, section, times = nil, output = nil, opt) click to toggle source

Display entries within a date range

@param dates [Array] [start, end] @param section [String] The section @param times (Bool) Show times @param output [String] Output format @param opt [Hash] Additional Options

# File lib/doing/wwid.rb, line 1813
def list_date(dates, section, times = nil, output = nil, opt)
  opt ||= {}
  opt[:totals] ||= false
  opt[:sort_tags] ||= false
  section = guess_section(section)
  # :date_filter expects an array with start and end date
  dates = dates.split_date_range if dates.instance_of?(String)

  opt[:section] = section
  opt[:count] = 0
  opt[:order] = :asc
  opt[:date_filter] = dates
  opt[:times] = times
  opt[:output] = output

  time_rx = /^(\d{1,2}+(:\d{1,2}+)?( *(am|pm))?|midnight|noon)$/
  if opt[:from] && opt[:from][0].is_a?(String) && opt[:from][0] =~ time_rx
    opt[:time_filter] = opt[:from]
  end

  list_section(opt)
end
list_section(opt, items: Items.new) click to toggle source

Display contents of a section based on options

@param opt [Hash] Additional Options

# File lib/doing/wwid.rb, line 1637
def list_section(opt, items: Items.new)
  logger.benchmark(:list_section, :start)
  opt[:config_template] ||= 'default'

  tpl_cfg = Doing.setting(['templates', opt[:config_template]])

  cfg = if opt[:view_template]
          Doing.setting(['views', opt[:view_template]]).deep_merge(tpl_cfg, { extend_existing_arrays: true, sort_merged_arrays: true })
        else
          tpl_cfg
        end

  cfg.deep_merge({
                   'wrap_width' => Doing.setting('wrap_width') || 0,
                   'date_format' => Doing.setting('default_date_format'),
                   'order' => Doing.setting('order') || :asc,
                   'tags_color' => Doing.setting('tags_color'),
                   'duration' => Doing.setting('duration'),
                   'interval_format' => Doing.setting('interval_format')
                 }, { extend_existing_arrays: true, sort_merged_arrays: true })

  opt[:duration] ||= cfg['duration'] || false
  opt[:interval_format] ||= cfg['interval_format'] || 'text'
  opt[:count] ||= 0
  opt[:age] ||= :newest
  opt[:age] = opt[:age].normalize_age
  opt[:format] ||= cfg['date_format']
  opt[:order] ||= cfg['order'] || :asc
  opt[:tag_order] ||= :asc
  opt[:tags_color] = cfg['tags_color'] || false if opt[:tags_color].nil?
  opt[:template] ||= cfg['template']
  opt[:sort_tags] ||= opt[:tag_sort]

  # opt[:highlight] ||= true
  title = ''
  is_single = true
  if opt[:section].nil?
    opt[:section] = choose_section
    title = opt[:section]
  elsif opt[:section].instance_of?(String)
    title = if opt[:section] =~ /^all$/i
              if opt[:page_title]
                opt[:page_title]
              elsif opt[:tag_filter] && opt[:tag_filter]['bool'].normalize_bool != :not
                opt[:tag_filter]['tags'].map { |tag| "@#{tag}" }.join(' + ')
              else
                'doing'
              end
            else
              guess_section(opt[:section])
            end
  end

  items = filter_items(items, opt: opt)

  items.reverse! unless opt[:order].normalize_order == :desc

  if opt[:delete]
    delete_items(items, force: opt[:force])

    write(@doing_file)
    return
  elsif opt[:editor]
    edit_items(items)

    write(@doing_file)
    return
  elsif opt[:interactive]
    opt[:menu] = !opt[:force]
    opt[:query] = '' # opt[:search]
    opt[:multiple] = true
    selected = Prompt.choose_from_items(items.reverse, include_section: opt[:section] =~ /^all$/i, **opt)

    raise NoResults, 'no items selected' if selected.nil? || selected.empty?

    act_on(selected, opt)
    return
  end

  opt[:output] ||= 'template'
  opt[:wrap_width] ||= Doing.setting('templates.default.wrap_width', 0)

  logger.benchmark(:list_section, :finish)
  output(items, title, is_single, opt)
end
logger() click to toggle source

Logger

Responds to :debug, :info, :warn, and :error

Each method takes a topic, and a message or block

Example: debug('Hooks', 'Hook 1 triggered')

# File lib/doing/wwid.rb, line 46
def logger
  @logger ||= Doing.logger
end
next_item(item, options = {}) click to toggle source

Get next item in the index

@param item [Item] target item @param options [Hash] additional options @see filter_items

@return [Item] the next chronological item in the index

# File lib/doing/wwid.rb, line 1375
def next_item(item, options = {})
  options ||= {}
  items = filter_items(Items.new, opt: options)

  idx = items.index(item)

  idx.positive? ? items[idx - 1] : nil
end
recent(count = 10, section = nil, opt) click to toggle source

Show recent entries

@param count [Integer] The number to show @param section [String] The section to show from, default Currently @param opt [Hash] Additional Options

# File lib/doing/wwid.rb, line 1871
def recent(count = 10, section = nil, opt)
  opt ||= {}
  times = opt[:t] || true
  opt[:totals] ||= false
  opt[:sort_tags] ||= false

  cfg = Doing.setting('templates.recent').deep_merge(Doing.setting('templates.default'), { extend_existing_arrays: true, sort_merged_arrays: true }).deep_merge({
    'wrap_width' => Doing.setting('wrap_width') || 0,
    'date_format' => Doing.setting('default_date_format'),
    'order' => Doing.setting('order') || :asc,
    'tags_color' => Doing.setting('tags_color'),
    'duration' => Doing.setting('duration'),
    'interval_format' => Doing.setting('interval_format')
  }, { extend_existing_arrays: true, sort_merged_arrays: true })
  opt[:duration] ||= cfg['duration'] || false
  opt[:interval_format] ||= cfg['interval_format'] || 'text'

  section ||= Doing.setting('current_section')
  section = guess_section(section)

  opt[:section] = section
  opt[:wrap_width] = cfg['wrap_width']
  opt[:count] = count
  opt[:format] = cfg['date_format']
  opt[:template] = opt[:template] || cfg['template']
  opt[:order] = :asc
  opt[:times] = times

  list_section(opt)
end
repeat_item(item, opt) click to toggle source

Duplicate an item and add it as a new item

@param item [Item] the item to duplicate @param opt [Hash] additional options

@option opt :editor [Boolean] open new item in editor @option opt :date [String] set start date @option opt :in [String] add new item to section :in @option opt :note [Note] add note to new item

@return nothing

# File lib/doing/wwid.rb, line 491
def repeat_item(item, opt)
  opt ||= {}
  old_item = item.clone
  if item.should_finish?
    if item.should_time?
      finish_date = verify_duration(item.date, Time.now, title: item.title)
      item.title.tag!('done', value: finish_date.strftime('%F %R'))
    else
      item.title.tag!('done')
    end
    Hooks.trigger :post_entry_updated, self, item, old_item
  end

  # Remove @done tag
  title = item.title.sub(/\s*@done(\(.*?\))?/, '').chomp
  section = opt[:in].nil? ? item.section : guess_section(opt[:in])
  Doing.auto_tag = false

  note = opt[:note] || Note.new

  if opt[:editor]
    start = opt[:date] ? opt[:date] : Time.now
    to_edit = "#{start.strftime('%F %R')} | #{title}"
    to_edit += "\n#{note.strip_lines.join("\n")}" unless note.empty?
    new_item = fork_editor(to_edit)
    date, title, note = format_input(new_item)

    opt[:date] = date unless date.nil?

    if title.nil? || title.empty?
      logger.warn('Skipped:', 'No content provided')
      return
    end
  end

  # @content.update_item(original, item)
  add_item(title, section, { note: note, back: opt[:date], timed: false })
end
repeat_last(opt) click to toggle source

Restart the last entry

@param opt [Hash] Additional Options

# File lib/doing/wwid.rb, line 535
def repeat_last(opt)
  opt ||= {}
  opt[:section] ||= 'all'
  opt[:section] = guess_section(opt[:section])
  opt[:note] ||= []
  opt[:tag] ||= []
  opt[:tag_bool] ||= :and

  last = last_entry(opt)
  if last.nil?
    logger.warn('Skipped:', 'No previous entry found')
    return
  end

  repeat_item(last, opt)
  write(@doing_file)
end
reset_item(item, date: nil, resume: false) click to toggle source

Reset start date to current time, optionally remove done tag (resume)

@param item [Item] the item to reset/resume @param resume [Boolean] removing @done tag if true

# File lib/doing/wwid.rb, line 471
def reset_item(item, date: nil, resume: false)
  date ||= Time.now
  item.date = date
  item.tag('done', remove: true) if resume
  logger.info('Reset:', %(Reset #{resume ? 'and resumed ' : ''} "#{item.title}" in #{item.section}))
  item
end
rotate(opt) click to toggle source

Rename doing file with date and start fresh one

# File lib/doing/wwid.rb, line 1507
def rotate(opt)
  opt ||= {}
  keep = opt[:keep] || 0
  tags = []
  tags.concat(opt[:tag].split(/ *, */).map { |t| t.sub(/^@/, '').strip }) if opt[:tag]
  bool  = opt[:bool] || :and
  sect = opt[:section] !~ /^all$/i ? guess_section(opt[:section]) : 'all'

  section = guess_section(sect)

  section_items = @content.in_section(section)
  max = section_items.count - keep.to_i

  counter = 0
  new_content = Items.new

  section_items.each do |item|
    break if counter >= max
    if opt[:before]
      time_string = opt[:before]
      cutoff = time_string.chronify(guess: :begin)
    end

    unless ((!tags.empty? && !item.tags?(tags, bool)) || (opt[:search] && !item.search(opt[:search].to_s)) || (opt[:before] && item.date >= cutoff))
      new_item = @content.delete(item)
      Hooks.trigger :post_entry_removed, self, item.clone
      raise DoingRuntimeError, "Error deleting item: #{item}" if new_item.nil?

      new_content.add_section(new_item.section, log: false)
      new_content.push(new_item)
      counter += 1
    end
  end

  if counter.positive?
    logger.count(:rotated,
                 level: :info,
                 count: counter,
                 message: "Rotated %count %items")
  else
    logger.info('Skipped:', 'No items were rotated')
  end

  write(@doing_file)

  file = @doing_file.sub(/(\.\w+)$/, "_#{Time.now.strftime('%Y-%m-%d')}\\1")
  if File.exist?(file)
    init_doing_file(file)
    @content.concat(new_content).uniq!
    logger.warn('File update:', "added entries to existing file: #{file}")
  else
    @content = new_content
    logger.warn('File update:', "created new file: #{file}")
  end

  write(file, backup: false)
end
sections() click to toggle source

List sections

@return [Array] section titles

# File lib/doing/wwid.rb, line 232
def sections
  @content.section_titles
end
stop_start(target_tag, opt) click to toggle source

Accepts one tag and the raw text of a new item if the passed tag is on any item, it's replaced with @done. if new_item is not nil, it's tagged with the passed tag and inserted. This is for use where only one instance of a given tag should exist (@meanwhile)

@param target_tag [String] Tag to replace @param opt [Hash] Additional Options

@option opt :section [String] target section @option opt :archive [Boolean] archive old item @option opt :back [Date] backdate new item @option opt :new_item [String] content to use for new item @option opt :note [Array] note content for new item

# File lib/doing/wwid.rb, line 1436
def stop_start(target_tag, opt)
  opt ||= {}
  tag = target_tag.dup
  opt[:section] ||= Doing.setting('current_section')
  opt[:archive] ||= false
  opt[:back] ||= Time.now
  opt[:new_item] ||= false
  opt[:note] ||= false

  opt[:section] = guess_section(opt[:section])

  tag.sub!(/^@/, '')

  found_items = 0

  @content.each_with_index do |item, i|
    old_item = i.clone
    next unless item.section == opt[:section] || opt[:section] =~ /all/i

    next unless item.title =~ /@#{tag}/

    item.title.add_tags!([tag, 'done'], remove: true)
    item.tag('done', value: opt[:back].strftime('%F %R'))

    found_items += 1

    if opt[:archive] && opt[:section] != 'Archive'
      item.title = item.title.sub(/(?:@from\(.*?\))?(.*)$/, "\\1 @from(#{item.section})")
      item.move_to('Archive', label: false, log: false)
      logger.count(:completed_archived)
      logger.info('Completed/archived:', item.title)
    else
      logger.count(:completed)
      logger.info('Completed:', item.title)
    end
    Hooks.trigger :post_entry_updated, self, item, old_item
  end


  logger.debug('Skipped:', "No active @#{tag} tasks found.") if found_items.zero?

  if opt[:new_item]
    date, title, note = format_input(opt[:new_item])
    opt[:back] = date unless date.nil?
    note.add(opt[:note]) if opt[:note]
    title.tag!(tag)
    add_item(title.cap_first, opt[:section], { note: note, back: opt[:back] })
  end

  write(@doing_file)
end
tag_groups(items, opt: {}) click to toggle source
# File lib/doing/wwid.rb, line 604
def tag_groups(items, opt: {})
  all_items = filter_items(items, opt: opt)
  tags = all_tags(all_items, opt: {})
  tag_groups = {}
  tags.each do |tag|
    tag_groups[tag] ||= []
    tag_groups[tag] = filter_items(all_items, opt: { tag: tag, tag_bool: :or })
  end

  tag_groups
end
tag_last(opt) click to toggle source

Tag the last entry or X entries

@param opt [Hash] Additional Options (see filter_items for filtering options)

@see filter_items

# File lib/doing/wwid.rb, line 1216
def tag_last(opt) # hooked
  opt ||= {}
  opt[:count] ||= 1
  opt[:archive] ||= false
  opt[:tags] ||= ['done']
  opt[:sequential] ||= false
  opt[:date] ||= false
  opt[:remove] ||= false
  opt[:update] ||= false
  opt[:autotag] ||= false
  opt[:back] ||= false
  opt[:unfinished] ||= false
  opt[:section] = opt[:section] ? guess_section(opt[:section]) : 'All'

  items = filter_items(Items.new, opt: opt)

  if opt[:interactive]
    items = Prompt.choose_from_items(items, include_section: opt[:section] =~ /^all$/i, menu: true,
                                header: '',
                                prompt: 'Select entries to tag > ',
                                multiple: true,
                                sort: true,
                                show_if_single: true)

    raise NoResults, 'no items selected' if items.empty?

  end

  raise NoResults, 'no items matched your search' if items.empty?

  if opt[:tags].empty? && !opt[:autotag]
    completions = opt[:remove] ? all_tags(items) : all_tags(@content)
    if opt[:remove]
      puts "#{yellow}Available tags: #{boldwhite}#{completions.map(&:add_at).join(', ')}"
    else
      puts "#{yellow}Use tab to complete known tags"
    end
    opt[:tags] = Doing::Prompt.read_line(prompt: "Enter tag(s) to #{opt[:remove] ? 'remove' : 'add'}",
                                         completions: completions,
                                         default_response: '').to_tags
    raise UserCancelled, 'No tags provided' if opt[:tags].empty?
  end

  items.each do |item|
    old_item = item.clone
    added = []
    removed = []

    if opt[:autotag]
      new_title = autotag(item.title) if Doing.auto_tag
      if new_title == item.title
        logger.count(:skipped, level: :debug, message: '%count unchaged %items')
        # logger.debug('Autotag:', 'No changes')
      else
        logger.count(:added_tags)
        logger.write(items.count == 1 ? :info : :debug, 'Tagged:', new_title)
        item.title = new_title
      end
    else
      if opt[:sequential]
        next_entry = next_item(item)

        done_date = if next_entry.nil?
                      Time.now
                    else
                      next_entry.date - 60
                    end
      else
        done_date = item.calculate_end_date(opt)
      end

      opt[:tags].each do |tag|
        if tag == 'done' && !item.should_finish?

          Doing.logger.debug('Skipped:', "Item in never_finish: #{item.title}")
          logger.count(:skipped, level: :debug)
          next
        end

        tag = tag.strip

        if tag =~ /^(\S+)\((.*?)\)$/
          m = Regexp.last_match
          tag = m[1]
          opt[:value] ||= m[2]
        end

        if tag =~ /^done$/ && opt[:date] && item.should_time?
          max_elapsed = Doing.setting('interaction.confirm_longer_than', 0)
          max_elapsed = max_elapsed.chronify_qty if max_elapsed.is_a?(String)
          elapsed = done_date - item.date

          if max_elapsed.positive? && (elapsed > max_elapsed) && !opt[:took]
            puts boldwhite(item.title)
            human = elapsed.time_string(format: :natural)
            res = Prompt.yn(yellow("Did this actually take #{human}"), default_response: true)
            unless res
              new_elapsed = Prompt.enter_text('How long did it take?').chronify_qty
              raise InvalidTimeExpression, 'Unrecognized time span entry' unless new_elapsed > 0

              opt[:took] = new_elapsed
              done_date = item.calculate_end_date(opt) if opt[:took]
            end
          end
        end

        if opt[:remove] || opt[:rename] || opt[:value]
          rename_to = nil
          if opt[:value]
            rename_to = tag
          elsif opt[:rename]
            rename_to = tag
            tag = opt[:rename]
          end
          old_title = item.title.dup
          force = opt[:value].nil? ? false : true
          item.title.tag!(tag, remove: opt[:remove], rename_to: rename_to, regex: opt[:regex], value: opt[:value], force: force)
          if old_title != item.title
            removed << tag
            added << rename_to if rename_to
          else
            logger.count(:skipped, level: :debug)
          end
        else
          old_title = item.title.dup
          should_date = opt[:date] && item.should_time?
          item.title.tag!('done', remove: true) if tag =~ /done/ && (!should_date || opt[:update])
          item.title.tag!(tag, value: should_date ? done_date.strftime('%F %R') : nil)
          added << tag if old_title != item.title
        end
      end
    end

    logger.log_change(tags_added: added, tags_removed: removed, item: item, single: items.count == 1)

    item.note.add(opt[:note]) if opt[:note]

    if opt[:archive] && opt[:section] != 'Archive' && (opt[:count]).positive?
      item.move_to('Archive', label: true)
    elsif opt[:archive] && opt[:count].zero?
      logger.warn('Skipped:', 'Archiving is skipped when operating on all entries')
    end

    item.expand_date_tags(Doing.setting('date_tags'))
    Hooks.trigger :post_entry_updated, self, item, old_item
  end

  write(@doing_file)
end
tag_times(format: :text, sort_by: :time, sort_order: :asc) click to toggle source

Get total elapsed time for all tags in selection

@param format [String] return format (html, json, or text) @param sort_by [Symbol] Sort by :name or :time @param sort_order [Symbol] The sort order (:asc or :desc)

# File lib/doing/wwid.rb, line 2063
    def tag_times(format: :text, sort_by: :time, sort_order: :asc)
      return '' if @timers.empty?

      max = @timers.keys.sort_by(&:length).reverse[0].length + 1

      total = @timers.delete('All')

      tags_data = @timers.delete_if { |_k, v| v.zero? }
      sorted_tags_data = if sort_by.normalize_tag_sort == :name
                           tags_data.sort_by { |k, _v| k }
                         else
                           tags_data.sort_by { |_k, v| v }
                         end

      sorted_tags_data.reverse! if sort_order.normalize_order == :asc
      case format
      when :html

        output = <<EOHEAD
          <table>
          <caption id="tagtotals">Tag Totals</caption>
          <colgroup>
          <col style="text-align:left;"/>
          <col style="text-align:left;"/>
          </colgroup>
          <thead>
          <tr>
            <th style="text-align:left;">project</th>
            <th style="text-align:left;">time</th>
          </tr>
          </thead>
          <tbody>
EOHEAD
        sorted_tags_data.reverse.each do |k, v|
          if v.positive?
            output += "<tr><td style='text-align:left;'>#{k}</td><td style='text-align:left;'>#{v.time_string(format: :clock)}</td></tr>\n"
          end
        end
        tail = <<EOTAIL
        <tr>
          <td style="text-align:left;" colspan="2"></td>
        </tr>
        </tbody>
        <tfoot>
        <tr>
          <td style="text-align:left;"><strong>Total</strong></td>
          <td style="text-align:left;">#{total.time_string(format: :clock)}</td>
        </tr>
        </tfoot>
        </table>
EOTAIL
        output + tail
      when :markdown
        pad = sorted_tags_data.map { |k, _| k }.group_by(&:size).max.last[0].length
        pad = 7 if pad < 7
        output = <<~EOHEADER
  | #{' ' * (pad - 7)}project | time     |
  | #{'-' * (pad - 1)}: | :------- |
        EOHEADER
        sorted_tags_data.reverse.each do |k, v|
          if v.positive?
            output += "| #{' ' * (pad - k.length)}#{k} | #{v.time_string(format: :clock)} |\n"
          end
        end
        tail = '[Tag Totals]'
        output + tail
      when :json
        output = []
        sorted_tags_data.reverse.each do |k, v|
          output << {
            'tag' => k,
            'seconds' => v,
            'formatted' => v.time_string(format: :clock)
          }
        end
        output
      when :human
        output = []
        sorted_tags_data.reverse.each do |k, v|
          spacer = ''
          (max - k.length).times do
            spacer += ' '
          end
          output.push("┃ #{spacer}#{k}:#{v.time_string(format: :hm)} ┃")
        end

        header = '┏━━ Tag Totals '
        (max - 2).times { header += '━' }
        header += '┓'
        footer = '┗'
        (max + 12).times { footer += '━' }
        footer += '┛'
        divider = '┣'
        (max + 12).times { divider += '━' }
        divider += '┫'
        output = output.empty? ? '' : "\n#{header}\n#{output.join("\n")}"
        output += "\n#{divider}"
        spacer = ''
        (max - 6).times do
          spacer += ' '
        end
        total_time = total.time_string(format: :hm)
        total = "┃ #{spacer}total: "
        total += total_time
        total += ' ┃'
        output += "\n#{total}"
        output += "\n#{footer}"
        output
      else
        output = []
        sorted_tags_data.reverse.each do |k, v|
          spacer = ''
          (max - k.length).times do
            spacer += ' '
          end
          output.push("#{k}:#{spacer}#{v.time_string(format: :clock)}")
        end

        output = output.empty? ? '' : "\n--- Tag Totals ---\n#{output.join("\n")}"
        output += "\n\nTotal tracked: #{total.time_string(format: :clock)}\n"
        output
      end
    end
today(times = true, output = nil, opt) click to toggle source

Show all entries from the current day

@param times [Boolean] show times @param output [String] output format @param opt [Hash] Options

# File lib/doing/wwid.rb, line 1761
def today(times = true, output = nil, opt)
  opt ||= {}
  opt[:totals] ||= false
  opt[:sort_tags] ||= false

  cfg = Doing.setting('templates').deep_merge(Doing.setting('templates.default'), { extend_existing_arrays: true, sort_merged_arrays: true }).deep_merge({
    'wrap_width' => Doing.setting('wrap_width') || 0,
    'date_format' => Doing.setting('default_date_format'),
    'order' => Doing.setting('order') || :asc,
    'tags_color' => Doing.setting('tags_color'),
    'duration' => Doing.setting('duration'),
    'interval_format' => Doing.setting('interval_format')
  }, { extend_existing_arrays: true, sort_merged_arrays: true })

  template = opt[:template] || cfg['template']

  opt[:duration] ||= cfg['duration'] || false
  opt[:interval_format] ||= cfg['interval_format'] || 'text'

  options = {
    after: opt[:after],
    before: opt[:before],
    count: 0,
    duration: opt[:duration],
    from: opt[:from],
    format: cfg['date_format'],
    interval_format: opt[:interval_format],
    only_timed: opt[:only_timed],
    order: cfg['order'] || :asc,
    output: output,
    section: opt[:section],
    sort_tags: opt[:sort_tags],
    template: template,
    times: times,
    today: true,
    totals: opt[:totals],
    wrap_width: cfg['wrap_width'],
    tags_color: cfg['tags_color'],
    config_template: opt[:config_template]
  }
  list_section(options)
end
verify_duration(date, finish_date, title: nil) click to toggle source
# File lib/doing/wwid.rb, line 1185
def verify_duration(date, finish_date, title: nil)
  max_elapsed = Doing.setting('interaction.confirm_longer_than', 0)
  max_elapsed = max_elapsed.chronify_qty if max_elapsed.is_a?(String)
  date = date.chronify(guess: :end, context: :today) if finish_date.is_a?(String)

  elapsed = finish_date - date

  if max_elapsed.positive? && (elapsed > max_elapsed)
    puts boldwhite(title) if title
    human = elapsed.time_string(format: :natural)
    res = Prompt.yn(yellow("Did this entry actually take #{human}"), default_response: true)
    unless res
      new_elapsed = Prompt.enter_text('How long did it take?').chronify_qty
      raise InvalidTimeExpression, 'Unrecognized time span entry' unless new_elapsed.positive?

      finish_date = date + new_elapsed if new_elapsed
    end
  end

  finish_date
end
views() click to toggle source

List available views

@return [Array] View names

# File lib/doing/wwid.rb, line 1607
def views
  Doing.setting('views') ? Doing.setting('views').keys : []
end
write(file = nil, backup: true) click to toggle source

Write content to file or STDOUT

@param file [String] The filepath to write to

# File lib/doing/wwid.rb, line 1493
def write(file = nil, backup: true)
  Hooks.trigger :pre_write, self, file
  output = combined_content
  if file.nil?
    $stdout.puts output
  else
    Util.write_to_file(file, output, backup: backup)
    run_after if Doing.setting('run_after')
  end
end
yesterday(section, times = nil, output = nil, opt) click to toggle source

Show entries from the previous day

@param section [String] The section @param times (Bool) Show times @param output [String] Output format @param opt [Hash] Additional Options

# File lib/doing/wwid.rb, line 1844
def yesterday(section, times = nil, output = nil, opt)
  opt ||= {}
  opt[:totals] ||= false
  opt[:sort_tags] ||= false
  opt[:config_template] ||= 'today'
  opt[:yesterday] = true

  section = guess_section(section)
  y = (Time.now - (60 * 60 * 24)).strftime('%Y-%m-%d')
  opt[:after] = "#{y} #{opt[:after]}" if opt[:after]
  opt[:before] = "#{y} #{opt[:before]}" if opt[:before]

  opt[:output] = output
  opt[:section] = section
  opt[:times] = times
  opt[:count] = 0

  list_section(opt)
end

Private Instance Methods

combined_content() click to toggle source

Wraps doing file content with additional header/footer content

@return [String] concatenated content

# File lib/doing/wwid.rb, line 2257
def combined_content
  output = @other_content_top ? "#{@other_content_top.join("\n")}\n" : ''
  was_color = Color.coloring?
  Color.coloring = false
  @content.dedup!(match_section: true)
  output += @content.to_s
  output += @other_content_bottom.join("\n") unless @other_content_bottom.nil?
  # Just strip all ANSI colors from the content before writing to doing file
  Color.coloring = was_color

  output.uncolor
end
do_archive(section, destination, opt) click to toggle source

Helper function, performs the actual archiving

@param section [String] The source section @param destination [String] The destination section @param opt [Hash] Additional Options

# File lib/doing/wwid.rb, line 2332
def do_archive(section, destination, opt)
  opt ||= {}
  count = opt[:count] || 0
  tags  = opt[:tags] || []
  bool  = opt[:bool] || :and
  label = opt[:label] || true

  section = guess_section(section)
  destination = guess_section(destination)

  section_items = @content.in_section(section)
  max = section_items.count - count.to_i

  opt[:after] = opt[:from][0] if opt[:from]
  opt[:before] = opt[:from][1] if opt[:from]

  time_rx = /^(\d{1,2}+(:\d{1,2}+)?( *(am|pm))?|midnight|noon)$/

  if opt[:before].is_a?(String) && opt[:before] =~ time_rx
    opt[:before] = opt[:before].chronify(guess: :end, future: false)
  end

  if opt[:after].is_a?(String) && opt[:after] =~ time_rx
    opt[:after] = opt[:after].chronify(guess: :begin, future: false)
  end

  counter = 0

  @content.map do |item|
    break if counter >= max

    next if item.section.downcase == destination.downcase

    next if item.section.downcase != section.downcase && section != /^all$/i

    next if (opt[:before] && item.date > opt[:before]) || (opt[:after] && item.date < opt[:after])

    next if (!tags.empty? && !item.tags?(tags, bool)) || (opt[:search] && !item.search(opt[:search].to_s))

    counter += 1
    old_item = item.clone
    item.move_to(destination, label: label, log: false)
    Hooks.trigger :post_entry_updated, self, item, old_item
    item
  end

  if counter.positive?
    logger.count(destination == 'Archive' ? :archived : :moved,
                 level: :info,
                 count: counter,
                 message: "%count %items from #{section} to #{destination}")
  else
    logger.info('Skipped:', 'No items were moved')
  end
end
output(items, title, is_single, opt) click to toggle source

Generate output using available export plugins

@param items [Array] The items @param title [String] Page title @param is_single [Boolean] Indicates if single section @param opt [Hash] Additional options

@return [String] formatted output based on opt template trigger

# File lib/doing/wwid.rb, line 2282
def output(items, title, is_single, opt)
  logger.benchmark(:output, :start)
  opt ||= {}
  out = nil

  raise InvalidArgument, 'Unknown output format' unless opt[:output] =~ Plugins.plugin_regex(type: :export)

  export_options = { page_title: title, is_single: is_single, options: opt }

  Hooks.trigger :pre_export, self, opt[:output], items

  Plugins.plugins[:export].each do |_, options|
    next unless opt[:output] =~ /^(#{options[:trigger].normalize_trigger})$/i

    out = options[:class].render(self, items, variables: export_options)
    break
  end

  logger.debug('Output:', "#{items.count} #{items.count == 1 ? 'item' : 'items'} shown")
  logger.benchmark(:output, :finish)
  out
end
record_tag_times(item, seconds) click to toggle source

Record times for item tags

@param item [Item] The item to record

# File lib/doing/wwid.rb, line 2310
def record_tag_times(item, seconds)
  item_hash = "#{item.date.strftime('%s')}#{item.title}#{item.section}"
  return if @recorded_items.include?(item_hash)
  item.title.scan(/(?mi)@(\S+?)(\(.*\))?(?=\s|$)/).each do |m|
    k = m[0] == 'done' ? 'All' : m[0].downcase
    if @timers.key?(k)
      @timers[k] += seconds
    else
      @timers[k] = seconds
    end
    @recorded_items.push(item_hash)
  end
end
run_after() click to toggle source
# File lib/doing/wwid.rb, line 2388
def run_after
  return unless Doing.setting('run_after')

  _, stderr, status = Open3.capture3(Doing.setting('run_after'))
  return unless status.exitstatus.positive?

  logger.log_now(:error, 'Script error:', "Error running #{Doing.setting('run_after')}")
  logger.log_now(:error, 'STDERR output:', stderr)
end