na 1.2.28 → 1.2.30

data/bin/commands/prompt.rb

@@ -1,48 +1,51 @@
 # frozen_string_literal: true
 
-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'
-command %i[prompt] do |c|
-  c.desc 'Output the prompt hook for the current shell to STDOUT. Pass an argument to
-          specify a shell (zsh, bash, fish)'
-  c.arg_name 'SHELL', optional: true
-  c.command %i[show] do |s|
-    s.action do |_global_options, _options, args|
-      shell = if args.count.positive?
-                args[0]
-              else
-                File.basename(ENV['SHELL'])
-              end
+class App
+  extend GLI::App
+  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'
+  command %i[prompt] do |c|
+    c.desc 'Output the prompt hook for the current shell to STDOUT. Pass an argument to
+            specify a shell (zsh, bash, fish)'
+    c.arg_name 'SHELL', optional: true
+    c.command %i[show] do |s|
+      s.action do |_global_options, _options, args|
+        shell = if args.count.positive?
+                  args[0]
+                else
+                  File.basename(ENV['SHELL'])
+                end
 
-      case shell
-      when /^f/i
-        NA::Prompt.show_prompt_hook(:fish)
-      when /^z/i
-        NA::Prompt.show_prompt_hook(:zsh)
-      when /^b/i
-        NA::Prompt.show_prompt_hook(:bash)
+        case shell
+        when /^f/i
+          NA::Prompt.show_prompt_hook(:fish)
+        when /^z/i
+          NA::Prompt.show_prompt_hook(:zsh)
+        when /^b/i
+          NA::Prompt.show_prompt_hook(:bash)
+        end
       end
     end
-  end
 
-  c.desc 'Install the hook for the current shell to the appropriate startup file.'
-  c.arg_name 'SHELL', optional: true
-  c.command %i[install] do |s|
-    s.action do |_global_options, _options, args|
-      shell = if args.count.positive?
-                args[0]
-              else
-                File.basename(ENV['SHELL'])
-              end
+    c.desc 'Install the hook for the current shell to the appropriate startup file.'
+    c.arg_name 'SHELL', optional: true
+    c.command %i[install] do |s|
+      s.action do |_global_options, _options, args|
+        shell = if args.count.positive?
+                  args[0]
+                else
+                  File.basename(ENV['SHELL'])
+                end
 
-      case shell
-      when /^f/i
-        NA::Prompt.install_prompt_hook(:fish)
-      when /^z/i
-        NA::Prompt.install_prompt_hook(:zsh)
-      when /^b/i
-        NA::Prompt.install_prompt_hook(:bash)
+        case shell
+        when /^f/i
+          NA::Prompt.install_prompt_hook(:fish)
+        when /^z/i
+          NA::Prompt.install_prompt_hook(:zsh)
+        when /^b/i
+          NA::Prompt.install_prompt_hook(:bash)
+        end
       end
     end
   end

data/bin/commands/saved.rb

@@ -1,39 +1,47 @@
 # frozen_string_literal: true
 
-desc 'Execute a saved search'
-long_desc 'Run without argument to list saved searches'
-arg_name 'SEARCH_TITLE', optional: true
-command %i[saved] do |c|
-  c.example 'na tagged "+maybe,+priority<=3" --save maybelater', description: 'save a search called "maybelater"'
-  c.example 'na saved maybelater', description: 'perform the search named "maybelater"'
-  c.example 'na saved maybe',
-            description: 'perform the search named "maybelater", assuming no other searches match "maybe"'
-  c.example 'na maybe',
-            description: 'na run with no command and a single argument automatically performs a matching saved search'
-  c.example 'na saved', description: 'list available searches'
-
-  c.desc 'Open the saved search file in $EDITOR'
-  c.switch %i[e edit], negatable: false
-
-  c.desc 'Delete the specified search definition'
-  c.switch %i[d delete], negatable: false
-
-  c.action do |_global_options, options, args|
-    NA.edit_searches if options[:edit]
-
-    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
-      NA.delete_search(args) if options[:delete]
-
-      keys = searches.keys.delete_if { |k| k !~ /#{args[0]}/ }
-      NA.notify("{r}Search #{args[0]} not found", exit_code: 1) if keys.empty?
-
-      key = keys[0]
-      cmd = Shellwords.shellsplit(searches[key])
-      exit run(cmd)
+class App
+  extend GLI::App
+  desc 'Execute a saved search'
+  long_desc 'Run without argument to list saved searches'
+  arg_name 'SEARCH_TITLE', optional: true, multiple: true
+  command %i[saved] do |c|
+    c.example 'na tagged "+maybe,+priority<=3" --save maybelater', desc: 'save a search called "maybelater"'
+    c.example 'na saved maybelater', desc: 'perform the search named "maybelater"'
+    c.example 'na saved maybe',
+              desc: 'perform the search named "maybelater", assuming no other searches match "maybe"'
+    c.example 'na maybe',
+              desc: 'na run with no command and a single argument automatically performs a matching saved search'
+    c.example 'na saved', desc: 'list available searches'
+
+    c.desc 'Open the saved search file in $EDITOR'
+    c.switch %i[e edit], negatable: false
+
+    c.desc 'Delete the specified search definition'
+    c.switch %i[d delete], negatable: false
+
+    c.action do |_global_options, options, args|
+      NA.edit_searches if options[:edit]
+
+      if args.empty?
+        searches = NA.load_searches
+        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
+        args.each do |arg|
+          searches = NA.load_searches
+
+          NA.delete_search(arg) if options[:delete]
+
+          keys = searches.keys.delete_if { |k| k !~ /#{arg}/ }
+          NA.notify("{r}Search #{arg} not found", exit_code: 1) if keys.empty?
+
+          key = keys[0]
+          cmd = Shellwords.shellsplit(searches[key])
+          run(cmd)
+        end
+        exit
+      end
     end
   end
 end

data/bin/commands/tagged.rb

@@ -1,146 +1,149 @@
 # frozen_string_literal: true
 
-desc 'Find actions matching a tag'
-long_desc 'Finds actions with tags matching the arguments. An action is shown if it
-contains all of the tags listed. Add a + before a tag to make it required
-and others optional. You can specify values using TAG=VALUE pairs.
-Use <, >, and = for numeric comparisons, and *=, ^=, and $= for text comparisons.
-Date comparisons use natural language (`na tagged "due<=today"`) and
-are detected automatically.'
-arg_name 'TAG[=VALUE]'
-command %i[tagged] do |c|
-  c.example 'na tagged maybe', desc: 'Show all actions tagged @maybe'
-  c.example 'na tagged -d 3 "feature, idea"', desc: 'Show all actions tagged @feature AND @idea, recurse 3 levels'
-  c.example 'na tagged --or "feature, idea"', desc: 'Show all actions tagged @feature OR @idea'
-  c.example 'na tagged "priority>=4"', desc: 'Show actions with @priority(4) or @priority(5)'
-  c.example 'na tagged "due<in 2 days"', desc: 'Show actions with a due date coming up in the next 2 days'
-
-  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 '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 'Combine tags with OR, displaying actions matching ANY of the tags'
-  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 'Filter results using search terms'
-  c.arg_name 'QUERY'
-  c.flag %i[search], multiple: true
-
-  c.desc 'Search query is regular expression'
-  c.switch %i[regex], negatable: false
-
-  c.desc 'Search query is exact text match (not tokens)'
-  c.switch %i[exact], negatable: false
-
-  c.desc 'Include @done actions'
-  c.switch %i[done]
-
-  c.desc 'Show actions not matching tags'
-  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 '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.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
+class App
+  extend GLI::App
+  desc 'Find actions matching a tag'
+  long_desc 'Finds actions with tags matching the arguments. An action is shown if it
+  contains all of the tags listed. Add a + before a tag to make it required
+  and others optional. You can specify values using TAG=VALUE pairs.
+  Use <, >, and = for numeric comparisons, and *=, ^=, and $= for text comparisons.
+  Date comparisons use natural language (`na tagged "due<=today"`) and
+  are detected automatically.'
+  arg_name 'TAG[=VALUE]'
+  command %i[tagged] do |c|
+    c.example 'na tagged maybe', desc: 'Show all actions tagged @maybe'
+    c.example 'na tagged -d 3 "feature, idea"', desc: 'Show all actions tagged @feature AND @idea, recurse 3 levels'
+    c.example 'na tagged --or "feature, idea"', desc: 'Show all actions tagged @feature OR @idea'
+    c.example 'na tagged "priority>=4"', desc: 'Show actions with @priority(4) or @priority(5)'
+    c.example 'na tagged "due<in 2 days"', desc: 'Show actions with a due date coming up in the next 2 days'
+
+    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 '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 'Combine tags with OR, displaying actions matching ANY of the tags'
+    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 'Filter results using search terms'
+    c.arg_name 'QUERY'
+    c.flag %i[search], multiple: true
+
+    c.desc 'Search query is regular expression'
+    c.switch %i[regex], negatable: false
+
+    c.desc 'Search query is exact text match (not tokens)'
+    c.switch %i[exact], negatable: false
+
+    c.desc 'Include @done actions'
+    c.switch %i[done]
+
+    c.desc 'Show actions not matching tags'
+    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 '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.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
 
-    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
-
-    tags = []
-
-    all_req = args.join(' ') !~ /[+!\-]/ && !options[:or]
-    args.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
 
-    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
-
-    tokens = nil
-    if options[:search]
-      if options[:exact]
-        tokens = options[:search].join(' ')
-      elsif options[:regex]
-        tokens = Regexp.new(options[:search].join(' '), Regexp::IGNORECASE)
-      else
-        tokens = []
-        all_req = options[:search].join(' ') !~ /[+!\-]/ && !options[:or]
-
-        options[:search].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
-    end
+      tags = []
 
-    todo = nil
-    if options[:in]
-      todo = []
-      options[:in].split(/ *, */).each do |a|
-        m = a.match(/^(?<req>[+\-!])?(?<tok>.*?)$/)
-        todo.push({
-                    token: m['tok'],
+      all_req = args.join(' ') !~ /[+!\-]/ && !options[:or]
+      args.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
-    end
 
-    files, actions, = NA.parse_actions(depth: depth,
-                                       done: options[:done],
-                                       query: todo,
-                                       search: tokens,
-                                       tag: tags,
-                                       negate: options[:invert],
-                                       project: options[:project],
-                                       require_na: false)
-    # regexes = tags.delete_if { |token| token[:negate] }.map { |token| token[:token] }
-    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])
+      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
+
+      tokens = nil
+      if options[:search]
+        if options[:exact]
+          tokens = options[:search].join(' ')
+        elsif options[:regex]
+          tokens = Regexp.new(options[:search].join(' '), Regexp::IGNORECASE)
+        else
+          tokens = []
+          all_req = options[:search].join(' ') !~ /[+!\-]/ && !options[:or]
+
+          options[:search].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
+      end
+
+      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],
+                                         project: options[:project],
+                                         require_na: false)
+      # regexes = tags.delete_if { |token| token[:negate] }.map { |token| token[:token] }
+      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/todos.rb

@@ -1,28 +1,31 @@
 # frozen_string_literal: true
 
-desc 'Show list of known todo files'
-long_desc 'Arguments will be interpreted as a query against which the
-list of todos will be fuzzy matched. Separate directories with
-/, :, or a space, e.g. `na todos code/marked`'
-arg_name 'QUERY', optional: true
-command %i[todos] do |c|
-  c.action do |_global_options, _options, args|
-    if args.count.positive?
-      all_req = args.join(' ') !~ /[+!\-]/
+class App
+  extend GLI::App
+  desc 'Show list of known todo files'
+  long_desc 'Arguments will be interpreted as a query against which the
+  list of todos will be fuzzy matched. Separate directories with
+  /, :, or a space, e.g. `na todos code/marked`'
+  arg_name 'QUERY', optional: true
+  command %i[todos] do |c|
+    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'] =~ /[!\-]/
-                      })
+        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
-    end
 
-    NA.list_todos(query: tokens)
+      NA.list_todos(query: tokens)
+    end
   end
 end