na 1.2.80 → 1.2.81

data/lib/na/actions.rb

@@ -5,24 +5,19 @@ 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 = {})
       NA::Benchmark.measure('Actions.output') do
         defaults = {
@@ -31,87 +26,94 @@ module NA
           notes: false,
           nest: false,
           nest_projects: false,
-          no_files: 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))
-          end
-        else
-          template = NA.theme[:templates][:default]
-          template = NA.theme[:templates][:no_file] if config[:no_files]
+            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
+            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?
+            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
-        end
-        NA::Pager.page out.join("\n")
-      else
-        # Optimize template selection
-        template = case
-        when config[:no_files]
-          NA.theme[:templates][:no_file]
-        when config[:files]&.count&.positive?
-          config[:files].count == 1 ? NA.theme[:templates][:single_file] : NA.theme[:templates][:multi_file]
-        when depth > 1
-          NA.theme[:templates][:multi_file]
+          NA::Pager.page out.join("\n")
         else
-          NA.theme[:templates][:default]
-        end
-        template += "%note" if config[:notes]
+          # 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]
 
-        # Skip debug output if not verbose
-        config[:files]&.each { |f| NA.notify(f, debug: true) } if config[:files] && NA.verbose
+          # 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
 
-        # 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
+          # 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
 
-        # 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])
+          # 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
-        end
 
-        NA::Benchmark.measure('Pager.page call') do
-          NA::Pager.page(output)
+          NA::Benchmark.measure('Pager.page call') do
+            NA::Pager.page(output)
+          end
         end
       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

@@ -5,12 +5,19 @@ module NA
     class << self
       attr_accessor :enabled, :timings
 
+      # Initialize benchmarking state
+      #
+      # @return [void]
       def init
-        @enabled = ENV['NA_BENCHMARK'] == '1' || ENV['NA_BENCHMARK'] == 'true'
+        @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
 
@@ -21,24 +28,29 @@ module NA
         result
       end
 
+      # Output a performance report to STDERR
+      #
+      # @return [void]
       def report
         return unless @enabled
 
         total = @timings.sum { |t| t[:duration] }
-        $stderr.puts "\n#{NA::Color.template('{y}=== NA Performance Report ===')}"
-        $stderr.puts NA::Color.template("{dw}Total: {bw}#{total.round(2)}ms{x}")
-        $stderr.puts NA::Color.template("{dw}GC Count: {bw}#{GC.count}{x}") if defined?(GC)
-        $stderr.puts NA::Color.template("{dw}Memory: {bw}#{(GC.stat[:heap_live_slots] * 40 / 1024.0).round(1)}KB{x}") if defined?(GC)
-        $stderr.puts ""
+        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 > 0 ? ((timing[:duration] / total) * 100).round(1) : 0
+          pct = total.positive? ? ((timing[:duration] / total) * 100).round(1) : 0
           bar = '█' * [(pct / 2).round, 50].min
-          $stderr.puts NA::Color.template(
+          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
-        $stderr.puts NA::Color.template("{y}#{'=' * 50}{x}\n")
+        warn NA::Color.template("{y}#{'=' * 50}{x}\n")
       end
     end
   end

data/lib/na/colors.rb

@@ -5,7 +5,7 @@ module NA
   # Terminal output color functions.
   module Color
     # Regexp to match excape sequences
-    ESCAPE_REGEX = /(?<=\[)(?:(?:(?:[349]|10)[0-9]|[0-9])?;?)+(?=m)/
+    ESCAPE_REGEX = /(?<=\[)(?:(?:(?:[349]|10)[0-9]|[0-9])?;?)+(?=m)/.freeze
 
     # All available color names. Available as methods and string extensions.
     #
@@ -99,35 +99,33 @@ module NA
 
     # Template coloring
     class ::String
-      ##
-      ## Extract the longest valid %color name from a string.
-      ##
-      ## Allows %colors to bleed into other text and still
-      ## be recognized, e.g. %greensomething still finds
-      ## %green.
-      ##
-      ## @return     [String] a valid color name
-      ##
+      # Extract the longest valid %color name from a string.
+      #
+      # Allows %colors to bleed into other text and still
+      # be recognized, e.g. %greensomething still finds
+      # %green.
+      #
+      # @return [String] a valid color name
       def validate_color
         valid_color = nil
         compiled = ''
-        normalize_color.split('').each do |char|
+        normalize_color.chars.each do |char|
           compiled += char
-          valid_color = compiled if Color.attributes.include?(compiled.to_sym) || compiled =~ /^([fb]g?)?#([a-f0-9]{6})$/i
+          if Color.attributes.include?(compiled.to_sym) || compiled =~ /^([fb]g?)?#([a-f0-9]{6})$/i
+            valid_color = compiled
+          end
         end
 
         valid_color
       end
 
-      ##
-      ## Normalize a color name, removing underscores,
-      ## replacing "bright" with "bold", and converting
-      ## bgbold to boldbg
-      ##
-      ## @return     [String] Normalized color name
-      ##
+      # Normalize a color name, removing underscores,
+      # replacing "bright" with "bold", and converting
+      # bgbold to boldbg
+      #
+      # @return [String] Normalized color name
       def normalize_color
-        gsub(/_/, '').sub(/bright/i, 'bold').sub(/bgbold/, 'boldbg')
+        gsub('_', '').sub(/bright/i, 'bold').sub('bgbold', 'boldbg')
       end
 
       # Get the calculated ANSI color at the end of the
@@ -159,20 +157,20 @@ module NA
               rgbb = c
             end
           else
-            c.split(/;/).each do |i|
+            c.split(';').each do |i|
               x = i.to_i
               if x <= 9
                 em << x
-              elsif x >= 30 && x <= 39
+              elsif x.between?(30, 39)
                 rgbf = nil
                 fg = x
-              elsif x >= 40 && x <= 49
+              elsif x.between?(40, 49)
                 rgbb = nil
                 bg = x
-              elsif x >= 90 && x <= 97
+              elsif x.between?(90, 97)
                 rgbf = nil
                 fg = x
-              elsif x >= 100 && x <= 107
+              elsif x.between?(100, 107)
                 rgbb = nil
                 bg = x
               end
@@ -208,48 +206,48 @@ module NA
       # Pre-computed colors hash (expensive to create, so we cache it)
       def colors_hash
         @colors_hash ||= { w: white, k: black, g: green, l: blue,
-                          y: yellow, c: cyan, m: magenta, r: red,
-                          W: bgwhite, K: bgblack, G: bggreen, L: bgblue,
-                          Y: bgyellow, C: bgcyan, M: bgmagenta, R: bgred,
-                          d: dark, b: bold, u: underline, i: italic, x: reset }
+                           y: yellow, c: cyan, m: magenta, r: red,
+                           W: bgwhite, K: bgblack, G: bggreen, L: bgblue,
+                           Y: bgyellow, C: bgcyan, M: bgmagenta, R: bgred,
+                           d: dark, b: bold, u: underline, i: italic, x: reset }
       end
 
-      ##
-      ## Enables colored output
-      ##
-      ## @example Turn color on or off based on TTY
-      ##   NA::Color.coloring = STDOUT.isatty
+      #
+      # Enables colored output
+      #
+      # @example Turn color on or off based on TTY
+      #   NA::Color.coloring = STDOUT.isatty
       def coloring
         @coloring ||= true
       end
 
-      ##
-      ## Convert a template string to a colored string.
-      ## Colors are specified with single letters inside
-      ## curly braces. Uppercase changes background color.
-      ##
-      ## w: white, k: black, g: green, l: blue, y: yellow,
-      ## c: cyan, m: magenta, r: red, b: bold, u: underline,
-      ## i: italic, x: reset (remove background, color,
-      ## emphasis)
-      ##
-      ## Also accepts {#RGB} and {#RRGGBB} strings. Put a b
-      ## before the hash to make it a background color
-      ##
-      ## @example    Convert a templated string
-      ## Color.template('{Rwb}Warning:{x} {w}you look a
-      ## little {g}ill{x}')
-      ##
-      ## @example    Convert using RGB colors
-      ## Color.template('{#f0a}This is an RGB color')
-      ##
-      ## @param      input  [String, Array] The template
-      ##                    string. If this is an array, the
-      ##                    elements will be joined with a
-      ##                    space.
-      ##
-      ## @return     [String] Colorized string
-      ##
+      #
+      # Convert a template string to a colored string.
+      # Colors are specified with single letters inside
+      # curly braces. Uppercase changes background color.
+      #
+      # w: white, k: black, g: green, l: blue, y: yellow,
+      # c: cyan, m: magenta, r: red, b: bold, u: underline,
+      # i: italic, x: reset (remove background, color,
+      # emphasis)
+      #
+      # Also accepts {#RGB} and {#RRGGBB} strings. Put a b
+      # before the hash to make it a background color
+      #
+      # @example    Convert a templated string
+      # Color.template('{Rwb}Warning:{x} {w}you look a
+      # little {g}ill{x}')
+      #
+      # @example    Convert using RGB colors
+      # Color.template('{#f0a}This is an RGB color')
+      #
+      # @param      input  [String, Array] The template
+      #                    string. If this is an array, the
+      #                    elements will be joined with a
+      #                    space.
+      #
+      # @return     [String] Colorized string
+      #
       def template(input)
         input = input.join(' ') if input.is_a? Array
         return input.gsub(/(?<!\\)\{#?(\w+)\}/i, '') unless NA::Color.coloring?
@@ -265,9 +263,9 @@ module NA
         end
 
         # Convert to format string
-        fmt = processed_input.gsub(/%/, '%%')
+        fmt = processed_input.gsub('%', '%%')
         fmt = fmt.gsub(/(?<!\\)\{(\w+)\}/i) do
-          Regexp.last_match(1).split('').map { |c| "%<#{c}>s" }.join('')
+          Regexp.last_match(1).chars.map { |c| "%<#{c}>s" }.join
         end
 
         # Use pre-computed colors hash
@@ -283,18 +281,18 @@ module NA
       new_method = <<-EOSCRIPT
         # Color string as #{c}
         def #{c}(string = nil)
-          result = ''
-          result << "\e[#{v}m" if NA::Color.coloring?
+          result = ''.dup
+          result << "\e[#{v}m".dup if NA::Color.coloring?
           if block_given?
             result << yield
           elsif string.respond_to?(:to_str)
-            result << string.to_str
+            result << string.to_str.dup
           elsif respond_to?(:to_str)
-            result << to_str
+            result << to_str.dup
           else
             return result #only switch on
           end
-          result << "\e[0m" if NA::Color.coloring?
+          result << "\e[0m".dup if NA::Color.coloring?
           result
         end
       EOSCRIPT
@@ -306,19 +304,19 @@ module NA
       # Accept brightwhite in addition to boldwhite
       new_method = <<-EOSCRIPT
         # color string as #{c}
-        def #{c.to_s.sub(/bold/, 'bright')}(string = nil)
-          result = ''
-          result << "\e[#{v}m" if NA::Color.coloring?
+        def #{c.to_s.sub('bold', 'bright')}(string = nil)
+          result = ''.dup
+          result << "\e[#{v}m".dup if NA::Color.coloring?
           if block_given?
             result << yield
           elsif string.respond_to?(:to_str)
-            result << string.to_str
+            result << string.to_str.dup
           elsif respond_to?(:to_str)
-            result << to_str
+            result << to_str.dup
           else
             return result #only switch on
           end
-          result << "\e[0m" if NA::Color.coloring?
+          result << "\e[0m".dup if NA::Color.coloring?
           result
         end
       EOSCRIPT
@@ -326,13 +324,13 @@ module NA
       module_eval(new_method)
     end
 
-    ##
-    ## Generate escape codes for hex colors
-    ##
-    ## @param      hex   [String] The hexadecimal color code
-    ##
-    ## @return     [String] ANSI escape string
-    ##
+    #
+    # Generate escape codes for hex colors
+    #
+    # @param      hex   [String] The hexadecimal color code
+    #
+    # @return     [String] ANSI escape string
+    #
     def rgb(hex)
       is_bg = hex.match(/^bg?#/) ? true : false
       hex_string = hex.sub(/^([fb]g?)?#/, '')
@@ -345,13 +343,12 @@ module NA
           t << parts[e]
           t << parts[e]
         end
-        hex_string = t.join('')
+        hex_string = t.join
       end
 
       parts = hex_string.match(/(?<r>..)(?<g>..)(?<b>..)/)
-      t = []
-      %w[r g b].each do |e|
-        t << parts[e].hex
+      t = %w[r g b].map do |e|
+        parts[e].hex
       end
 
       "\e[#{is_bg ? '48' : '38'};2;#{t.join(';')}m"
@@ -359,7 +356,7 @@ module NA
 
     # Regular expression that is used to scan for ANSI-sequences while
     # uncoloring strings.
-    COLORED_REGEXP = /\e\[(?:(?:(?:[349]|10)[0-9]|[0-9])?;?)+m/
+    COLORED_REGEXP = /\e\[(?:(?:(?:[349]|10)[0-9]|[0-9])?;?)+m/.freeze
 
     # Returns an uncolored version of the string, that is all
     # ANSI-sequences are stripped from the string.
@@ -379,6 +376,7 @@ module NA
     def attributes
       ATTRIBUTE_NAMES
     end
+
     extend self
   end
 end

data/lib/na/editor.rb

@@ -1,16 +1,20 @@
+# frozen_string_literal: true
+
+require 'English'
+
 module NA
   module Editor
     class << self
       def default_editor(prefer_git_editor: true)
-        if prefer_git_editor
-          editor ||= ENV['NA_EDITOR'] || ENV['GIT_EDITOR'] || ENV['EDITOR']
-        else
-          editor ||= ENV['NA_EDITOR'] || ENV['EDITOR'] || ENV['GIT_EDITOR']
-        end
+        editor ||= if prefer_git_editor
+                     ENV['NA_EDITOR'] || ENV['GIT_EDITOR'] || ENV.fetch('EDITOR', nil)
+                   else
+                     ENV['NA_EDITOR'] || ENV['EDITOR'] || ENV.fetch('GIT_EDITOR', nil)
+                   end
 
         return editor if editor&.good? && TTY::Which.exist?(editor)
 
-        NA.notify("No EDITOR environment variable, testing available editors", debug: true)
+        NA.notify('No EDITOR environment variable, testing available editors', debug: true)
         editors = %w[vim vi code subl mate mvim nano emacs]
         editors.each do |ed|
           try = TTY::Which.which(ed)
@@ -43,11 +47,10 @@ module NA
         "#{editor} #{args.join(' ')}"
       end
 
-      ##
-      ## Create a process for an editor and wait for the file handle to return
-      ##
-      ## @param      input  [String] Text input for editor
-      ##
+      # Create a process for an editor and wait for the file handle to return
+      #
+      # @param input [String] Text input for editor
+      # @return [String] Edited text
       def fork_editor(input = '', message: :default)
         # raise NonInteractive, 'Non-interactive terminal' unless $stdout.isatty || ENV['DOING_EDITOR_TEST']
 
@@ -78,8 +81,8 @@ module NA
         Process.wait(pid)
 
         begin
-          if $?.exitstatus == 0
-            input = IO.read(tmpfile.path)
+          if $CHILD_STATUS.exitstatus.zero?
+            input = File.read(tmpfile.path)
           else
             exit_now! 'Cancelled'
           end
@@ -88,16 +91,13 @@ module NA
           tmpfile.unlink
         end
 
-        input.split(/\n/).delete_if(&:ignore?).join("\n")
+        input.split("\n").delete_if(&:ignore?).join("\n")
       end
 
-      ##
-      ## Takes a multi-line string and formats it as an entry
-      ##
-      ## @param      input  [String] The string to parse
-      ##
-      ## @return     [Array] [[String]title, [Note]note]
-      ##
+      # Takes a multi-line string and formats it as an entry
+      #
+      # @param input [String] The string to parse
+      # @return [Array] [[String]title, [Note]note]
       def format_input(input)
         NA.notify("#{NA.theme[:error]}No content in entry", exit_code: 1) if input.nil? || input.strip.empty?
 
@@ -108,7 +108,7 @@ module NA
         title = title.expand_date_tags
 
         note = if input_lines.length > 1
-                 input_lines[1..-1]
+                 input_lines[1..]
                else
                  []
                end