na 1.2.79 → 1.2.81

data/lib/na/action.rb

@@ -12,12 +12,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 +52,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,102 +64,153 @@ 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)
-      theme = NA::Theme.load_theme
-      template = theme.merge(template)
-
-      # Create the hierarchical parent string
-      parents = @parent.map do |par|
-        NA::Color.template("{x}#{template[:parent]}#{par}")
-      end.join(NA::Color.template(template[:parent_divider]))
-      parents = "#{NA.theme[:bracket]}[#{NA.theme[:error]}#{parents}#{NA.theme[:bracket]}]{x} "
-
-      # Create the project string
-      project = NA::Color.template("#{template[:project]}#{@project}{x} ")
-
-      # Create the source filename string, substituting ~ for HOME and removing extension
-      file = @file.sub(%r{^\./}, '').sub(/#{ENV['HOME']}/, '~')
-      file = file.sub(/\.#{extension}$/, '') unless NA.include_ext
-      # colorize the basename
-      file = file.highlight_filename
-      file_tpl = "#{template[:file]}#{file} {x}"
-      filename = NA::Color.template(file_tpl)
-
-      # colorize the action and highlight tags
-      @action.gsub!(/\{(.*?)\}/, '\\{\1\\}')
-      action = NA::Color.template("#{template[:action]}#{@action.sub(/ @#{NA.na_tag}\b/, '')}{x}")
-      action = action.highlight_tags(color: template[:tags],
-                                     parens: template[:value_parens],
-                                     value: template[:values],
-                                     last_color: template[:action])
-
-      if detect_width
-        width = TTY::Screen.columns
-        prefix = NA::Color.uncolor(pretty(template: { templates: { output: template[:templates][:output].sub(/%action/, '').sub(/%note/, '') } }, detect_width: false))
-        indent = prefix.length
-
-        # Add notes if needed
-        note = if notes && @note.count.positive?
-                 NA::Color.template(@note.wrap(width, indent, template[:note]))
-               elsif !notes && @note.count.positive?
-                 action += "#{template[:note]}*"
-               else
-                 ''
-               end
-
-        action = action.wrap(width, indent)
-      else
-        note = if notes && @note.count.positive?
-                 NA::Color.template("\n#{@note.map { |l| "  #{template[:note]}• #{l.wrap(width, indent)}{x}" }.join("\n")}")
-               elsif !notes && @note.count.positive?
-                 action += "#{template[:note]}*"
-               else
-                 ''
-               end
-      end
+      NA::Benchmark.measure('Action.pretty') do
+        # Use cached theme instead of loading every time
+        theme = NA.theme
+        template = theme.merge(template)
+
+        # Pre-compute common template parts to avoid repeated processing
+        output_template = template[:templates][:output]
+        needs_filename = output_template.include?('%filename')
+        needs_parents = output_template.include?('%parents') || output_template.include?('%parent')
+        needs_project = output_template.include?('%project')
+
+        # 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}{x}#{template[:bracket]}]{x} ")
+                  else
+                    ''
+                  end
+
+        # Create the project string (optimized)
+        project = if needs_project && !@project.empty?
+                    NA::Color.template("{x}#{template[:project]}#{@project}{x} ")
+                  else
+                    ''
+                  end
+
+        # Create the source filename string (optimized)
+        filename = if needs_filename
+                     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
+
+        # colorize the action and highlight tags (optimized)
+        action_text = @action.dup
+        action_text.gsub!(/\{(.*?)\}/, '\\{\1\\}')
+        action_text = action_text.sub(/ @#{NA.na_tag}\b/, '')
+        action = NA::Color.template("#{template[:action]}#{action_text}{x}")
+        action = action.highlight_tags(color: template[:tags],
+                                       parens: template[:value_parens],
+                                       value: template[:values],
+                                       last_color: template[:action])
+
+        # Handle notes and wrapping (optimized)
+        note = ''
+        if @note.any?
+          if notes
+            if detect_width
+              # 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)
+              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| "  {x}#{template[:note]}• #{l}{x}" }.join("\n")}")
+            end
+          else
+            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)
+          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!(/%parents?/, parents)
+        final_output.gsub!('%action', action.highlight_search(regexes))
+        final_output.gsub!('%note', note)
+        final_output.gsub!('\\{', '{')
 
-      # Replace variables in template string and output colorized
-      NA::Color.template(template[:templates][:output].gsub(/%filename/, filename)
-                          .gsub(/%project/, project)
-                          .gsub(/%parents?/, parents)
-                          .gsub(/%action/, action.highlight_search(regexes))
-                          .gsub(/%note/, note)).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) &&
@@ -157,32 +219,54 @@ 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|
-        note_matches = include_note && @note.join(' ').match(Regexp.new(rx, Regexp::IGNORECASE))
-        return false if @action.match(Regexp.new(rx, Regexp::IGNORECASE)) || note_matches
+        regex = rx.is_a?(Regexp) ? rx : Regexp.new(rx, Regexp::IGNORECASE)
+        note_matches = include_note && @note.join(' ').match(regex)
+        return false if @action.match(regex) || note_matches
       end
       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?
 
       regexes.each do |rx|
-        note_matches = include_note && @note.join(' ').match(Regexp.new(rx, Regexp::IGNORECASE))
-        return true if @action.match(Regexp.new(rx, Regexp::IGNORECASE)) || note_matches
+        regex = rx.is_a?(Regexp) ? rx : Regexp.new(rx, Regexp::IGNORECASE)
+        note_matches = include_note && @note.join(' ').match(regex)
+        return true if @action.match(regex) || note_matches
       end
       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|
-        note_matches = include_note && @note.join(' ').match(Regexp.new(rx, Regexp::IGNORECASE))
-        return false unless @action.match(Regexp.new(rx, Regexp::IGNORECASE)) || note_matches
+        regex = rx.is_a?(Regexp) ? rx : Regexp.new(rx, Regexp::IGNORECASE)
+        note_matches = include_note && @note.join(' ').match(regex)
+        return false unless @action.match(regex) || note_matches
       end
       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)
@@ -190,6 +274,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?
 
@@ -199,6 +287,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)
@@ -206,8 +298,13 @@ 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)
-      keys = @tags.keys.delete_if { |k| k !~ Regexp.new(tag[:tag], Regexp::IGNORECASE) }
+      tag_regex = tag[:tag].is_a?(Regexp) ? tag[:tag] : Regexp.new(tag[:tag], Regexp::IGNORECASE)
+      keys = @tags.keys.delete_if { |k| k !~ tag_regex }
       return false if keys.empty?
 
       key = keys[0]
@@ -220,6 +317,7 @@ module NA
 
       begin
         tag_date = Time.parse(tag_val)
+        require 'chronic' unless defined?(Chronic)
         date = Chronic.parse(val)
 
         raise ArgumentError if date.nil?

data/lib/na/actions.rb

@@ -5,89 +5,114 @@ module NA
   class Actions < Array
     def initialize(actions = [])
       super
-      concat(actions)
     end
 
-    ##
-    ## Pretty print a list of actions
-    ##
-    ## @param depth [Integer] The depth of the action
-    ## @param config [Hash] The configuration options
-    ##
-    ## @option config [Array] :files The files to include in the output
-    ## @option config [Array] :regexes The regexes to match against
-    ## @option config [Boolean] :notes Whether to include notes in the output
-    ## @option config [Boolean] :nest Whether to nest the output
-    ## @option config [Boolean] :nest_projects Whether to nest projects in the output
-    ## @option config [Boolean] :no_files Whether to include files in the output
-    ##
-    ## @return [String] The output string
-    ##
+    # Pretty print a list of actions
+    #
+    # @param depth [Integer] The depth of the action
+    # @param config [Hash] The configuration options
+    # @option config [Array] :files The files to include in the output
+    # @option config [Array] :regexes The regexes to match against
+    # @option config [Boolean] :notes Whether to include notes in the output
+    # @option config [Boolean] :nest Whether to nest the output
+    # @option config [Boolean] :nest_projects Whether to nest projects in the output
+    # @option config [Boolean] :no_files Whether to include files in the output
+    # @return [String] The output string
     def output(depth, config = {})
-      defaults = {
-        files: nil,
-        regexes: [],
-        notes: false,
-        nest: false,
-        nest_projects: false,
-        no_files: false,
-      }
-      config = defaults.merge(config)
+      NA::Benchmark.measure('Actions.output') do
+        defaults = {
+          files: nil,
+          regexes: [],
+          notes: false,
+          nest: false,
+          nest_projects: false,
+          no_files: false
+        }
+        config = defaults.merge(config)
 
-      return if config[:files].nil?
+        return if config[:files].nil?
 
-      if config[:nest]
-        template = NA.theme[:templates][:default]
-        template = NA.theme[:templates][:no_file] if config[:no_files]
+        if config[:nest]
+          template = NA.theme[:templates][:default]
+          template = NA.theme[:templates][:no_file] if config[:no_files]
 
-        parent_files = {}
-        out = []
+          parent_files = {}
+          out = []
 
-        if config[:nest_projects]
-          each do |action|
-            parent_files[action.file] ||= []
-            parent_files[action.file].push(action)
-          end
+          if config[:nest_projects]
+            each do |action|
+              parent_files[action.file] ||= []
+              parent_files[action.file].push(action)
+            end
 
-          parent_files.each do |file, acts|
-            projects = NA.project_hierarchy(acts)
-            out.push("#{file.sub(%r{^./}, "").shorten_path}:")
-            out.concat(NA.output_children(projects, 0))
+            parent_files.each do |file, acts|
+              projects = NA.project_hierarchy(acts)
+              out.push("#{file.sub(%r{^./}, '').shorten_path}:")
+              out.concat(NA.output_children(projects, 0))
+            end
+          else
+            template = NA.theme[:templates][:default]
+            template = NA.theme[:templates][:no_file] if config[:no_files]
+
+            each do |action|
+              parent_files[action.file] ||= []
+              parent_files[action.file].push(action)
+            end
+
+            parent_files.each do |file, acts|
+              out.push("#{file.sub(%r{^\./}, '')}:")
+              acts.each do |a|
+                out.push("\t- [#{a.parent.join('/')}] #{a.action}")
+                out.push("\t\t#{a.note.join("\n\t\t")}") unless a.note.empty?
+              end
+            end
           end
+          NA::Pager.page out.join("\n")
         else
-          template = NA.theme[:templates][:default]
-          template = NA.theme[:templates][:no_file] if config[:no_files]
+          # Optimize template selection
+          template = if config[:no_files]
+                       NA.theme[:templates][:no_file]
+                     elsif config[:files]&.count&.positive?
+                       config[:files].count == 1 ? NA.theme[:templates][:single_file] : NA.theme[:templates][:multi_file]
+                     elsif depth > 1
+                       NA.theme[:templates][:multi_file]
+                     else
+                       NA.theme[:templates][:default]
+                     end
+          template += '%note' if config[:notes]
 
-          each do |action|
-            parent_files[action.file] ||= []
-            parent_files[action.file].push(action)
+          # Show './' for current directory only when listing also includes subdir files
+          if template == NA.theme[:templates][:multi_file]
+            has_subdir = config[:files]&.any? { |f| File.dirname(f) != '.' } || depth > 1
+            NA.show_cwd_indicator = !has_subdir.nil?
+          else
+            NA.show_cwd_indicator = false
           end
 
-          parent_files.each do |file, acts|
-            out.push("#{file.sub(%r{^\./}, "")}:")
-            acts.each do |a|
-              out.push("\t- [#{a.parent.join("/")}] #{a.action}")
-              out.push("\t\t#{a.note.join("\n\t\t")}") unless a.note.empty?
+          # Skip debug output if not verbose
+          config[:files]&.each { |f| NA.notify(f, debug: true) } if config[:files] && NA.verbose
+
+          # Optimize output generation - compile all output first, then apply regexes
+          output = String.new
+          NA::Benchmark.measure('Generate action strings') do
+            each_with_index do |action, idx|
+              # Generate raw output without regex processing
+              output << action.pretty(template: { templates: { output: template } }, regexes: [], notes: config[:notes])
+              output << "\n" unless idx == size - 1
             end
           end
-        end
-        NA::Pager.page out.join("\n")
-      else
-        template = if config[:no_files]
-            NA.theme[:templates][:no_file]
-          elsif config[:files].count.positive?
-            config[:files].count == 1 ? NA.theme[:templates][:single_file] : NA.theme[:templates][:multi_file]
-          elsif NA.find_files(depth: depth).count > 1
-            depth > 1 ? NA.theme[:templates][:multi_file] : NA.theme[:templates][:single_file]
-          else
-            NA.theme[:templates][:default]
-          end
-        template += "%note" if config[:notes]
 
-        config[:files].map { |f| NA.notify(f, debug: true) } if config[:files]
+          # Apply regex highlighting to the entire output at once
+          if config[:regexes].any?
+            NA::Benchmark.measure('Apply regex highlighting') do
+              output = output.highlight_search(config[:regexes])
+            end
+          end
 
-        output = map { |action| action.pretty(template: { templates: { output: template } }, regexes: config[:regexes], notes: config[:notes]) }
-        NA::Pager.page(output.join("\n"))
+          NA::Benchmark.measure('Pager.page call') do
+            NA::Pager.page(output)
+          end
+        end
       end
     end
   end

data/lib/na/array.rb

@@ -1,21 +1,25 @@
 # frozen_string_literal: true
 
 class ::Array
-  ##
-  ## Like Array#compact -- removes nil items, but also
-  ## removes empty strings, zero or negative numbers and FalseClass items
-  ##
-  ## @return     [Array] Array without "bad" elements
-  ##
+  # Like Array#compact -- removes nil items, but also
+  # removes empty strings, zero or negative numbers and FalseClass items
+  #
+  # @return [Array] Array without "bad" elements
   def remove_bad
     compact.map { |x| x.is_a?(String) ? x.strip : x }.select(&:good?)
   end
 
+  # Wrap each string in the array to the given width and indent, with color
+  #
+  # @param width [Integer] Maximum line width
+  # @param indent [Integer] Indentation spaces
+  # @param color [String] Color code to apply
+  # @return [Array, String] Wrapped and colorized lines
   def wrap(width, indent, color)
     return map { |l| "#{color}  #{l.wrap(width, 2)}" } if width < 60
 
     map! do |l|
-      "#{color}#{' ' * indent }• #{l.wrap(width, indent)}{x}"
+      "#{color}#{' ' * indent}• #{l.wrap(width, indent)}{x}"
     end
     "\n#{join("\n")}"
   end

data/lib/na/benchmark.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module NA
+  module Benchmark
+    class << self
+      attr_accessor :enabled, :timings
+
+      # Initialize benchmarking state
+      #
+      # @return [void]
+      def init
+        @enabled = %w[1 true].include?(ENV.fetch('NA_BENCHMARK', nil))
+        @timings = []
+        @start_time = Time.now
+      end
+
+      # Measure the execution time of a block
+      #
+      # @param label [String] Label for the measurement
+      # @return [Object] Result of the block
+      def measure(label)
+        return yield unless @enabled
+
+        start = Time.now
+        result = yield
+        duration = ((Time.now - start) * 1000).round(2)
+        @timings << { label: label, duration: duration, timestamp: (start - @start_time) * 1000 }
+        result
+      end
+
+      # Output a performance report to STDERR
+      #
+      # @return [void]
+      def report
+        return unless @enabled
+
+        total = @timings.sum { |t| t[:duration] }
+        warn "\n#{NA::Color.template('{y}=== NA Performance Report ===')}"
+        warn NA::Color.template("{dw}Total: {bw}#{total.round(2)}ms{x}")
+        warn NA::Color.template("{dw}GC Count: {bw}#{GC.count}{x}") if defined?(GC)
+        if defined?(GC)
+          warn NA::Color.template("{dw}Memory: {bw}#{(GC.stat[:heap_live_slots] * 40 / 1024.0).round(1)}KB{x}")
+        end
+        warn ''
+
+        @timings.each do |timing|
+          pct = total.positive? ? ((timing[:duration] / total) * 100).round(1) : 0
+          bar = '█' * [(pct / 2).round, 50].min
+          warn NA::Color.template(
+            "{dw}[{y}#{bar.ljust(25)}{dw}] {bw}#{timing[:duration].to_s.rjust(7)}ms {dw}(#{pct.to_s.rjust(5)}%) {x}#{timing[:label]}"
+          )
+        end
+        warn NA::Color.template("{y}#{'=' * 50}{x}\n")
+      end
+    end
+  end
+end