howzit 2.1.26 → 2.1.28

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 19fc185635709d53c4d7dcf0b437d4ec6b00cdd341d734e4655ef4e8e1dbfd3a
-  data.tar.gz: 9305e6edf7a8c4f7bf6d2d6a4a1aed14313aac73b658595a877314e929c15c8b
+  metadata.gz: cd3edf8d90a9cf744655479a0d81d11453d30d4d32f1f43cd719b6133b7c18d1
+  data.tar.gz: d8c862edff83fb8a456057682bf5063ddd7dfca44e37e45a97faee14482a1fdd
 SHA512:
-  metadata.gz: a35475dfaf7aa381157964466046ff8c94b0a4282bd9bbb8c067b7d344527d8ba95a296934ce935375111c4c255122cd3c684829d761b4962c517ea6dfadc14b
-  data.tar.gz: 41ae72b53d9602fb9b6df8231a4d1db8d9f134b78460e2243e8afaf616528279d0e7b08d68820a330994935579186058838a5d5e5c288b809aa46d0670b71b0f
+  metadata.gz: '08ef313bfa86f22c700610a114bafbbcf6aa769667ada6c007dad65370fc90cefad1562df99227676bc4e70fdaf0c82d751a0ecb86321ef09f0955e8d5bc1c23'
+  data.tar.gz: 026b8782c3f889adbf18dd4841faa709fd460eed3710c1402c089f5926f50c0340b2b9ec471baaf268cf456256a7ee3de8ad35741bac7b57f2fe0f0a931d8442

data/CHANGELOG.md

@@ -1,3 +1,39 @@
+### 2.1.28
+
+2025-12-31 10:21
+
+#### CHANGED
+
+- Refactored code to use more concise unless statement syntax
+
+#### NEW
+
+- Added "token" matching mode for multi-word searches that matches words in order
+
+#### IMPROVED
+
+- Enhanced fuzzy matching to use token-based approach for multi-word searches
+- Default partial matching now uses token-based matching for better multi-word search results
+
+#### FIXED
+
+- Improved error handling when topics are not found or invalid
+- Fixed topic selection when using interactive choose mode with topics that have named arguments
+- Added nil checks to prevent errors when arguments array is nil
+- Improved handling of empty search terms to prevent matching all topics
+
+### 2.1.27
+
+2025-12-26 08:59
+
+#### IMPROVED
+
+- Task titles now support variable substitution using ${VAR} syntax, so titles like "@run(echo test) Title with ${var}" will replace ${var} with its value from topic metadata. This applies to all task types (run, copy, open, include) and code block titles.
+
+#### FIXED
+
+- Task and topic names containing dollar signs (like $text$ or ${VAR}) now display correctly in run report output without causing color code interpretation issues. Dollar signs are properly escaped during formatting and unescaped in the final output.
+
 ### 2.1.26
 
 2025-12-26 04:53

data/lib/howzit/buildnote.rb

@@ -291,21 +291,17 @@ module Howzit
       title = File.basename(Dir.pwd)
       # prompt = TTY::Prompt.new
       if default
-        input = title
+        title
       else
         title = Prompt.get_line('{bw}Project name{x}'.c, default: title)
       end
       summary = ''
-      unless default
-        summary = Prompt.get_line('{bw}Project summary{x}'.c)
-      end
+      summary = Prompt.get_line('{bw}Project summary{x}'.c) unless default
 
       # Template selection
       selected_templates = []
       template_metadata = {}
-      unless default
-        selected_templates, template_metadata = select_templates_for_note(title)
-      end
+      selected_templates, template_metadata = select_templates_for_note(title) unless default
 
       fname = 'buildnotes.md'
       unless default
@@ -314,9 +310,7 @@ module Howzit
 
       # Build metadata section
       metadata_lines = []
-      unless selected_templates.empty?
-        metadata_lines << "template: #{selected_templates.join(',')}"
-      end
+      metadata_lines << "template: #{selected_templates.join(',')}" unless selected_templates.empty?
       template_metadata.each do |key, value|
         metadata_lines << "#{key}: #{value}"
       end
@@ -386,7 +380,7 @@ module Howzit
     ##
     ## @return     [Array<Array, Hash>] Array of [selected_template_names, required_vars_hash]
     ##
-    def select_templates_for_note(project_title)
+    def select_templates_for_note(_project_title)
       template_dir = Howzit.config.template_folder
       template_glob = File.join(template_dir, '*.md')
       template_files = Dir.glob(template_glob)
@@ -879,7 +873,21 @@ module Howzit
     ##                     single topic
     ##
     def process_topic(topic, run, single: false)
-      new_topic = topic.is_a?(String) ? find_topic(topic)[0] : topic.dup
+      if topic.is_a?(String)
+        matches = find_topic(topic)
+        new_topic = matches.empty? ? nil : matches[0]
+      else
+        new_topic = begin
+          topic.dup
+        rescue StandardError
+          topic
+        end
+      end
+
+      if new_topic.nil?
+        Howzit.console.warn "{br}ERROR:{xr} Topic not found or invalid: {bw}#{topic.is_a?(String) ? topic : topic.inspect}{x}".c
+        return ''
+      end
 
       output = if run
                  new_topic.run
@@ -946,13 +954,67 @@ module Howzit
         when :all
           topic_matches.concat(matches.sort_by(&:title))
         else
-          topic_matches.concat(Prompt.choose(matches.map(&:title), height: :max, query: Howzit.options[:grep]))
+          selected_titles = Prompt.choose(matches.map(&:title), height: :max, query: Howzit.options[:grep])
+          # Convert selected titles back to topic objects
+          selected_titles.each do |title|
+            matched_topic = matches.find { |t| t.title == title }
+            topic_matches.push(matched_topic) if matched_topic
+          end
         end
+        topic_matches.compact! # Remove any nil values
         process_topic_matches(topic_matches, output)
       elsif Howzit.options[:choose]
         topic_matches = []
         titles = Prompt.choose(list_topics, height: :max)
-        titles.each { |title| topic_matches.push(find_topic(title)[0]) }
+        titles.each do |selected_title|
+          selected_title = selected_title.strip
+          matched_topic = nil
+
+          # First, try to match by reconstructing the formatted title exactly as list_topics does
+          @topics.each do |topic|
+            formatted_title = topic.title.dup
+            formatted_title += "(#{topic.named_args.keys.join(', ')})" unless topic.named_args.empty?
+            formatted_title = formatted_title.strip
+
+            # Normalize both titles for comparison (remove extra whitespace, normalize case)
+            normalized_formatted = formatted_title.downcase.gsub(/\s+/, ' ')
+            normalized_selected = selected_title.downcase.gsub(/\s+/, ' ')
+
+            if formatted_title == selected_title || normalized_formatted == normalized_selected
+              matched_topic = topic
+              break
+            end
+          end
+
+          # If still not found, try matching by base title (without args)
+          unless matched_topic
+            clean_selected = selected_title.sub(/ *\([^)]*\) *$/, '').strip
+            matched_topic = @topics.find do |topic|
+              base_title = topic.title.strip
+              base_title.downcase == clean_selected.downcase || base_title == clean_selected
+            end
+          end
+
+          # Last resort: use find_topic with the cleaned title
+          unless matched_topic
+            clean_selected = selected_title.sub(/ *\([^)]*\) *$/, '').strip
+            matches = find_topic(clean_selected)
+            matched_topic = matches[0] unless matches.empty?
+          end
+
+          if matched_topic
+            topic_matches.push(matched_topic)
+          else
+            Howzit.console.warn "{br}WARNING:{xr} Could not find topic matching: {bw}#{selected_title}{x}".c
+          end
+        end
+
+        topic_matches.compact! # Remove any nil values
+        if topic_matches.empty?
+          output.push(%({bR}ERROR:{xr} No valid topics found from selection{x}\n).c)
+          Util.show(output.join("\n"), { color: true, highlight: false, paginate: false, wrap: 0 })
+          Process.exit 1
+        end
         process_topic_matches(topic_matches, output)
       elsif !Howzit.cli_args.empty?
         # Check if first arg is "default"
@@ -964,23 +1026,21 @@ module Howzit
           topic_matches = collect_topic_matches(search, output)
           process_topic_matches(topic_matches, output)
         end
-      else
+      elsif Howzit.options[:run]
         # No arguments
-        if Howzit.options[:run]
-          # Check for default metadata when running with no args
-          if @metadata.key?('default')
-            process_default_metadata(output)
-          else
-            Howzit.run_log = []
-            Howzit.multi_topic_run = topics.length > 1
-            topics.each { |k| output.push(process_topic(k, false, single: false)) }
-            finalize_output(output)
-          end
+        # Check for default metadata when running with no args
+        if @metadata.key?('default')
+          process_default_metadata(output)
         else
-          # Show all topics
+          Howzit.run_log = []
+          Howzit.multi_topic_run = topics.length > 1
           topics.each { |k| output.push(process_topic(k, false, single: false)) }
           finalize_output(output)
         end
+      else
+        # Show all topics
+        topics.each { |k| output.push(process_topic(k, false, single: false)) }
+        finalize_output(output)
       end
     end
 
@@ -996,7 +1056,12 @@ module Howzit
     def collect_topic_matches(search_terms, output)
       all_matches = []
 
+      # If no search terms, return empty (don't match all topics)
+      return [] if search_terms.nil? || search_terms.empty?
+
       search_terms.each do |s|
+        next if s.nil? || s.strip.empty?
+
         # First check for exact whole-word matches
         exact_matches = find_topic_exact(s)
 
@@ -1024,7 +1089,7 @@ module Howzit
     ##
     ## @return     [Array] Array of matched topics
     ##
-    def resolve_fuzzy_matches(search_term, output)
+    def resolve_fuzzy_matches(search_term, _output)
       matches = find_topic(search_term)
 
       return [] if matches.empty?
@@ -1039,11 +1104,12 @@ module Howzit
       else
         titles = matches.map(&:title)
         res = Prompt.choose(titles, query: search_term)
-        old_matching = Howzit.options[:matching]
-        Howzit.options[:matching] = 'exact'
-        selected = res.flat_map { |title| find_topic(title) }
-        Howzit.options[:matching] = old_matching
-        selected
+        # Convert selected titles back to topic objects from the original matches
+        res.flat_map do |title|
+          matched_topic = matches.find { |t| t.title == title }
+          matched_topic || find_topic(title)[0]
+        end.compact
+
       end
     end
 
@@ -1065,7 +1131,15 @@ module Howzit
       end
 
       if !topic_matches.empty?
-        topic_matches.map! { |topic| topic.is_a?(String) ? find_topic(topic)[0] : topic }
+        topic_matches.map! do |topic|
+          if topic.is_a?(String)
+            matches = find_topic(topic)
+            matches.empty? ? nil : matches[0]
+          elsif topic.is_a?(Howzit::Topic)
+            topic
+          end
+        end
+        topic_matches.compact! # Remove any nil values from failed matches
         topic_matches.each { |topic_match| output.push(process_topic(topic_match, Howzit.options[:run], single: true)) }
       else
         topics.each { |k| output.push(process_topic(k, false, single: false)) }
@@ -1107,11 +1181,11 @@ module Howzit
       # Run each topic with its specific arguments
       topic_specs.each do |topic_match, args|
         # Set arguments if provided, otherwise clear them
-        if args && !args.empty?
-          Howzit.arguments = args.split(/ *, */).map(&:render_arguments)
-        else
-          Howzit.arguments = []
-        end
+        Howzit.arguments = if args && !args.empty?
+                             args.split(/ *, */).map(&:render_arguments)
+                           else
+                             []
+                           end
         output.push(process_topic(topic_match, Howzit.options[:run], single: true))
       end
       finalize_output(output)

data/lib/howzit/colors.rb

@@ -288,8 +288,8 @@ module Howzit
                    d: dark, b: bold, u: underline, i: italic, x: reset }
 
         result = fmt.empty? ? input : format(fmt, colors)
-        # Unescape braces that were escaped to prevent color code interpretation
-        result.gsub(/\\\{/, '{').gsub(/\\\}/, '}')
+        # Unescape braces and dollar signs that were escaped to prevent color code interpretation
+        result.gsub(/\\\{/, '{').gsub(/\\\}/, '}').gsub(/\\\$/, '$')
       end
     end
 

data/lib/howzit/run_report.rb

@@ -30,13 +30,13 @@ module Howzit
       symbol = entry[:success] ? '✅' : '❌'
       parts = ["#{symbol} "]
       if prefix_topic && entry[:topic] && !entry[:topic].empty?
-        # Escape braces in topic name to prevent color code interpretation
-        topic_escaped = entry[:topic].gsub(/\{/, '\\{').gsub(/\}/, '\\}')
+        # Escape braces and dollar signs in topic name to prevent color code interpretation
+        topic_escaped = entry[:topic].gsub(/\{/, '\\{').gsub(/\}/, '\\}').gsub(/\$/, '\\$')
         parts << "{bw}#{topic_escaped}{x}: "
       end
-      # Escape braces in task name to prevent color code interpretation
-      task_escaped = entry[:task].gsub(/\{/, '\\{').gsub(/\}/, '\\}')
-      parts << "{by}#{task_escaped}{x}"
+      # Escape braces and dollar signs in task name to prevent color code interpretation
+      task_escaped = entry[:task].gsub(/\{/, '\\{').gsub(/\}/, '\\}').gsub(/\$/, '\\$')
+      parts << "{by}#{task_escaped} {x}"
       unless entry[:success]
         reason = entry[:exit_status] ? "exit code #{entry[:exit_status]}" : 'failed'
         parts << " {br}(#{reason}){x}"
@@ -82,15 +82,15 @@ module Howzit
       task_parts_plain = []
 
       if prefix_topic && entry[:topic] && !entry[:topic].empty?
-        # Escape braces in topic name to prevent color code interpretation
-        topic_escaped = entry[:topic].gsub(/\{/, '\\{').gsub(/\}/, '\\}')
+        # Escape braces and dollar signs in topic name to prevent color code interpretation
+        topic_escaped = entry[:topic].gsub(/\{/, '\\{').gsub(/\}/, '\\}').gsub(/\$/, '\\$')
         task_parts << "{bw}#{topic_escaped}{x}: "
         task_parts_plain << "#{entry[:topic]}: "
       end
 
-      # Escape braces in task name to prevent color code interpretation
-      task_escaped = entry[:task].gsub(/\{/, '\\{').gsub(/\}/, '\\}')
-      task_parts << "{by}#{task_escaped}{x}"
+      # Escape braces and dollar signs in task name to prevent color code interpretation
+      task_escaped = entry[:task].gsub(/\{/, '\\{').gsub(/\}/, '\\}').gsub(/\$/, '\\$')
+      task_parts << "{by}#{task_escaped} {x}"
       task_parts_plain << entry[:task]
 
       unless entry[:success]

data/lib/howzit/stringutils.rb

@@ -175,9 +175,43 @@ module Howzit
       when 'beginswith'
         /^#{self}/i
       when 'fuzzy'
-        /#{split(//).join('.{0,3}?')}/i
+        # For fuzzy matching, use token-based matching where each word gets fuzzy character matching
+        # This allows "lst tst" to match "List Available Tests" by applying fuzzy matching to each token
+        words = split(/\s+/).reject(&:empty?)
+        if words.length > 1
+          # Multiple words: apply character-by-character fuzzy matching to each word token
+          # Then allow flexible matching between words
+          pattern = words.map do |w|
+            # Apply fuzzy matching to each word (character-by-character with up to 3 chars between)
+            w.split(//).map { |c| Regexp.escape(c) }.join('.{0,3}?')
+          end.join('.*')
+          /#{pattern}/i
+        else
+          # Single word: character-by-character fuzzy matching for flexibility
+          /#{split(//).join('.{0,3}?')}/i
+        end
+      when 'token'
+        # Token-based matching: match words in order with any text between them
+        # "list tests" matches "list available tests", "list of tests", etc.
+        words = split(/\s+/).reject(&:empty?)
+        if words.length > 1
+          pattern = words.map { |w| Regexp.escape(w) }.join('.*')
+          /#{pattern}/i
+        else
+          /#{Regexp.escape(self)}/i
+        end
       else
-        /#{self}/i
+        # Default 'partial' mode: token-based matching for multi-word searches
+        # This allows "list tests" to match "list available tests"
+        words = split(/\s+/).reject(&:empty?)
+        if words.length > 1
+          # Token-based: match words in order with any text between
+          pattern = words.map { |w| Regexp.escape(w) }.join('.*')
+          /#{pattern}/i
+        else
+          # Single word: simple substring match
+          /#{Regexp.escape(self)}/i
+        end
       end
     end
 

data/lib/howzit/topic.rb

@@ -37,7 +37,7 @@ module Howzit
       args.each_with_index do |arg, idx|
         arg_name, default = arg.split(/:/).map(&:strip)
 
-        @named_args[arg_name] = if Howzit.arguments.count >= idx + 1
+        @named_args[arg_name] = if Howzit.arguments && Howzit.arguments.count >= idx + 1
                                   Howzit.arguments[idx]
                                 else
                                   default
@@ -175,6 +175,7 @@ module Howzit
       return [] if matches.empty?
 
       topic = matches[0]
+      return [] if topic.nil?
 
       rule = '{kKd}'
       color = '{Kyd}'
@@ -302,26 +303,31 @@ module Howzit
                     title: title.dup,  # Make a copy to avoid reference issues
                     action: obj,
                     parent: self }
+      # Set named_arguments before processing titles for variable substitution
+      Howzit.named_arguments = @named_args
       case cmd
       when /include/i
         if title =~ /\[(.*?)\] *$/
-          Howzit.named_arguments = @named_args
           args = Regexp.last_match(1).split(/ *, */).map(&:render_arguments)
           Howzit.arguments = args
           arguments
           title.sub!(/ *\[.*?\] *$/, '')
-          task_args[:title] = title
         end
+        # Apply variable substitution to title after bracket processing
+        task_args[:title] = title.render_arguments
 
         task_args[:type] = :include
         task_args[:arguments] = Howzit.named_arguments
       when /run/i
         task_args[:type] = :run
+        task_args[:title] = title.render_arguments
       when /copy/i
         task_args[:type] = :copy
         task_args[:action] = Shellwords.escape(obj)
+        task_args[:title] = title.render_arguments
       when /open|url/i
         task_args[:type] = :open
+        task_args[:title] = title.render_arguments
       end
 
       task_args
@@ -373,6 +379,8 @@ module Howzit
         if c[:cmd].nil?
           optional, default = define_optional(c[:optional2])
           title = c[:title2].nil? ? '' : c[:title2].strip
+          # Apply variable substitution to block title
+          title = title.render_arguments if title && !title.empty?
           block = c[:block]&.strip
           runnable << Howzit::Task.new({ type: :block,
                                          title: title,

data/lib/howzit/version.rb

@@ -3,5 +3,5 @@
 # Primary module for this gem.
 module Howzit
   # Current Howzit version.
-  VERSION = '2.1.26'
+  VERSION = '2.1.28'
 end

data/lib/howzit.rb

@@ -13,7 +13,7 @@ COLOR_FILE = 'theme.yaml'
 IGNORE_FILE = 'ignore.yaml'
 
 # Available options for matching method
-MATCHING_OPTIONS = %w[partial exact fuzzy beginswith].freeze
+MATCHING_OPTIONS = %w[partial exact fuzzy beginswith token].freeze
 
 # Available options for multiple_matches method
 MULTIPLE_OPTIONS = %w[first best all choose].freeze

data/spec/run_report_spec.rb

@@ -47,5 +47,25 @@ describe Howzit::RunReport do
     # Second line should be separator
     expect(lines[1]).to match(/^\|[\s:-]+\|[\s:-]+\|$/)
   end
+
+  it 'preserves dollar signs in task names without interfering with color codes' do
+    Howzit::RunReport.log({ topic: 'Test Topic', task: '$text$', success: true, exit_status: 0 })
+    Howzit::RunReport.log({ topic: 'Test', task: 'echo ${VAR}', success: true, exit_status: 0 })
+    plain = Howzit::RunReport.format.uncolor
+    expect(plain).to include('$text$')
+    expect(plain).to include('${VAR}')
+    # Verify dollar signs are preserved and not causing color code issues
+    expect(plain).not_to include('{x}')
+    expect(plain.scan(/\$\{x\}/).length).to eq(0)
+  end
+
+  it 'preserves dollar signs in topic names without interfering with color codes' do
+    Howzit.multi_topic_run = true
+    Howzit::RunReport.log({ topic: '$dollar$ Topic', task: 'Some Task', success: true, exit_status: 0 })
+    plain = Howzit::RunReport.format.uncolor
+    expect(plain).to include('$dollar$ Topic')
+    expect(plain).not_to include('{x}')
+    expect(plain.scan(/\$\{x\}/).length).to eq(0)
+  end
 end
 

data/spec/topic_spec.rb

@@ -101,4 +101,33 @@ describe Howzit::Topic do
       expect(topic.print_out({ single: true, header: true }).join("\n").uncolor).to match(/▶ ls -1/)
     end
   end
+
+
+  describe '.arguments' do
+    before do
+      Howzit.arguments = []
+    end
+
+    it 'extracts named arguments from topic title with defaults' do
+      topic = Howzit::Topic.new('Test Topic (var1:default1, var2:default2)', 'Content')
+      expect(topic.named_args['var1']).to eq('default1')
+      expect(topic.named_args['var2']).to eq('default2')
+    end
+
+    it 'does nothing when title has no arguments' do
+      topic = Howzit::Topic.new('Test Topic', 'Content')
+      expect(topic.named_args).to eq({})
+    end
+
+    it 'cleans title after extracting arguments' do
+      topic = Howzit::Topic.new('Test Topic (var:val)', 'Content')
+      expect(topic.title).to eq('Test Topic')
+    end
+
+    it 'uses provided arguments over defaults' do
+      Howzit.arguments = ['provided_value']
+      topic = Howzit::Topic.new('Test Topic (var:default_value)', 'Content')
+      expect(topic.named_args['var']).to eq('provided_value')
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: howzit
 version: !ruby/object:Gem::Version
-  version: 2.1.26
+  version: 2.1.28
 platform: ruby
 authors:
 - Brett Terpstra