na 1.2.29 → 1.2.31

data/bin/commands/changes.rb

@@ -1,19 +1,22 @@
 # frozen_string_literal: true
 
-desc 'Display the changelog'
-command %i[changes changelog] do |c|
-  c.action do |_, _, _|
-    changelog = File.expand_path(File.join(File.dirname(__FILE__), '..', 'CHANGELOG.md'))
-    pagers = [
-      'mdless',
-      'mdcat',
-      'bat',
-      ENV['PAGER'],
-      'less -FXr',
-      ENV['GIT_PAGER'],
-      'more -r'
-    ]
-    pager = pagers.find { |cmd| TTY::Which.exist?(cmd.split.first) }
-    system %(#{pager} "#{changelog}")
+class App
+  extend GLI::App
+  desc 'Display the changelog'
+  command %i[changes changelog] do |c|
+    c.action do |_, _, _|
+      changelog = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'CHANGELOG.md'))
+      pagers = [
+        'mdless',
+        'mdcat',
+        'bat',
+        ENV['PAGER'],
+        'less -FXr',
+        ENV['GIT_PAGER'],
+        'more -r'
+      ]
+      pager = pagers.find { |cmd| TTY::Which.exist?(cmd.split.first) }
+      system %(#{pager} "#{changelog}")
+    end
   end
 end

data/bin/commands/complete.rb

@@ -1,51 +1,54 @@
 # frozen_string_literal: true
 
-desc 'Find and mark an action as @done'
-arg_name 'ACTION'
-command %i[complete finish] do |c|
-  c.example 'na complete "An existing task"',
-            desc: 'Find "An existing task" and mark @done'
-  c.example 'na finish "An existing task"',
-            desc: 'Alias for complete'
-
-  c.desc 'Prompt for additional notes. Input will be appended to any existing note.
-  If STDIN input (piped) is detected, it will be used as a 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 a @done tag to action and move to Archive'
-  c.switch %i[a archive], 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, args|
-    options[:finish] = true
-    options[:f] = true
-    options[:project] = 'Archive' if options[:archive]
-
-    cmd = commands[:update]
-    action = cmd.send(:get_action, nil)
-    action.call(global, options, args)
+class App
+  extend GLI::App
+  desc 'Find and mark an action as @done'
+  arg_name 'ACTION'
+  command %i[complete finish] do |c|
+    c.example 'na complete "An existing task"',
+              desc: 'Find "An existing task" and mark @done'
+    c.example 'na finish "An existing task"',
+              desc: 'Alias for complete'
+
+    c.desc 'Prompt for additional notes. Input will be appended to any existing note.
+    If STDIN input (piped) is detected, it will be used as a 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 a @done tag to action and move to Archive'
+    c.switch %i[a archive], 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, args|
+      options[:finish] = true
+      options[:f] = true
+      options[:project] = 'Archive' if options[:archive]
+
+      cmd = commands[:update]
+      action = cmd.send(:get_action, nil)
+      action.call(global, options, args)
+    end
   end
 end

data/bin/commands/completed.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+class App
+  extend GLI::App
+  desc 'Display completed actions'
+  long_desc 'Search tokens are separated by spaces. Actions matching all tokens in the pattern will be shown
+    (partial matches allowed). Add a + before a token to make it required, e.g. `na completed +feature +maybe`,
+    add a - or ! to ignore matches containing that token.'
+  arg_name 'PATTERN', optional: true, multiple: true
+  command %i[completed finished] do |c|
+    c.example 'na completed', desc: 'display completed actions'
+    c.example 'na completed --before "2 days ago"',
+              desc: 'display actions completed more than two days ago'
+    c.example 'na completed --on yesterday',
+              desc: 'display actions completed yesterday'
+    c.example 'na completed --after "1 week ago"',
+              desc: 'display actions completed in the last week'
+    c.example 'na completed feature',
+              desc: 'display completed actions matcning "feature"'
+
+    c.desc 'Display actions completed before (natural language) date string'
+    c.arg_name 'DATE_STRING'
+    c.flag %i[b before]
+
+    c.desc 'Display actions completed on (natural language) date string'
+    c.arg_name 'DATE_STRING'
+    c.flag %i[on]
+
+    c.desc 'Display actions completed after (natural language) date string'
+    c.arg_name 'DATE_STRING'
+    c.flag %i[a after]
+
+    c.desc 'Combine before, on, and/or after with OR, displaying actions matching ANY of the ranges'
+    c.switch %i[o or], negatable: false
+
+    c.desc 'Recurse to depth'
+    c.arg_name 'DEPTH'
+    c.flag %i[d depth], type: :integer, must_match: /^\d+$/
+
+    c.desc 'Show actions from a specific todo file in history. May use wildcards (* and ?)'
+    c.arg_name 'TODO_PATH'
+    c.flag %i[in]
+
+    c.desc 'Include notes in output'
+    c.switch %i[notes], negatable: true, default_value: false
+
+    c.desc 'Show actions from a specific project'
+    c.arg_name 'PROJECT[/SUBPROJECT]'
+    c.flag %i[proj project]
+
+    c.desc 'Match actions containing tag. Allows value comparisons'
+    c.arg_name 'TAG'
+    c.flag %i[tagged], multiple: true
+
+    c.desc 'Output actions nested by file'
+    c.switch %[nest], negatable: false
+
+    c.desc 'Output actions nested by file and project'
+    c.switch %[omnifocus], negatable: false
+
+    c.desc 'Save this search for future use'
+    c.arg_name 'TITLE'
+    c.flag %i[save]
+
+    c.action do |_global_options, options, args|
+      tag_string = []
+      if options[:before] || options[:on] || options[:after]
+        tag_string << "done<#{options[:before]}" if options[:before]
+        tag_string << "done=#{options[:on]}" if options[:on]
+        tag_string << "done>#{options[:after]}" if options[:after]
+      else
+        tag_string << 'done'
+      end
+
+      tag_string.concat(options[:tagged]) if options[:tagged]
+
+      if args.empty?
+        cmd_string = %(tagged --done "#{tag_string.join(',')}")
+      else
+        cmd_string = %(find --tagged "#{tag_string.join(',')}" --done #{args.join(' ')})
+      end
+
+      cmd_string += ' --or' if options[:or]
+      cmd_string += %( --in "#{options[:in]}") if options[:in]
+      cmd_string += %( --project "#{options[:project]}") if options[:project]
+      cmd_string += %( --depth #{options[:depth]}) if options[:depth]
+      cmd_string += ' --nest' if options[:nest]
+      cmd_string += ' --omnifocus' if options[:omnifocus]
+      cmd_string += " --#{options[:notes] ? 'notes' : 'no-notes' }"
+
+      if options[:save]
+        title = options[:save].gsub(/[^a-z0-9]/, '_').gsub(/_+/, '_')
+        NA.save_search(title, cmd_string)
+      end
+
+      exit run(Shellwords.shellsplit(cmd_string))
+    end
+  end
+end

data/bin/commands/edit.rb

@@ -1,45 +1,48 @@
 # frozen_string_literal: true
 
-desc 'Open a todo file in the default editor'
-long_desc 'Let the system choose the defualt, (e.g. TaskPaper), or specify a command line utility (e.g. vim).
-           If more than one todo file is found, a menu is displayed.'
-command %i[edit] do |c|
-  c.example 'na edit', desc: 'Open the main todo file in the default editor'
-  c.example 'na edit -d 3 -a vim', desc: 'Display a menu of all todo files three levels deep from the
-             current directory, open selection in vim.'
+class App
+  extend GLI::App
+  desc 'Open a todo file in the default editor'
+  long_desc 'Let the system choose the defualt, (e.g. TaskPaper), or specify a command line utility (e.g. vim).
+             If more than one todo file is found, a menu is displayed.'
+  command %i[edit] do |c|
+    c.example 'na edit', desc: 'Open the main todo file in the default editor'
+    c.example 'na edit -d 3 -a vim', desc: 'Display a menu of all todo files three levels deep from the
+               current directory, open selection in vim.'
 
-  c.desc 'Recurse to depth'
-  c.arg_name 'DEPTH'
-  c.default_value 1
-  c.flag %i[d depth], type: :integer, must_match: /^\d+$/
+    c.desc 'Recurse to depth'
+    c.arg_name 'DEPTH'
+    c.default_value 1
+    c.flag %i[d depth], type: :integer, must_match: /^\d+$/
 
-  c.desc 'Specify an editor CLI'
-  c.arg_name 'EDITOR'
-  c.flag %i[e editor]
+    c.desc 'Specify an editor CLI'
+    c.arg_name 'EDITOR'
+    c.flag %i[e editor]
 
-  c.desc 'Specify a Mac app'
-  c.arg_name 'EDITOR'
-  c.flag %i[a app]
+    c.desc 'Specify a Mac app'
+    c.arg_name 'EDITOR'
+    c.flag %i[a app]
 
-  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?
+    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
-             files[0]
-           end
+      file = if files.count > 1
+               NA.select_file(files)
+             else
+               files[0]
+             end
 
-    if options[:editor]
-      system options[:editor], file
-    else
-      NA.edit_file(file: file, app: options[:app])
+      if options[:editor]
+        system options[:editor], file
+      else
+        NA.edit_file(file: file, app: options[:app])
+      end
     end
   end
 end

data/bin/commands/find.rb

@@ -1,135 +1,138 @@
 # frozen_string_literal: true
 
-desc 'Find actions matching a search pattern'
-long_desc 'Search tokens are separated by spaces. Actions matching all tokens in the pattern will be shown
-(partial matches allowed). Add a + before a token to make it required, e.g. `na find +feature +maybe`,
-add a - or ! to ignore matches containing that token.'
-arg_name 'PATTERN'
-command %i[find grep] do |c|
-  c.example 'na find feature idea swift', desc: 'Find all actions containing feature, idea, and swift'
-  c.example 'na find feature idea -swift', desc: 'Find all actions containing feature and idea but NOT swift'
-  c.example 'na find -x feature idea', desc: 'Find all actions containing the exact text "feature idea"'
+class App
+  extend GLI::App
+  desc 'Find actions matching a search pattern'
+  long_desc 'Search tokens are separated by spaces. Actions matching all tokens in the pattern will be shown
+  (partial matches allowed). Add a + before a token to make it required, e.g. `na find +feature +maybe`,
+  add a - or ! to ignore matches containing that token.'
+  arg_name 'PATTERN'
+  command %i[find grep] do |c|
+    c.example 'na find feature idea swift', desc: 'Find all actions containing feature, idea, and swift'
+    c.example 'na find feature idea -swift', desc: 'Find all actions containing feature and idea but NOT swift'
+    c.example 'na find -x feature idea', desc: 'Find all actions containing the exact text "feature idea"'
 
-  c.desc 'Interpret search pattern as regular expression'
-  c.switch %i[e regex], 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.desc 'Match pattern exactly'
+    c.switch %i[x exact], negatable: false
 
-  c.desc 'Recurse to depth'
-  c.arg_name 'DEPTH'
-  c.flag %i[d depth], type: :integer, must_match: /^\d+$/
+    c.desc 'Recurse to depth'
+    c.arg_name 'DEPTH'
+    c.flag %i[d depth], type: :integer, must_match: /^\d+$/
 
-  c.desc 'Show actions from a specific todo file in history. May use wildcards (* and ?)'
-  c.arg_name 'TODO_PATH'
-  c.flag %i[in]
+    c.desc 'Show actions from a specific todo file in history. May use wildcards (* and ?)'
+    c.arg_name 'TODO_PATH'
+    c.flag %i[in]
 
-  c.desc 'Include notes in output'
-  c.switch %i[notes], negatable: true, default_value: false
+    c.desc 'Include notes in output'
+    c.switch %i[notes], negatable: true, default_value: false
 
-  c.desc 'Combine search tokens with OR, displaying actions matching ANY of the terms'
-  c.switch %i[o or], negatable: false
+    c.desc 'Combine search tokens with OR, displaying actions matching ANY of the terms'
+    c.switch %i[o or], negatable: false
 
-  c.desc 'Show actions from a specific project'
-  c.arg_name 'PROJECT[/SUBPROJECT]'
-  c.flag %i[proj project]
+    c.desc 'Show actions from a specific project'
+    c.arg_name 'PROJECT[/SUBPROJECT]'
+    c.flag %i[proj project]
 
-  c.desc 'Match actions containing tag. Allows value comparisons'
-  c.arg_name 'TAG'
-  c.flag %i[tagged], multiple: true
+    c.desc 'Match actions containing tag. Allows value comparisons'
+    c.arg_name 'TAG'
+    c.flag %i[tagged], multiple: true
 
-  c.desc 'Include @done actions'
-  c.switch %i[done]
+    c.desc 'Include @done actions'
+    c.switch %i[done]
 
-  c.desc 'Show actions not matching search pattern'
-  c.switch %i[v invert], negatable: false
+    c.desc 'Show actions not matching search pattern'
+    c.switch %i[v invert], negatable: false
 
-  c.desc 'Save this search for future use'
-  c.arg_name 'TITLE'
-  c.flag %i[save]
+    c.desc 'Save this search for future use'
+    c.arg_name 'TITLE'
+    c.flag %i[save]
 
-  c.desc 'Output actions nested by file'
-  c.switch %[nest], negatable: false
+    c.desc 'Output actions nested by file'
+    c.switch %[nest], negatable: false
 
-  c.desc 'Output actions nested by file and project'
-  c.switch %[omnifocus], negatable: false
+    c.desc 'Output actions nested by file and project'
+    c.switch %[omnifocus], negatable: false
 
-  c.action do |global_options, options, args|
-    options[:nest] = true if options[:omnifocus]
+    c.action do |global_options, options, args|
+      options[:nest] = true if options[:omnifocus]
 
-    if options[:save]
-      title = options[:save].gsub(/[^a-z0-9]/, '_').gsub(/_+/, '_')
-      NA.save_search(title, "#{NA.command_line.join(' ').sub(/ --save[= ]*\S+/, '').split(' ').map { |t| %("#{t}") }.join(' ')}")
-    end
+      if options[:save]
+        title = options[:save].gsub(/[^a-z0-9]/, '_').gsub(/_+/, '_')
+        NA.save_search(title, "#{NA.command_line.join(' ').sub(/ --save[= ]*\S+/, '').split(' ').map { |t| %("#{t}") }.join(' ')}")
+      end
 
 
-    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
-
-    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
+      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
 
-    tokens = nil
-    if options[:exact]
-      tokens = args.join(' ')
-    elsif options[:regex]
-      tokens = Regexp.new(args.join(' '), Regexp::IGNORECASE)
-    else
-      tokens = []
-      all_req = args.join(' ') !~ /[+!\-]/ && !options[:or]
-
-      args.join(' ').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
+      all_req = options[:tagged].join(' ') !~ /[+!\-]/ && !options[:or]
+      tags = []
+      options[:tagged].join(',').split(/ *, */).each do |arg|
+        m = arg.match(/^(?<req>[+\-!])?(?<tag>[^ =<>$\^]+?)(?:(?<op>[=<>]{1,2}|[*$\^]=)(?<val>.*?))?$/)
 
-    todo = nil
-    if options[:in]
-      todo = []
-      options[:in].split(/ *, */).each do |a|
-        m = a.match(/^(?<req>[+\-!])?(?<tok>.*?)$/)
-        todo.push({
-                    token: m['tok'],
+        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
-    end
 
-    files, actions, = NA.parse_actions(depth: depth,
-                                       done: options[:done],
-                                       query: todo,
-                                       search: tokens,
-                                       tag: tags,
-                                       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
+      tokens = nil
+      if options[:exact]
+        tokens = args.join(' ')
+      elsif options[:regex]
+        tokens = Regexp.new(args.join(' '), Regexp::IGNORECASE)
+      else
+        tokens = []
+        all_req = args.join(' ') !~ /[+!\-]/ && !options[:or]
+
+        args.join(' ').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
 
-    NA.output_actions(actions, depth, files: files, regexes: regexes, notes: options[:notes], nest: options[:nest], nest_projects: options[:omnifocus])
+      todo = nil
+      if options[:in]
+        todo = []
+        options[:in].split(/ *, */).each do |a|
+          m = a.match(/^(?<req>[+\-!])?(?<tok>.*?)$/)
+          todo.push({
+                      token: m['tok'],
+                      required: all_req || (!m['req'].nil? && m['req'] == '+'),
+                      negate: !m['req'].nil? && m['req'] =~ /[!\-]/
+                    })
+        end
+      end
+
+      files, actions, = NA.parse_actions(depth: depth,
+                                         done: options[:done],
+                                         query: todo,
+                                         search: tokens,
+                                         tag: tags,
+                                         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, notes: options[:notes], nest: options[:nest], nest_projects: options[:omnifocus])
+    end
   end
 end

data/bin/commands/init.rb

@@ -1,28 +1,31 @@
 # frozen_string_literal: true
 
-desc 'Create a new todo file in the current directory'
-arg_name 'PROJECT', optional: true
-command %i[init create] do |c|
-  c.example 'na init', desc: 'Generate a new todo file, prompting for project name'
-  c.example 'na init warpspeed', desc: 'Generate a new todo for a project called warpspeed'
+class App
+  extend GLI::App
+  desc 'Create a new todo file in the current directory'
+  arg_name 'PROJECT', optional: true
+  command %i[init create] do |c|
+    c.example 'na init', desc: 'Generate a new todo file, prompting for project name'
+    c.example 'na init warpspeed', desc: 'Generate a new todo for a project called warpspeed'
 
-  c.action do |global_options, _options, args|
-    reader = TTY::Reader.new
-    if args.count.positive?
-      project = args.join(' ')
-    elsif
-      project = File.expand_path('.').split('/').last
-      project = reader.read_line(NA::Color.template('{y}Project name {bw}> {x}'), value: project).strip if $stdin.isatty
-    end
+    c.action do |global_options, _options, args|
+      reader = TTY::Reader.new
+      if args.count.positive?
+        project = args.join(' ')
+      elsif
+        project = File.expand_path('.').split('/').last
+        project = reader.read_line(NA::Color.template('{y}Project name {bw}> {x}'), value: project).strip if $stdin.isatty
+      end
 
-    target = "#{project}.#{NA.extension}"
+      target = "#{project}.#{NA.extension}"
 
-    if File.exist?(target)
-      res = NA.yn(NA::Color.template("{r}File {bw}#{target}{r} already exists, overwrite it"), default: false)
-      Process.exit 1 unless res
+      if File.exist?(target)
+        res = NA.yn(NA::Color.template("{r}File {bw}#{target}{r} already exists, overwrite it"), default: false)
+        Process.exit 1 unless res
 
-    end
+      end
 
-    NA.create_todo(target, project, template: global_options[:template])
+      NA.create_todo(target, project, template: global_options[:template])
+    end
   end
 end