na 1.2.34 → 1.2.37

data/bin/commands/undo.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+class App
+  extend GLI::App
+  desc 'Undo the last change'
+  long_desc 'Run without argument to undo most recent change'
+  arg_name 'FILE', optional: true, multiple: true
+  command %i[undo] do |c|
+    c.example 'na undo', desc: 'Undo the last change'
+    c.example 'na undo myproject', desc: 'Undo the last change to a file matching "myproject"'
+
+    c.action do |_global_options, options, args|
+      if args.empty?
+        NA.restore_last_modified_file
+      else
+        args.each do |arg|
+          NA.restore_last_modified_file(search: arg)
+        end
+      end
+    end
+  end
+end

data/bin/commands/update.rb

@@ -63,7 +63,7 @@ class App
     c.desc 'Delete an action'
     c.switch %i[delete], negatable: false
 
-    c.desc "Open action in editor (#{NA.default_editor}).
+    c.desc "Open action in editor (#{NA::Editor.default_editor}).
             Natural language dates will be parsed and converted in date-based tags."
     c.switch %i[edit], negatable: false
 
@@ -97,6 +97,8 @@ class App
         options[:tagged] << '+done'
       elsif !options[:remove].nil? && !options[:remove].empty?
         options[:tagged].concat(options[:remove])
+      elsif options[:finish]
+        options[:tagged] << '-done'
       end
 
       action = if args.count.positive?
@@ -211,7 +213,15 @@ class App
 
         end
       else
-        files = NA.find_files(depth: options[:depth])
+        files = NA.find_files_matching({
+                                        depth: options[:depth],
+                                        done: options[:done],
+                                        project: target_proj,
+                                        regex: options[:regex],
+                                        require_na: false,
+                                        search: tokens,
+                                        tag: tags
+                                      })
         NA.notify('{r}No todo file found', exit_code: 1) if files.count.zero?
 
         targets = files.count > 1 ? NA.select_file(files, multiple: true) : [files[0]]

data/lib/na/action.rb

@@ -18,6 +18,32 @@ module NA
       @note = note
     end
 
+    def process(priority: 0, finish: false, add_tag: [], remove_tag: [], note: [])
+      string = @action.dup
+
+      if priority&.positive?
+        string.gsub!(/(?<=\A| )@priority\(\d+\)/, '').strip!
+        string += " @priority(#{priority})"
+      end
+
+      add_tag.each do |tag|
+        string.gsub!(/(?<=\A| )@#{tag.gsub(/([()*?])/, '\\\\1')}(\(.*?\))?/, '')
+        string.strip!
+        string += " @#{tag}"
+      end
+
+      remove_tag.each do |tag|
+        string.gsub!(/(?<=\A| )@#{tag.gsub(/([()*?])/, '\\\\1')}(\(.*?\))?/, '')
+        string.strip!
+      end
+
+      string = "#{string.strip} @done(#{Time.now.strftime('%Y-%m-%d %H:%M')})" if finish && string !~ /(?<=\A| )@done/
+
+      @action = string
+      @action.expand_date_tags
+      @note = note unless note.empty?
+    end
+
     def to_s
       note = if @note.count.positive?
                "\n#{@note.join("\n")}"
@@ -37,7 +63,18 @@ module NA
       EOINSPECT
     end
 
+    ##
+    ## Pretty print an action
+    ##
+    ## @param      extension  [String] The file extension
+    ## @param      template   [Hash] The template to use for
+    ##                        colorization
+    ## @param      regexes    [Array] The regexes to
+    ##                        highlight (searches)
+    ## @param      notes      [Boolean] Include notes
+    ##
     def pretty(extension: 'taskpaper', template: {}, regexes: [], notes: false)
+      # Default colorization, can be overridden with full or partial template variable
       default_template = {
         file: '{xbk}',
         parent: '{c}',
@@ -51,32 +88,38 @@ module NA
         note: '{dw}'
       }
       template = default_template.merge(template)
-
+      # Create the hierarchical parent string
       parents = @parent.map do |par|
         NA::Color.template("#{template[:parent]}#{par}")
       end.join(NA::Color.template(template[:parent_divider]))
       parents = "{dc}[{x}#{parents}{dc}]{x} "
 
+      # Create the project string
       project = NA::Color.template("#{template[:project]}#{@project}{x} ")
 
+      # Create the source filename string, substituting ~ for HOME and removing extension
       file = @file.sub(%r{^\./}, '').sub(/#{ENV['HOME']}/, '~')
       file = file.sub(/\.#{extension}$/, '')
+      # colorize the basename
       file = file.sub(/#{File.basename(@file, ".#{extension}")}$/, "{dw}#{File.basename(@file, ".#{extension}")}{x}")
       file_tpl = "#{template[:file]}#{file} {x}"
       filename = NA::Color.template(file_tpl)
 
+      # Add notes if needed
       note = if notes && @note.count.positive?
                NA::Color.template("\n#{@note.map { |l| "  #{template[:note]}• #{l}{x}" }.join("\n")}")
              else
                ''
              end
 
+      # colorize the action and highlight tags
       action = NA::Color.template("#{template[:action]}#{@action.sub(/ @#{NA.na_tag}\b/, '')}{x}")
       action = action.highlight_tags(color: template[:tags],
                                      parens: template[:value_parens],
                                      value: template[:values],
                                      last_color: template[:action])
 
+      # Replace variables in template string and output colorized
       NA::Color.template(template[:output].gsub(/%filename/, filename)
                           .gsub(/%project/, project)
                           .gsub(/%parents?/, parents)
@@ -162,7 +205,7 @@ module NA
           date = Time.parse(date.strftime('%Y-%m-%d 12:00'))
         end
 
-        puts "Comparing #{tag_date} #{tag[:comp]} #{date}" if NA.verbose
+        # NA.notify("{dw}Comparing #{tag_date} #{tag[:comp]} #{date}{x}", debug: true)
 
         case tag[:comp]
         when /^>$/

data/lib/na/actions.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module NA
+  # Actions controller
+  class Actions < Array
+    def initialize(actions = [])
+      super
+      concat(actions)
+    end
+
+    ##
+    ## Pretty print a list of actions
+    ##
+    ## @param      actions  [Array] The actions
+    ## @param      depth    [Number] The depth
+    ## @param      files    [Array] The files actions originally came from
+    ## @param      regexes  [Array] The regexes used to gather actions
+    ##
+    def output(depth, files: nil, regexes: [], notes: false, nest: false, nest_projects: false)
+      return if files.nil?
+
+      if nest
+        template = '%parent%action'
+
+        parent_files = {}
+        out = []
+
+        if nest_projects
+          each do |action|
+            if parent_files.key?(action.file)
+              parent_files[action.file].push(action)
+            else
+              parent_files[action.file] = [action]
+            end
+          end
+
+          parent_files.each do |file, acts|
+            projects = NA.project_hierarchy(acts)
+            out.push("#{file.sub(%r{^./}, '').shorten_path}:")
+            out.concat(NA.output_children(projects, 0))
+          end
+        else
+          template = '%parent%action'
+
+          each do |action|
+            if parent_files.key?(action.file)
+              parent_files[action.file].push(action)
+            else
+              parent_files[action.file] = [action]
+            end
+          end
+
+          parent_files.each do |k, v|
+            out.push("#{k.sub(%r{^\./}, '')}:")
+            v.each do |a|
+              out.push("\t- [#{a.parent.join('/')}] #{a.action}")
+              out.push("\t\t#{a.note.join("\n\t\t")}") unless a.note.empty?
+            end
+          end
+        end
+        NA::Pager.page out.join("\n")
+      else
+        template = if files.count.positive?
+                     if files.count == 1
+                       '%parent%action'
+                     else
+                       '%filename%parent%action'
+                     end
+                   elsif NA.find_files(depth: depth).count > 1
+                     if depth > 1
+                       '%filename%parent%action'
+                     else
+                       '%project%parent%action'
+                     end
+                   else
+                     '%parent%action'
+                   end
+        template += '%note' if notes
+
+        files.map { |f| NA.notify("{dw}#{f}", debug: true) } if files
+
+        output = map { |action| action.pretty(template: { output: template }, regexes: regexes, notes: notes) }
+        NA::Pager.page(output.join("\n"))
+      end
+    end
+  end
+end

data/lib/na/editor.rb

@@ -0,0 +1,123 @@
+module NA
+  module Editor
+    class << self
+      def default_editor
+        editor ||= ENV['NA_EDITOR'] || ENV['GIT_EDITOR'] || ENV['EDITOR']
+
+        if editor.good? && TTY::Which.exist?(editor)
+          return editor
+        end
+
+        notify('No EDITOR environment variable, testing available editors', debug: true)
+        editors = %w[vim vi code subl mate mvim nano emacs]
+        editors.each do |ed|
+          try = TTY::Which.which(ed)
+          if try
+            notify("Using editor #{try}", debug: true)
+            return try
+          end
+        end
+
+        notify('{br}No editor found{x}', exit_code: 5)
+
+        nil
+      end
+
+      def editor_with_args
+        args_for_editor(default_editor)
+      end
+
+      def args_for_editor(editor)
+        return editor if editor =~ /-\S/
+
+        args = case editor
+               when /^(subl|code|mate)$/
+                 ['-w']
+               when /^(vim|mvim)$/
+                 ['-f']
+               else
+                 []
+               end
+        "#{editor} #{args.join(' ')}"
+      end
+
+      ##
+      ## 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']
+
+        notify('{br}No EDITOR variable defined in environment{x}', exit_code: 5) if default_editor.nil?
+
+        tmpfile = Tempfile.new(['na_temp', '.na'])
+
+        File.open(tmpfile.path, 'w+') do |f|
+          f.puts input
+          unless message.nil?
+            f.puts message == :default ? '# First line is the action, lines after are added as a note' : message
+          end
+        end
+
+        pid = Process.fork { system("#{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)
+        notify('No content in entry', exit_code: 1) if input.nil? || input.strip.empty?
+
+        input_lines = input.split(/[\n\r]+/).delete_if(&:ignore?)
+        title = input_lines[0]&.strip
+        notify('{br}No content in first line{x}', exit_code: 1) if title.nil? || title.strip.empty?
+
+        title.expand_date_tags
+
+        note = if input_lines.length > 1
+                 input_lines[1..-1]
+               else
+                 []
+               end
+
+        unless note.empty?
+          note.map!(&:strip)
+          note.delete_if { |l| l =~ /^\s*$/ || l =~ /^#/ }
+        end
+
+        [title, note]
+      end
+    end
+  end
+end