na 1.1.26 → 1.2.0

data/bin/na

@@ -95,13 +95,16 @@ class App
               end
 
       if args.count.positive?
+        all_req = false
+
         tokens = []
         args.each do |arg|
           arg.split(/ *, */).each do |a|
-            m = a.match(/^(?<req>\+)?(?<tok>.*?)$/)
+            m = a.match(/^(?<req>[+\-!])?(?<tok>.*?)$/)
             tokens.push({
                           token: m['tok'],
-                          required: !m['req'].nil?
+                          required: all_req || (!m['req'].nil? && m['req'] == '+'),
+                          negate: !m['req'].nil? && m['req'] =~ /[!\-]/
                         })
           end
         end
@@ -110,12 +113,12 @@ class App
       NA.na_tag = options[:tag] unless options[:tag].nil?
       require_na = true
 
-      tag = [{ tag: tag, value: nil }]
-      files, actions = NA.parse_actions(depth: depth,
-                                        query: tokens,
-                                        tag: tag,
-                                        project: options[:project],
-                                        require_na: require_na)
+      tag = [{ tag: tag, value: nil }, { tag: 'done', value: nil, negate: true}]
+      files, actions, = NA.parse_actions(depth: depth,
+                                         query: tokens,
+                                         tag: tag,
+                                         project: options[:project],
+                                         require_na: require_na)
 
       NA.output_actions(actions, depth, files: files)
     end
@@ -146,7 +149,11 @@ class App
     c.desc 'Add action to specific project'
     c.arg_name 'PROJECT'
     c.default_value 'Inbox'
-    c.flag %i[to]
+    c.flag %i[to project proj]
+
+    c.desc 'Add to a known todo file, partial matches allowed'
+    c.arg_name 'TODO_FILE'
+    c.flag %i[in todo]
 
     c.desc 'Use a tag other than the default next action tag'
     c.arg_name 'TAG'
@@ -183,7 +190,7 @@ class App
         action = "#{action.gsub(/@priority\(\d+\)/, '')} @priority(#{options[:priority]})"
       end
 
-      note_rx = /^(.+)\((.*?)\)$/
+      note_rx = /^(.+) \((.*?)\)$/
       split_note = if action =~ note_rx
                      n = Regexp.last_match(2)
                      action.sub!(note_rx, '\1').strip!
@@ -229,6 +236,34 @@ class App
             Process.exit 1
           end
         end
+      elsif options[:todo]
+        todo = []
+        options[:todo].split(/ *, */).each do |a|
+          m = a.match(/^(?<req>\+)?(?<tok>.*?)$/)
+          todo.push({
+                      token: m['tok'],
+                      required: !m['req'].nil?
+                    })
+        end
+        dirs = NA.match_working_dir(todo)
+        if dirs.count.positive?
+          target = dirs[0]
+        else
+          todo = "#{options[:todo].sub(/#{NA.extension}$/, '')}.#{NA.extension}"
+          target = File.expand_path(todo)
+          unless File.exist?(target)
+
+            res = NA.yn(NA::Color.template("{by}Specified file not found, create #{todo}"), default: true)
+            if res
+              basename = File.basename(target, ".#{NA.extension}")
+              NA.create_todo(target, basename)
+            else
+              NA.notify('{r}Cancelled{x}', exit_code: 1)
+
+            end
+          end
+
+        end
       else
         files = NA.find_files(depth: options[:depth])
         if files.count.zero?
@@ -243,12 +278,209 @@ class App
         end
         target = files.count > 1 ? NA.select_file(files) : files[0]
         unless files.count.positive? && File.exist?(target)
-          puts NA::Color.template('{r}Cancelled{x}')
-          Process.exit 1
+          NA.notify('{r}Cancelled{x}', exit_code: 1)
+
+        end
+      end
+
+      NA.add_action(target, options[:project], action, note)
+    end
+  end
+
+  desc 'Update an existing action'
+  long_desc 'Provides an easy way to complete, prioritize, and tag existing actions.
+
+  If multiple todo files are found in the current directory, a menu will
+  allow you to pick which file to act on.'
+  arg_name 'ACTION'
+  command %i[update] do |c|
+    c.example 'na update --remove na "An existing task"', desc: 'Find "An existing task" action and remove the @na tag from it'
+    c.example 'na update --tag waiting "A bug I need to fix" -p 4 -n',
+              desc: 'Find "A bug..." action, add @waiting, add/update @priority(4), and prompt for an additional note'
+    c.example 'na update --archive My cool action', desc: 'Add @done to "My cool action" and immediately move to Archive'
+
+    c.desc 'Prompt for additional notes. Input will be appended to any existing note.'
+    c.switch %i[n note], negatable: false
+
+    c.desc 'Overwrite note instead of appending'
+    c.switch %i[o overwrite], negatable: false
+
+    c.desc 'Add/change a priority level 1-5'
+    c.arg_name 'PRIO'
+    c.flag %i[p priority], must_match: /[1-5]/, type: :integer, default_value: 0
+
+    c.desc 'Move action to specific project'
+    c.arg_name 'PROJECT'
+    c.flag %i[to project proj]
+
+    c.desc 'Use a known todo file, partial matches allowed'
+    c.arg_name 'TODO_FILE'
+    c.flag %i[in todo]
+
+    c.desc 'Add a tag to the action, @tag(values) allowed'
+    c.arg_name 'TAG'
+    c.flag %i[t tag], multiple: true
+
+    c.desc 'Remove a tag to the action'
+    c.arg_name 'TAG'
+    c.flag %i[r remove], multiple: true
+
+    c.desc 'Add a @done tag to action'
+    c.switch %i[f finish done], negatable: false
+
+    c.desc 'Add a @done tag to action and move to Archive'
+    c.switch %i[a archive], negatable: false
+
+    c.desc 'Delete an action'
+    c.switch %i[delete], negatable: false
+
+    c.desc 'Specify the file to search for the task'
+    c.arg_name 'PATH'
+    c.flag %i[file]
+
+    c.desc 'Search for files X directories deep'
+    c.arg_name 'DEPTH'
+    c.flag %i[d depth], must_match: /^[1-9]$/, type: :integer, default_value: 1
+
+    c.desc 'Match actions containing tag. Allows value comparisons'
+    c.arg_name 'TAG'
+    c.flag %i[tagged], multiple: true
+
+    c.desc 'Act on all matches immediately (no menu)'
+    c.switch %i[all], negatable: false
+
+    c.desc 'Interpret search pattern as regular expression'
+    c.switch %i[e regex], negatable: false
+
+    c.desc 'Match pattern exactly'
+    c.switch %i[x exact], negatable: false
+
+    c.action do |_global_options, options, args|
+      reader = TTY::Reader.new
+      action = if args.count.positive?
+                 args.join(' ').strip
+               elsif TTY::Which.exist?('gum') && options[:tagged].empty?
+                 options = [
+                   %(--placeholder "Enter a task to search for"),
+                   '--char-limit=500',
+                   "--width=#{TTY::Screen.columns}"
+                 ]
+                 `gum input #{options.join(' ')}`.strip
+               elsif options[:tagged].empty?
+                 puts NA::Color.template('{bm}Enter search string:{x}')
+                 reader.read_line(NA::Color.template('{by}> {bw}')).strip
+               end
+
+      if action
+        tokens = nil
+        if options[:exact]
+          tokens = action
+        elsif options[:regex]
+          tokens = Regexp.new(action, Regexp::IGNORECASE)
+        else
+          tokens = []
+          all_req = action !~ /[+!\-]/ && !options[:or]
+
+          action.split(/ /).each do |arg|
+            m = arg.match(/^(?<req>[+\-!])?(?<tok>.*?)$/)
+            tokens.push({
+                          token: m['tok'],
+                          required: all_req || (!m['req'].nil? && m['req'] == '+'),
+                          negate: !m['req'].nil? && m['req'] =~ /[!\-]/
+                        })
+          end
+        end
+      end
+
+      if (action.nil? || action.empty?) && options[:tagged].empty?
+        puts 'Empty input, cancelled'
+        Process.exit 1
+      end
+
+      all_req = options[:tagged].join(' ') !~ /[+!\-]/ && !options[:or]
+      tags = []
+      options[:tagged].join(',').split(/ *, */).each do |arg|
+        m = arg.match(/^(?<req>[+\-!])?(?<tag>[^ =<>$\^]+?)(?:(?<op>[=<>]{1,2}|[*$\^]=)(?<val>.*?))?$/)
+
+        tags.push({
+                    tag: m['tag'].wildcard_to_rx,
+                    comp: m['op'],
+                    value: m['val'],
+                    required: all_req || (!m['req'].nil? && m['req'] == '+'),
+                    negate: !m['req'].nil? && m['req'] =~ /[!\-]/
+                  })
+      end
+
+      priority = options[:priority].to_i if options[:priority]&.to_i&.positive?
+      add_tags = options[:tag].map { |t| t.sub(/^@/, '').wildcard_to_rx }
+      remove_tags = options[:remove].map { |t| t.sub(/^@/, '').wildcard_to_rx }
+
+      line_note = if options[:note]
+                    if TTY::Which.exist?('gum')
+                      args = ['--placeholder "Enter a note, CTRL-d to save"']
+                      args << '--char-limit 0'
+                      args << '--width $(tput cols)'
+                      `gum write #{args.join(' ')}`.strip.split("\n")
+                    else
+                      puts NA::Color.template('{bm}Enter a note, {bw}CTRL-d{bm} to end editing{bw}')
+                      reader.read_multiline
+                    end
+                  end
+
+      note = line_note.nil? || line_note.empty? ? [] : line_note
+
+      if options[:file]
+        file = File.expand_path(options[:file])
+        NA.notify('{r}File not found', exit_code: 1) unless File.exist?(file)
+
+        targets = [file]
+      elsif options[:todo]
+        todo = []
+        options[:todo].split(/ *, */).each do |a|
+          m = a.match(/^(?<req>\+)?(?<tok>.*?)$/)
+          todo.push({
+                      token: m['tok'],
+                      required: !m['req'].nil?
+                    })
+        end
+        dirs = NA.match_working_dir(todo)
+
+        if dirs.count == 1
+          targets = [dirs[0]]
+        elsif dirs.count.positive?
+          targets = NA.select_file(dirs, multiple: true)
+          NA.notify('{r}Cancelled', exit_code: 1) unless targets && targets.count.positive?
+        else
+          NA.notify('{r}Todo not found', exit_code: 1) unless targets && targets.count.positive?
+
         end
+      else
+        files = NA.find_files(depth: options[:depth])
+        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]]
+        NA.notify('{r}Cancelled{x}', exit_code: 1) unless files.count.positive?
+
       end
 
-      NA.add_action(target, options[:to], action, note)
+      options[:finish] = true if options[:archive]
+      options[:project] = 'Archive' if options[:archive]
+
+      NA.notify('{r}No search terms provided', exit_code: 1) if tokens.nil? && options[:tagged].empty?
+
+      targets.each do |target|
+        NA.update_action(target, tokens,
+                         priority: priority,
+                         add_tag: add_tags,
+                         remove_tag: remove_tags,
+                         finish: options[:finish],
+                         project: options[:project],
+                         delete: options[:delete],
+                         note: note,
+                         overwrite: options[:overwrite],
+                         tagged: tags,
+                         all: options[:all])
+      end
     end
   end
 
@@ -291,7 +523,7 @@ class App
     c.action do |global_options, options, args|
       if options[:save]
         title = options[:save].gsub(/[^a-z0-9]/, '_').gsub(/_+/, '_')
-        NA.save_search(title, "find #{NA.command_line.map { |c| "\"#{c}\"" }.join(' ')}")
+        NA.save_search(title, "find #{NA.command_line.map { |cmd| "\"#{cmd}\"" }.join(' ')}")
       end
 
       depth = if global_options[:recurse] && options[:depth].nil? && global_options[:depth] == 1
@@ -324,24 +556,24 @@ class App
         options[:in].split(/ *, */).each do |a|
           m = a.match(/^(?<req>\+)?(?<tok>.*?)$/)
           todo.push({
-                        token: m['tok'],
-                        required: !m['req'].nil?
-                      })
+                      token: m['tok'],
+                      required: !m['req'].nil?
+                    })
         end
       end
 
-      files, actions = NA.parse_actions(depth: depth,
-                                        query: todo,
-                                        search: tokens,
-                                        negate: options[:invert],
-                                        regex: options[:regex],
-                                        project: options[:project],
-                                        require_na: false)
-      if tokens.is_a?(Array)
-        regexes = tokens.delete_if { |token| token[:negate] }.map { |token| token[:token] }
-      else
-        regexes = [tokens]
-      end
+      files, actions, = NA.parse_actions(depth: depth,
+                                         query: todo,
+                                         search: tokens,
+                                         negate: options[:invert],
+                                         regex: options[:regex],
+                                         project: options[:project],
+                                         require_na: false)
+      regexes = if tokens.is_a?(Array)
+                  tokens.delete_if { |token| token[:negate] }.map { |token| token[:token] }
+                else
+                  [tokens]
+                end
 
       NA.output_actions(actions, depth, files: files, regexes: regexes)
     end
@@ -401,7 +633,6 @@ class App
 
       all_req = args.join(' ') !~ /[+!\-]/ && !options[:or]
       args.join(',').split(/ *, */).each do |arg|
-        # TODO: <> comparisons do nothing right now
         m = arg.match(/^(?<req>[+\-!])?(?<tag>[^ =<>$\^]+?)(?:(?<op>[=<>]{1,2}|[*$\^]=)(?<val>.*?))?$/)
 
         tags.push({
@@ -413,6 +644,10 @@ class App
                   })
       end
 
+      search_for_done = false
+      tags.each { |tag| search_for_done = true if tag[:tag] =~ /done/ }
+      tags.push({ tag: 'done', value: nil, negate: true}) unless search_for_done
+
       todo = nil
       if options[:in]
         todo = []
@@ -425,12 +660,12 @@ class App
         end
       end
 
-      files, actions = NA.parse_actions(depth: depth,
-                                        query: todo,
-                                        tag: tags,
-                                        negate: options[:invert],
-                                        project: options[:project],
-                                        require_na: false)
+      files, actions, = NA.parse_actions(depth: depth,
+                                         query: todo,
+                                         tag: tags,
+                                         negate: options[:invert],
+                                         project: options[:project],
+                                         require_na: false)
       regexes = tags.delete_if { |token| token[:negate] }.map { |token| token[:token] }
       NA.output_actions(actions, depth, files: files, regexes: regexes)
     end
@@ -484,13 +719,15 @@ class App
     c.arg_name 'EDITOR'
     c.flag %i[a app]
 
-    c.action do |global_options, options, _args|
+    c.action do |global_options, options, args|
       depth = if global_options[:recurse] && options[:depth].nil? && global_options[:depth] == 1
                 3
               else
                 options[:depth].nil? ? global_options[:depth].to_i : options[:depth].to_i
               end
       files = NA.find_files(depth: depth)
+      files.delete_if { |f| f !~ /.*?(#{args.join('|')}).*?.#{NA.extension}/ } if args.count.positive?
+
       file = if files.count > 1
                NA.select_file(files)
              else
@@ -513,13 +750,16 @@ class App
   command %i[todos] do |c|
     c.action do |_global_options, _options, args|
       if args.count.positive?
-        tokens = []
+        all_req = args.join(' ') !~ /[+!\-]/
+
+        tokens = [{ token: '*', required: all_req, negate: false }]
         args.each do |arg|
           arg.split(/ *, */).each do |a|
-            m = a.match(/^(?<req>\+)?(?<tok>.*?)$/)
+            m = a.match(/^(?<req>[+\-!])?(?<tok>.*?)$/)
             tokens.push({
                           token: m['tok'],
-                          required: !m['req'].nil?
+                          required: all_req || (!m['req'].nil? && m['req'] == '+'),
+                          negate: !m['req'].nil? && m['req'] =~ /[!\-]/
                         })
           end
         end
@@ -529,6 +769,39 @@ class App
     end
   end
 
+  desc 'Show list of projects for a file'
+  long_desc 'Arguments will be interpreted as a query for a known todo file,
+  fuzzy matched. Separate directories with /, :, or a space, e.g. `na projects code/marked`'
+  arg_name 'QUERY', optional: true
+  command %i[projects] do |c|
+    c.desc 'Search for files X directories deep'
+    c.arg_name 'DEPTH'
+    c.flag %i[d depth], must_match: /^[1-9]$/, type: :integer, default_value: 1
+
+    c.desc 'Output projects as paths instead of hierarchy'
+    c.switch %i[p paths], negatable: false
+
+    c.action do |_global_options, options, args|
+      if args.count.positive?
+        all_req = args.join(' ') !~ /[+!\-]/
+
+        tokens = [{ token: '*', required: all_req, negate: false }]
+        args.each do |arg|
+          arg.split(/ *, */).each do |a|
+            m = a.match(/^(?<req>[+\-!])?(?<tok>.*?)$/)
+            tokens.push({
+                          token: m['tok'],
+                          required: all_req || (!m['req'].nil? && m['req'] == '+'),
+                          negate: !m['req'].nil? && m['req'] =~ /[!\-]/
+                        })
+          end
+        end
+      end
+
+      NA.list_projects(query: tokens, depth: options[:depth], paths: options[:paths])
+    end
+  end
+
   desc 'Show or install prompt hooks for the current shell'
   long_desc 'Installing the prompt hook allows you to automatically
   list next actions when you cd into a directory'
@@ -581,12 +854,30 @@ class App
   long_desc 'Run without argument to list saved searches'
   arg_name 'SEARCH_TITLE', optional: true
   command %i[saved] do |c|
-    c.action do |_global_options, _options, args|
+    c.example 'na saved overdue', description: 'perform the search named "overdue"'
+    c.example 'na saved over', description: 'perform the search named "overdue", assuming no other searches match "over"'
+    c.example 'na saved', description: 'list available searches'
+
+    c.desc 'Open the saved search file in $EDITOR'
+    c.switch %i[e edit]
+
+    c.desc 'Delete the specified search definition'
+    c.switch %i[d delete]
+
+    c.action do |_global_options, options, args|
+      if options[:edit]
+        NA.edit_searches
+      end
+
       searches = NA.load_searches
       if args.empty?
         NA.notify("{bg}Saved searches stored in {bw}#{NA.database_path(file: 'saved_searches.yml')}")
         NA.notify(searches.map { |k, v| "{y}#{k}: {w}#{v}" }.join("\n"), exit_code: 0)
       else
+        if options[:delete]
+          NA.delete_search(args)
+        end
+
         keys = searches.keys.delete_if { |k| k !~ /#{args[0]}/ }
         NA.notify("{r}Search #{args[0]} not found", exit_code: 1) if keys.empty?
 

data/lib/na/action.rb

@@ -2,20 +2,22 @@
 
 module NA
   class Action < Hash
-    attr_reader :file, :project, :parent, :action, :tags
+    attr_reader :file, :project, :parent, :action, :tags, :line, :note
 
-    def initialize(file, project, parent, action)
+    def initialize(file, project, parent, action, idx, note = [])
       super()
 
       @file = file
       @project = project
       @parent = parent
-      @action = action
+      @action = action.gsub(/\{/, '\\{')
       @tags = scan_tags
+      @line = idx
+      @note = note
     end
 
     def to_s
-      "(#{@file}) #{@project}:#{@parent.join('>')} | #{@action}"
+      "(#{@file}:#{@line}) #{@project}:#{@parent.join('>')} | #{@action}"
     end
 
     def inspect
@@ -41,14 +43,10 @@ module NA
       }
       template = default_template.merge(template)
 
-      if @parent != ['Inbox']
-        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} "
-      else
-        parents = ''
-      end
+      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} "
 
       project = NA::Color.template("#{template[:project]}#{@project}{x} ")
 
@@ -67,7 +65,7 @@ module NA
       NA::Color.template(template[:output].gsub(/%filename/, filename)
                           .gsub(/%project/, project)
                           .gsub(/%parents?/, parents)
-                          .gsub(/%action/, action.highlight_search(regexes)))
+                          .gsub(/%action/, action.highlight_search(regexes))).gsub(/\\\{/, '{')
     end
 
     def tags_match?(any: [], all: [], none: [])

data/lib/na/colors.rb

@@ -226,8 +226,9 @@ module NA
       ##
       def template(input)
         input = input.join(' ') if input.is_a? Array
+
         fmt = input.gsub(/%/, '%%')
-        fmt = fmt.gsub(/(?<!\\u)\{(\w+)\}/i) do
+        fmt = fmt.gsub(/(?<!\\)\{(\w+)\}/i) do
           Regexp.last_match(1).split('').map { |c| "%<#{c}>s" }.join('')
         end