doing 2.1.39 → 2.1.40

data/lib/doing/wwid/editor.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+module Doing
+  class WWID
+    # Editor methods for WWID class
+    module Editor
+      ##
+      ## 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', '.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
+
+      ##
+      ## 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\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 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"))
+        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
+end

data/lib/doing/wwid/filetools.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+module Doing
+  # File methods for WWID class
+  class WWID
+    module FileTools
+      ##
+      ## 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*(@\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
+        @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
+end

data/lib/doing/wwid/filter.rb

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+module Doing
+  class WWID
+    # Filter methods for WWID class
+    module Filter
+      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
+
+      ##
+      ## 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
+
+        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]
+            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
+end

data/lib/doing/wwid/guess.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Doing
+  class WWID
+    # Section and view guessing methods for WWID class
+    module Guess
+      ##
+      ## 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 = 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 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
+end