na 1.2.80 → 1.2.82

data/bin/commands/update.rb

@@ -104,6 +104,49 @@ class App
     c.switch %i[x exact], negatable: false
 
     c.action do |global_options, options, args|
+      # Ensure all variables used in update loop are declared
+      target_proj = if options[:move]
+                      options[:move]
+                    elsif NA.respond_to?(:cwd_is) && NA.cwd_is == :project
+                      NA.cwd
+                    end
+
+      priority = options[:priority].to_i if options[:priority]&.to_i&.positive?
+      remove_tags = options[:remove] ? options[:remove].join(',').split(/ *, */).map { |t| t.sub(/^@/, '').respond_to?(:wildcard_to_rx) ? t.wildcard_to_rx : t } : []
+      remove_tags << 'done' if options[:restore]
+
+      stdin_note = NA.respond_to?(:stdin) && NA.stdin ? NA.stdin.split("\n") : []
+      line_note = if options[:note] && $stdin.isatty
+                    puts stdin_note unless stdin_note.nil?
+                    if TTY::Which.exist?('gum')
+                      args = ['--placeholder "Enter a note, CTRL-d to save"']
+                      args << '--char-limit 0'
+                      args << '--width $(tput cols)'
+                      gum = TTY::Which.which('gum')
+                      `#{gum} write #{args.join(' ')}`.strip.split("\n")
+                    else
+                      NA.notify("#{NA.theme[:prompt]}Enter a note, {bw}CTRL-d#{NA.theme[:prompt]} to end editing:#{NA.theme[:action]}")
+                      reader.read_multiline
+                    end
+                  end
+      note = stdin_note.empty? ? [] : stdin_note
+      note.concat(line_note) unless line_note.nil? || line_note.empty?
+
+      append = options[:at] ? options[:at] =~ /^[ae]/i : global_options[:add_at] =~ /^[ae]/i
+  add_tags = options[:tag] ? options[:tag].join(',').split(/ *, */).map { |t| t.sub(/^@/, '').respond_to?(:wildcard_to_rx) ? t.wildcard_to_rx : t } : []
+      # Build tags array from options[:tagged]
+      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'].respond_to?(:wildcard_to_rx) ? m['tag'].wildcard_to_rx : m['tag'],
+          comp: m['op'],
+          value: m['val'],
+          required: all_req || (!m['req'].nil? && m['req'] == '+'),
+          negate: !m['req'].nil? && m['req'] =~ /[!-]/ ? true : false
+        })
+      end
       reader = TTY::Reader.new
 
       args.concat(options[:search]) unless options[:search].nil?
@@ -121,13 +164,13 @@ class App
 
       options[:exact] = true unless options[:replace].nil?
 
-      action = if args.count.positive?
-                 args.join(' ').strip
-               else
-                 NA.request_input(options, prompt: 'Enter a task to search for')
-               end
-      if action
-        tokens = nil
+      if args.count.positive?
+        action = args.join(' ').strip
+      else
+        action = nil
+      end
+      tokens = nil
+      if action && !action.empty?
         if options[:exact]
           tokens = action
         elsif options[:regex]
@@ -135,20 +178,254 @@ class App
         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'] =~ /[!-]/ ? true : false
-                        })
+              token: m['tok'],
+              required: all_req || (!m['req'].nil? && m['req'] == '+'),
+              negate: !m['req'].nil? && m['req'] =~ /[!-]/ ? true : false
+            })
           end
         end
       end
 
+      # If no search query or tags, list all tasks for selection
       if (action.nil? || action.empty?) && options[:tagged].empty?
-        NA.notify("#{NA.theme[:error]}Empty input, cancelled", exit_code: 1)
+        tokens = nil # No search, list all
+      end
+
+      # Gather all candidate actions for selection
+      candidate_actions = []
+      targets_for_selection = []
+      files = NA.find_files_matching({
+        depth: options[:depth],
+        done: options[:done],
+        project: options[:project],
+        regex: options[:regex],
+        require_na: false,
+        search: tokens,
+        tag: tags
+      })
+      files.each do |file|
+        safe_search = (tokens.is_a?(String) || tokens.is_a?(Array) || tokens.is_a?(Regexp)) ? tokens : nil
+        todo = NA::Todo.new({
+          search: safe_search,
+          search_note: options[:search_notes],
+          require_na: false,
+          file_path: file,
+          project: options[:project],
+          tag: tags,
+          done: options[:done]
+        })
+        todo.actions.each do |action_obj|
+          # Format: filename:project:parent > action
+          display = "#{File.basename(action_obj.file)}:#{action_obj.project}:#{action_obj.parent.join('>')} | #{action_obj.action}"
+          candidate_actions << display
+          targets_for_selection << { file: action_obj.file, line: action_obj.line, action: action_obj }
+        end
+      end
+
+      # Multi-select using fzf or gum if available
+      selected_indices = []
+      if candidate_actions.any?
+        selector = nil
+        if TTY::Which.exist?('fzf')
+          selector = 'fzf --multi --prompt="Select tasks> "'
+        elsif TTY::Which.exist?('gum')
+          selector = 'gum choose --no-limit'
+        end
+        if selector
+          require 'open3'
+          input = candidate_actions.join("\n")
+          output, _ = Open3.capture2("echo \"#{input.gsub('"', '\"')}\" | #{selector}")
+          selected = output.split("\n").map(&:strip).reject(&:empty?)
+          selected_indices = candidate_actions.each_index.select { |i| selected.include?(candidate_actions[i]) }
+        else
+          # Fallback: select all or prompt for search string
+          selected_indices = (0...candidate_actions.size).to_a
+        end
+      end
+
+      # If no actions found, notify and exit
+      if selected_indices.empty?
+        NA.notify("#{NA.theme[:error]}No matching actions found for selection", exit_code: 1)
+      end
+
+      # Apply update to selected actions
+      actionable = [
+        options[:note],
+        (options[:priority].to_i if options[:priority]).to_i.positive?,
+        !options[:move].to_s.empty?,
+        !(options[:tag].nil? || options[:tag].empty?),
+        !(options[:remove].nil? || options[:remove].empty?),
+        !options[:replace].to_s.empty?,
+        options[:finish],
+        options[:archive],
+        options[:restore],
+        options[:delete],
+        options[:edit]
+      ].any?
+      unless actionable
+        # Interactive menu for actions
+        actions_menu = [
+          { key: :add_tag, label: 'Add Tag', param: 'Tag' },
+          { key: :remove_tag, label: 'Remove Tag', param: 'Tag' },
+          { key: :delete, label: 'Delete', param: nil },
+          { key: :finish, label: 'Finish (mark done)', param: nil },
+          { key: :edit, label: 'Edit', param: nil },
+          { key: :priority, label: 'Set Priority', param: 'Priority (1-5)' },
+          { key: :move, label: 'Move to Project', param: 'Project' },
+          { key: :restore, label: 'Restore', param: nil },
+          { key: :archive, label: 'Archive', param: nil },
+          { key: :note, label: 'Add Note', param: 'Note' }
+        ]
+        selector = nil
+        if TTY::Which.exist?('fzf')
+          selector = 'fzf --prompt="Select action> "'
+        elsif TTY::Which.exist?('gum')
+          selector = 'gum choose'
+        end
+        menu_labels = actions_menu.map { |a| a[:label] }
+        selected_action = nil
+        if selector
+          require 'open3'
+          input = menu_labels.join("\n")
+          output, _ = Open3.capture2("echo \"#{input.gsub('"', '\"')}\" | #{selector}")
+          selected_action = output.strip
+        else
+          puts 'Select an action:'
+          menu_labels.each_with_index { |label, i| puts "#{i+1}. #{label}" }
+          idx = (STDIN.gets || '').strip.to_i - 1
+          selected_action = menu_labels[idx] if idx >= 0 && idx < menu_labels.size
+        end
+        action_obj = actions_menu.find { |a| a[:label] == selected_action }
+        if action_obj.nil?
+          NA.notify("#{NA.theme[:error]}No action selected, cancelled", exit_code: 1)
+        end
+        # Prompt for parameter if needed
+        param_value = nil
+        # Only prompt for param if not :move (which has custom menu logic)
+        if action_obj[:param] && action_obj[:key] != :move
+          if TTY::Which.exist?('gum')
+            gum = TTY::Which.which('gum')
+            prompt = "Enter #{action_obj[:param]}: "
+            param_value = `#{gum} input --placeholder "#{prompt}"`.strip
+          else
+            print "Enter #{action_obj[:param]}: "
+            param_value = (STDIN.gets || '').strip
+          end
+        end
+        # Set options for update
+        case action_obj[:key]
+        when :add_tag
+          options[:tag] = [param_value]
+        when :remove_tag
+          options[:remove] = [param_value]
+        when :delete
+          options[:delete] = true
+        when :finish
+          options[:finish] = true
+        when :edit
+          # Open editor for the selected action and update its content
+          edit_action = targets_for_selection[selected_indices.first][:action]
+          editor_content = "#{edit_action.action}\n#{edit_action.note.join("\n")}"
+          new_action, new_note = NA::Editor.format_input(NA::Editor.fork_editor(editor_content))
+          edit_action.action = new_action
+          edit_action.note = new_note
+          options[:edit] = true
+        when :priority
+          options[:priority] = param_value
+        when :move
+          # Gather projects from the same file as the selected action
+          selected_file = targets_for_selection[selected_indices.first][:file]
+          todo = NA::Todo.new(file_path: selected_file)
+          project_names = todo.projects.map { |proj| proj.project }
+          project_menu = project_names + ['New project']
+          move_selector = nil
+          if TTY::Which.exist?('fzf')
+            move_selector = 'fzf --prompt="Select project> "'
+          elsif TTY::Which.exist?('gum')
+            move_selector = 'gum choose'
+          end
+          selected_project = nil
+          if move_selector
+            require 'open3'
+            input = project_menu.join("\n")
+            output, _ = Open3.capture2("echo \"#{input.gsub('"', '\"')}\" | #{move_selector}")
+            selected_project = output.strip
+          else
+            puts 'Select a project:'
+            project_menu.each_with_index { |label, i| puts "#{i+1}. #{label}" }
+            idx = (STDIN.gets || '').strip.to_i - 1
+            selected_project = project_menu[idx] if idx >= 0 && idx < project_menu.size
+          end
+          if selected_project == 'New project'
+            if TTY::Which.exist?('gum')
+              gum = TTY::Which.which('gum')
+              prompt = 'Enter new project name: '
+              new_proj_name = `#{gum} input --placeholder "#{prompt}"`.strip
+            else
+              print 'Enter new project name: '
+              new_proj_name = (STDIN.gets || '').strip
+            end
+            # Create the new project in the file
+            NA.insert_project(selected_file, new_proj_name, todo.projects)
+            options[:move] = new_proj_name
+          else
+            options[:move] = selected_project
+          end
+        when :restore
+          options[:restore] = true
+        when :archive
+          options[:archive] = true
+        when :note
+          options[:note] = true
+          note = [param_value]
+        end
+      end
+      did_direct_update = false
+      selected_indices.each do |idx|
+        # Rebuild all derived variables from options after menu-driven assignment
+        add_tags = options[:tag] ? options[:tag].join(',').split(/ *, */).map { |t| t.sub(/^@/, '') } : []
+        remove_tags = options[:remove] ? options[:remove].join(',').split(/ *, */).map { |t| t.sub(/^@/, '') } : []
+        remove_tags << 'done' if options[:restore]
+        priority = options[:priority].to_i if options[:priority]&.to_i&.positive?
+        target_proj = if options[:move]
+                        options[:move]
+                      elsif NA.respond_to?(:cwd_is) && NA.cwd_is == :project
+                        NA.cwd
+                      end
+        note_val = note
+        if options[:note] && defined?(param_value) && param_value
+          note_val = [param_value]
+        end
+        # Pass the selected action object as 'add', set search to nil
+        # Pass the exact selected action object to update_action, bypassing all search/filter logic
+        target = targets_for_selection[idx][:file]
+        action_obj = targets_for_selection[idx][:action]
+        # Direct action mode: update only the selected action in the known file
+        NA.update_action(target, nil,
+          add: action_obj,
+          add_tag: add_tags,
+          all: true,
+          append: append,
+          delete: options[:delete],
+          done: options[:done],
+          edit: options[:edit],
+          finish: options[:finish],
+          move: target_proj,
+          note: note_val,
+          overwrite: options[:overwrite],
+          priority: priority,
+          project: options[:project],
+          remove_tag: remove_tags,
+          replace: options[:replace],
+          search_note: options[:search_notes],
+          tagged: nil)
+        did_direct_update = true
+      end
+      if did_direct_update
+        next
       end
 
       all_req = options[:tagged].join(' ') !~ /[+!-]/ && !options[:or]
@@ -192,7 +469,7 @@ class App
       # Require at least one actionable option to be provided
       actionable = [
         options[:note],
-        (options[:priority].to_i if options[:priority]).to_i > 0,
+        (options[:priority].to_i if options[:priority]).to_i.positive?,
         !options[:move].to_s.empty?,
         !(options[:tag].nil? || options[:tag].empty?),
         !(options[:remove].nil? || options[:remove].empty?),

data/bin/na

@@ -10,11 +10,11 @@ require 'fcntl'
 require 'tempfile'
 
 NA::Benchmark.init
-NA::Benchmark.measure('Gem loading') { nil }  # Measures time up to this point
+NA::Benchmark.measure('Gem loading') { nil } # Measures time up to this point
 
 # Search for XDG compliant config first. Default to ~/.na.rc for compatibility
 def self.find_config_file
-  home = ENV['HOME']
+  home = Dir.home
   xdg_config_home = ENV['XDG_CONFIG_HOME'] || File.join(home, '.config')
 
   rc_paths = [
@@ -30,7 +30,6 @@ def self.find_config_file
   existing_path || File.join(xdg_config_home, 'na', 'na.rc')
 end
 
-
 # Main application
 class App
   extend GLI::App
@@ -84,7 +83,7 @@ class App
   switch %i[repo-top], default_value: false
 
   desc 'Provide a template for new/blank todo files, use initconfig to make permanent'
-  flag %[template]
+  flag %(template)
 
   desc 'Use current working directory as [p]roject, [t]ag, or [n]one'
   arg_name 'TYPE'
@@ -121,7 +120,7 @@ class App
     NA.include_ext = global[:include_ext]
     NA.na_tag = global[:na_tag]
     NA.global_file = global[:file]
-    NA.cwd = File.basename(ENV['PWD'])
+    NA.cwd = File.basename(ENV.fetch('PWD', nil))
     NA.cwd_is = if global[:cwd_as] =~ /^n/
                   :none
                 else
@@ -146,7 +145,8 @@ class App
           NA.global_file = taskpaper_file
           # Add this block to create the file if it doesn't exist
           unless File.exist?(taskpaper_file)
-            res = NA.yn(NA::Color.template("#{NA.theme[:warning]}Repository file not found, create #{taskpaper_file}"), default: true)
+            res = NA.yn(NA::Color.template("#{NA.theme[:warning]}Repository file not found, create #{taskpaper_file}"),
+                        default: true)
             if res
               NA.create_todo(taskpaper_file, repo_name, template: global[:template])
             else
@@ -198,7 +198,7 @@ class App
 end
 
 NA.stdin = $stdin.read.strip if $stdin.stat.size.positive? || $stdin.fcntl(Fcntl::F_GETFL, 0).zero?
-NA.stdin = nil unless NA.stdin && NA.stdin.length.positive?
+NA.stdin = nil unless NA.stdin&.length&.positive?
 
 NA.globals = []
 NA.command_line = []

data/lib/na/action.rb

@@ -2,9 +2,8 @@
 
 module NA
   class Action < Hash
-    attr_reader :file, :project, :parent, :tags, :line
-
-    attr_accessor :action, :note
+    attr_reader :file, :project, :tags, :line
+    attr_accessor :parent, :action, :note
 
     def initialize(file, project, parent, action, idx, note = [])
       super()
@@ -12,12 +11,20 @@ module NA
       @file = file
       @project = project
       @parent = parent
-      @action = action.gsub(/\{/, '\\{')
+      @action = action.gsub('{', '\\{')
       @tags = scan_tags
       @line = idx
       @note = note
     end
 
+    # Update the action string and note with priority, tags, and completion status
+    #
+    # @param priority [Integer] Priority value to set
+    # @param finish [Boolean] Mark as finished
+    # @param add_tag [Array<String>] Tags to add
+    # @param remove_tag [Array<String>] Tags to remove
+    # @param note [Array<String>] Notes to set
+    # @return [void]
     def process(priority: 0, finish: false, add_tag: [], remove_tag: [], note: [])
       string = @action.dup
 
@@ -44,6 +51,9 @@ module NA
       @note = note unless note.empty?
     end
 
+    # String representation of the action
+    #
+    # @return [String]
     def to_s
       note = if @note.count.positive?
                "\n#{@note.join("\n")}"
@@ -53,36 +63,41 @@ module NA
       "(#{@file}:#{@line}) #{@project}:#{@parent.join('>')} | #{@action}#{note}"
     end
 
+    # Pretty string representation of the action with color formatting
+    #
+    # @return [String]
     def to_s_pretty
       note = if @note.count.positive?
                "\n#{@note.join("\n")}"
              else
                ''
              end
-      "#{NA.theme[:filename]}#{File.basename(@file)}:#{@line}#{NA.theme[:bracket]}[#{NA.theme[:project]}#{@project}:#{@parent.join(">")}#{NA.theme[:bracket]}]{x} | #{NA.theme[:action]}#{@action}#{NA.theme[:note]}#{note}"
+      "{x}#{NA.theme[:filename]}#{File.basename(@file)}:#{@line}{x}#{NA.theme[:bracket]}[{x}#{NA.theme[:project]}#{@project}:#{@parent.join('>')}{x}#{NA.theme[:bracket]}]{x} | #{NA.theme[:action]}#{@action}{x}#{NA.theme[:note]}#{note}"
     end
 
+    # Inspect the action object
+    #
+    # @return [String]
     def inspect
       <<~EOINSPECT
-      @file: #{@file}
-      @project: #{@project}
-      @parent: #{@parent.join('>')}
-      @action: #{@action}
-      @tags: #{@tags}
-      @note: #{@note}
+        @file: #{@file}
+        @project: #{@project}
+        @parent: #{@parent.join('>')}
+        @action: #{@action}
+        @tags: #{@tags}
+        @note: #{@note}
       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
-    ##
+    #
+    # Pretty print an action with color and template formatting
+    #
+    # @param extension [String] File extension
+    # @param template [Hash] Color template
+    # @param regexes [Array] Regexes to highlight
+    # @param notes [Boolean] Include notes
+    # @param detect_width [Boolean] Detect terminal width
+    # @return [String]
     def pretty(extension: 'taskpaper', template: {}, regexes: [], notes: false, detect_width: true)
       NA::Benchmark.measure('Action.pretty') do
         # Use cached theme instead of loading every time
@@ -98,24 +113,29 @@ module NA
         # Create the hierarchical parent string (optimized)
         parents = if needs_parents && @parent.any?
                     parent_parts = @parent.map { |par| "#{template[:parent]}#{par}" }.join(template[:parent_divider])
-                    NA::Color.template("{x}#{template[:bracket]}[#{template[:error]}#{parent_parts}#{template[:bracket]}]{x} ")
+                    NA::Color.template("{x}#{template[:bracket]}[#{template[:error]}#{parent_parts}{x}#{template[:bracket]}]{x} ")
                   else
                     ''
                   end
 
         # Create the project string (optimized)
         project = if needs_project && !@project.empty?
-                    NA::Color.template("#{template[:project]}#{@project}{x} ")
+                    NA::Color.template("{x}#{template[:project]}#{@project}{x} ")
                   else
                     ''
                   end
 
         # Create the source filename string (optimized)
         filename = if needs_filename
-                     file = @file.sub(%r{^\./}, '').sub(/#{ENV['HOME']}/, '~')
-                     file = file.sub(/\.#{extension}$/, '') unless NA.include_ext
-                     file = file.highlight_filename
-                     NA::Color.template("#{template[:filename]}#{file} {x}")
+                     path = @file.sub(%r{^\./}, '').sub(/#{Dir.home}/, '~')
+                     if File.dirname(path) == '.'
+                       fname = NA.include_ext ? File.basename(path) : File.basename(path, ".#{extension}")
+                       fname = "./#{fname}" if NA.show_cwd_indicator
+                       NA::Color.template("#{template[:filename]}#{fname} {x}")
+                     else
+                       colored = (NA.include_ext ? path : path.sub(/\.#{extension}$/, '')).highlight_filename
+                       NA::Color.template("#{template[:filename]}#{colored} {x}")
+                     end
                    else
                      ''
                    end
@@ -138,44 +158,58 @@ module NA
               # Cache width calculation
               width = @cached_width ||= TTY::Screen.columns
               # Calculate indent more efficiently - avoid repeated template processing
-              base_template = output_template.gsub(/%action/, '').gsub(/%note/, '')
-              base_output = base_template.gsub(/%filename/, filename).gsub(/%project/, project).gsub(/%parents?/, parents)
+              base_template = output_template.gsub('%action', '').gsub('%note', '')
+              base_output = base_template.gsub('%filename', filename).gsub('%project', project).gsub(/%parents?/,
+                                                                                                     parents)
               indent = NA::Color.uncolor(NA::Color.template(base_output)).length
               note = NA::Color.template(@note.wrap(width, indent, template[:note]))
             else
-              note = NA::Color.template("\n#{@note.map { |l| "  #{template[:note]}• #{l}{x}" }.join("\n")}")
+              note = NA::Color.template("\n#{@note.map { |l| "  {x}#{template[:note]}• #{l}{x}" }.join("\n")}")
             end
           else
-            action += "#{template[:note]}*"
+            action += "{x}#{template[:note]}*"
           end
         end
 
         # Wrap action if needed (optimized)
         if detect_width && !action.empty?
           width = @cached_width ||= TTY::Screen.columns
-          base_template = output_template.gsub(/%action/, '').gsub(/%note/, '')
-          base_output = base_template.gsub(/%filename/, filename).gsub(/%project/, project).gsub(/%parents?/, parents)
+          base_template = output_template.gsub('%action', '').gsub('%note', '')
+          base_output = base_template.gsub('%filename', filename).gsub('%project', project).gsub(/%parents?/, parents)
           indent = NA::Color.uncolor(NA::Color.template(base_output)).length
           action = action.wrap(width, indent)
         end
 
         # Replace variables in template string and output colorized (optimized)
         final_output = output_template.dup
-        final_output.gsub!(/%filename/, filename)
-        final_output.gsub!(/%project/, project)
+        final_output.gsub!('%filename', filename)
+        final_output.gsub!('%project', project)
         final_output.gsub!(/%parents?/, parents)
-        final_output.gsub!(/%action/, action.highlight_search(regexes))
-        final_output.gsub!(/%note/, note)
-        final_output.gsub!(/\\\{/, '{')
+        final_output.gsub!('%action', action.highlight_search(regexes))
+        final_output.gsub!('%note', note)
+        final_output.gsub!('\\{', '{')
 
         NA::Color.template(final_output)
       end
     end
 
+    # Check if action tags match any, all, and none criteria
+    #
+    # @param any [Array] Tags to match any
+    # @param all [Array] Tags to match all
+    # @param none [Array] Tags to match none
+    # @return [Boolean]
     def tags_match?(any: [], all: [], none: [])
       tag_matches_any(any) && tag_matches_all(all) && tag_matches_none(none)
     end
 
+    # Check if action or note matches any, all, and none search criteria
+    #
+    # @param any [Array] Regexes to match any
+    # @param all [Array] Regexes to match all
+    # @param none [Array] Regexes to match none
+    # @param include_note [Boolean] Include note in search
+    # @return [Boolean]
     def search_match?(any: [], all: [], none: [], include_note: true)
       search_matches_any(any, include_note: include_note) &&
         search_matches_all(all, include_note: include_note) &&
@@ -184,6 +218,11 @@ module NA
 
     private
 
+    # Check if action and note do not match any regexes
+    #
+    # @param regexes [Array] Regexes to check
+    # @param include_note [Boolean] Include note in search
+    # @return [Boolean]
     def search_matches_none(regexes, include_note: true)
       regexes.each do |rx|
         regex = rx.is_a?(Regexp) ? rx : Regexp.new(rx, Regexp::IGNORECASE)
@@ -193,6 +232,11 @@ module NA
       true
     end
 
+    # Check if action or note matches any regexes
+    #
+    # @param regexes [Array] Regexes to check
+    # @param include_note [Boolean] Include note in search
+    # @return [Boolean]
     def search_matches_any(regexes, include_note: true)
       return true if regexes.empty?
 
@@ -204,6 +248,11 @@ module NA
       false
     end
 
+    # Check if action or note matches all regexes
+    #
+    # @param regexes [Array] Regexes to check
+    # @param include_note [Boolean] Include note in search
+    # @return [Boolean]
     def search_matches_all(regexes, include_note: true)
       regexes.each do |rx|
         regex = rx.is_a?(Regexp) ? rx : Regexp.new(rx, Regexp::IGNORECASE)
@@ -213,6 +262,10 @@ module NA
       true
     end
 
+    # Check if none of the tags match
+    #
+    # @param tags [Array] Tags to check
+    # @return [Boolean]
     def tag_matches_none(tags)
       tags.each do |tag|
         return false if compare_tag(tag)
@@ -220,6 +273,10 @@ module NA
       true
     end
 
+    # Check if any of the tags match
+    #
+    # @param tags [Array] Tags to check
+    # @return [Boolean]
     def tag_matches_any(tags)
       return true if tags.empty?
 
@@ -229,6 +286,10 @@ module NA
       false
     end
 
+    # Check if all of the tags match
+    #
+    # @param tags [Array] Tags to check
+    # @return [Boolean]
     def tag_matches_all(tags)
       tags.each do |tag|
         return false unless compare_tag(tag)
@@ -236,6 +297,10 @@ module NA
       true
     end
 
+    # Compare a tag against the action's tags with optional value comparison
+    #
+    # @param tag [Hash] Tag criteria
+    # @return [Boolean]
     def compare_tag(tag)
       tag_regex = tag[:tag].is_a?(Regexp) ? tag[:tag] : Regexp.new(tag[:tag], Regexp::IGNORECASE)
       keys = @tags.keys.delete_if { |k| k !~ tag_regex }