doing 2.1.39 → 2.1.42

data/lib/doing/wwid/editor.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+module Doing
+  class WWID
+    ##
+    ## Create a process for an editor and wait for the file handle to return
+    ##
+    ## @param      input  [String] Text input for editor
+    ##
+    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_temp', '.doing'])
+
+      File.open(tmpfile.path, 'w+') do |f|
+        f.puts input
+        unless message.nil?
+          f.puts message == :default ? '# First line is the entry title, lines after 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
+
+    ##
+    ## Takes a multi-line string and formats it as an entry
+    ##
+    ## @param      input  [String] The string to parse
+    ##
+    ## @return     [Array] [[String]title, [Note]note]
+    ##
+    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
+
+    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
+
+    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"
+
+      new_items = fork_editor(input, message: notice).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 the last entry
+    ##
+    ## @param      section  [String] The section, default "All"
+    ##
+    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"))
+      raise UserCancelled, 'No change' if new_item.strip == content.join("\n").strip
+
+      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
+  end
+end

data/lib/doing/wwid/filetools.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+module Doing
+  class WWID
+    ##
+    ## Initializes the doing file.
+    ##
+    ## @param      path  [String] Override path to a doing file, optional
+    ##
+    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*(@[\w\-_.]+\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
+      @initial_content = @content.clone
+    end
+
+    ##
+    ## Create a new doing file
+    ##
+    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
+
+    ##
+    ## Write content to file or STDOUT
+    ##
+    ## @param      file  [String] The filepath to write to
+    ##
+    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
+
+    ##
+    ## Rename doing file with date and start fresh one
+    ##
+    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
+
+    private
+
+    ##
+    ## Wraps doing file content with additional
+    ##             header/footer content
+    ##
+    ## @return     [String] concatenated content
+    ## @api private
+    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
+  end
+end

data/lib/doing/wwid/filter.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+module Doing
+  class WWID
+    # Use fzf to filter an Items object with a search query.
+    # Faster than {#filter_items} when all you need is a
+    # text search of the title and note
+    #
+    # @param      items      [Items] an Items object
+    # @param      query      [String] The search query
+    # @param      case_type  [Symbol] The case type (:smart, :sensitive, :ignore)
+    #
+    # @return     [Items] Filtered Items array
+    #
+    def fuzzy_filter_items(items, query, case_type: :smart)
+      scannable = items.map.with_index { |item, idx| "#{item.title} #{item.note.join(' ')}".gsub(/[|*?!]/, '') + "|#{idx}"  }.join("\n")
+
+      fzf_args = [
+        '--multi',
+        %(--filter="#{query.sub(/^'?/, "'")}"),
+        '--no-sort',
+        '-d "\|"',
+        '--nth=1'
+      ]
+      fzf_args << case case_type.normalize_case
+                  when :smart
+                    query =~ /[A-Z]/ ? '+i' : '-i'
+                  when :sensitive
+                    '+i'
+                  when :ignore
+                    '-i'
+                  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
+
+    ##
+    ## 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
+    ##
+    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
+
+      unless 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]
+          cutoff = if before =~ time_rx
+                     "#{item.date.strftime('%Y-%m-%d')} #{before}".chronify(guess: :begin)
+                   elsif before.is_a?(String)
+                     before.chronify(guess: :begin)
+                   else
+                     before
+                   end
+          keep = cutoff && item.date <= cutoff
+          keep = opt[:not] ? !keep : keep
+        end
+
+        if keep && opt[:after]
+          after = opt[:after]
+          cutoff = if after =~ time_rx
+                     "#{item.date.strftime('%Y-%m-%d')} #{after}".chronify(guess: :end)
+                   elsif after.is_a?(String)
+                     after.chronify(guess: :end)
+                   else
+                     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
+  end
+end

data/lib/doing/wwid/guess.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Doing
+  class WWID
+    ##
+    ## Attempt to match a string with an existing section
+    ##
+    ## @param      frag     [String] The user-provided string
+    ## @param      guessed  [Boolean] already guessed and failed
+    ##
+    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)
+
+      found = @content.guess_section(frag, distance: 2)
+
+      section = found ? found.title : nil
+
+      return section if suggest
+
+      unless section || guessed
+        alt = guess_view(frag, guessed: true, suggest: true)
+        if alt
+          prompt = Color.template("{bw}Did you mean `{xy}doing {by}view {xy}#{alt}`{bw}?{x}")
+          meant_view = Prompt.yn(prompt, default_response: 'n')
+
+          msg = format('%<y>srun with `%<w>sdoing view %<alt>s%<y>s`', w: boldwhite, y: yellow, alt: alt)
+          raise Errors::WrongCommand.new(msg, 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 Errors::InvalidSection.new("unknown section #{frag.bold.white}", topic: 'Missing:')
+      end
+      section ? section.cap_first : guessed
+    end
+
+    ##
+    ## Attempt to match a string with an existing view
+    ##
+    ## @param      frag     [String] The user-provided string
+    ## @param      guessed  [Boolean] already guessed
+    ##
+    def guess_view(frag, guessed: false, suggest: false)
+      views.each { |view| return view if frag.downcase == view.downcase }
+      view = nil
+      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 Errors::InvalidView.new(%(unknown view #{frag.bold.white}), topic: 'Missing:') unless alt
+
+        prompt = Color.template("{bw}Did you mean `{xy}doing {by}show {xy}#{alt}`{bw}?{x}")
+        meant_view = Prompt.yn(prompt, default_response: 'n')
+
+        if meant_view
+          msg = format('%<y>srun with `%<w>sdoing show %<alt>s%<y>s`', w: boldwhite, y: yellow, alt: alt)
+          raise Errors::WrongCommand.new(msg, topic: 'Try again:')
+
+        end
+
+        raise Errors::InvalidView.new(%(unknown view #{alt.bold.white}), topic: 'Missing:')
+
+      end
+      view
+    end
+  end
+end