howzit 2.1.27 → 2.1.29

data/lib/howzit/buildnote.rb

@@ -290,22 +290,14 @@ module Howzit
 
       title = File.basename(Dir.pwd)
       # prompt = TTY::Prompt.new
-      if default
-        input = title
-      else
-        title = Prompt.get_line('{bw}Project name{x}'.c, default: title)
-      end
+      title = Prompt.get_line('{bw}Project name{x}'.c, default: title) unless default
       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 +306,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 +376,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)
@@ -676,7 +666,7 @@ module Howzit
     ## @return     [String] file path
     ##
     def glob_note
-      Dir.glob('*.{txt,md,markdown}').select(&:build_note?).sort[0]
+      Dir.glob('*.{txt,md,markdown}').select(&:build_note?).min
     end
 
     ##
@@ -790,7 +780,7 @@ module Howzit
           title = "#{short_path}:#{title}"
         end
 
-        topic = Topic.new(title, prefix + lines.join("\n").strip.render_template(@metadata))
+        topic = Topic.new(title, prefix + lines.join("\n").strip.render_template(@metadata), @metadata)
 
         topics.push(topic)
       end
@@ -879,7 +869,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 +950,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 +1022,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 +1052,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 +1085,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?
@@ -1033,17 +1094,18 @@ module Howzit
       when :first
         [matches[0]]
       when :best
-        [matches.sort_by { |a| [a.title.comp_distance(search_term), a.title.length] }.first]
+        [matches.min_by { |a| [a.title.comp_distance(search_term), a.title.length] }]
       when :all
         matches
       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 +1127,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 +1177,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

@@ -281,11 +281,40 @@ module Howzit
           end
         end
 
-        colors = { 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 }
+        # Build colors hash from configured_colors, generating escape codes directly
+        color_map = configured_colors.to_h
+        colors = if coloring?
+                   {
+                     w: "\e[#{color_map[:white]}m",
+                     k: "\e[#{color_map[:black]}m",
+                     g: "\e[#{color_map[:green]}m",
+                     l: "\e[#{color_map[:blue]}m",
+                     y: "\e[#{color_map[:yellow]}m",
+                     c: "\e[#{color_map[:cyan]}m",
+                     m: "\e[#{color_map[:magenta]}m",
+                     r: "\e[#{color_map[:red]}m",
+                     W: "\e[#{color_map[:bgwhite]}m",
+                     K: "\e[#{color_map[:bgblack]}m",
+                     G: "\e[#{color_map[:bggreen]}m",
+                     L: "\e[#{color_map[:bgblue]}m",
+                     Y: "\e[#{color_map[:bgyellow]}m",
+                     C: "\e[#{color_map[:bgcyan]}m",
+                     M: "\e[#{color_map[:bgmagenta]}m",
+                     R: "\e[#{color_map[:bgred]}m",
+                     d: "\e[#{color_map[:dark]}m",
+                     b: "\e[#{color_map[:bold]}m",
+                     u: "\e[#{color_map[:underline]}m",
+                     i: "\e[#{color_map[:italic]}m",
+                     x: "\e[#{color_map[:reset]}m"
+                   }
+                 else
+                   # When coloring is disabled, return empty strings
+                   {
+                     w: '', k: '', g: '', l: '', y: '', c: '', m: '', r: '',
+                     W: '', K: '', G: '', L: '', Y: '', C: '', M: '', R: '',
+                     d: '', b: '', u: '', i: '', x: ''
+                   }
+                 end
 
         result = fmt.empty? ? input : format(fmt, colors)
         # Unescape braces and dollar signs that were escaped to prevent color code interpretation
@@ -295,24 +324,24 @@ module Howzit
 
     # Dynamically generate methods for each color name. Each
     # resulting method can be called with a string or a block.
-    configured_colors.each do |c, v|
+    Color.configured_colors.each do |c, v|
       new_method = <<-EOSCRIPT
-        # Color string as #{c}
-        def #{c}(string = nil)
-          result = ''
-          result << "\e[#{v}m" if Howzit::Color.coloring?
-          if block_given?
-            result << yield
-          elsif string.respond_to?(:to_str)
-            result << string.to_str
-          elsif respond_to?(:to_str)
-            result << to_str
-          else
-            return result #only switch on
+          # Color string as #{c}
+          def #{c}(string = nil)
+            result = ''
+            result << "\e[#{v}m" if Howzit::Color.coloring?
+            if block_given?
+              result << yield
+            elsif string.respond_to?(:to_str)
+              result << string.to_str
+            elsif respond_to?(:to_str)
+              result << to_str
+            else
+              return result #only switch on
+            end
+            result << "\e[0m" if Howzit::Color.coloring?
+            result
           end
-          result << "\e[0m" if Howzit::Color.coloring?
-          result
-        end
       EOSCRIPT
 
       module_eval(new_method)
@@ -383,6 +412,5 @@ module Howzit
     def attributes
       ATTRIBUTE_NAMES
     end
-    extend self
   end
 end

data/lib/howzit/condition_evaluator.rb

@@ -0,0 +1,307 @@
+# frozen_string_literal: true
+
+require 'English'
+
+module Howzit
+  # Condition Evaluator module
+  # Handles evaluation of @if/@unless conditions
+  module ConditionEvaluator
+    class << self
+      ##
+      ## Evaluate a condition expression
+      ##
+      ## @param      condition  [String] The condition to evaluate
+      ## @param      context    [Hash] Context with metadata, arguments, etc.
+      ##
+      ## @return     [Boolean] Result of condition evaluation
+      ##
+      def evaluate(condition, context = {})
+        condition = condition.strip
+
+        # Handle negation with 'not' or '!'
+        negated = false
+        if condition =~ /^(not\s+|!)/
+          negated = true
+          condition = condition.sub(/^(not\s+|!)/, '').strip
+        end
+
+        result = evaluate_condition(condition, context)
+        negated ? !result : result
+      end
+
+      private
+
+      ##
+      ## Evaluate a single condition (without negation)
+      ##
+      def evaluate_condition(condition, context)
+        # Handle special conditions FIRST to avoid false matches with comparison patterns
+        # Check file contents before other patterns since it has arguments and operators
+        if condition =~ /^file\s+contents\s+(.+?)\s+(\*\*=|\*=|\^=|\$=|==|!=|=~)\s*(.+)$/i
+          return evaluate_file_contents(condition, context)
+        # Check file/dir/topic exists before other patterns since they have arguments
+        elsif condition =~ /^(file\s+exists|dir\s+exists|topic\s+exists)\s+(.+)$/i
+          return evaluate_special(condition, context)
+        elsif condition =~ /^(git\s+dirty|git\s+clean)$/i
+          return evaluate_special(condition, context)
+        end
+
+        # Handle =~ regex comparisons separately (before string == to avoid conflicts)
+        if (match = condition.match(%r{^(.+?)\s*=~\s*/(.+)/$}))
+          left = match[1].strip
+          pattern = match[2].strip
+
+          left_val = get_value(left, context)
+          return false if left_val.nil?
+
+          !!(left_val.to_s =~ /#{pattern}/)
+        # Handle comparisons with ==, !=, >, >=, <, <=
+        # Determine if numeric or string comparison based on values
+        elsif (match = condition.match(/^(.+?)\s*(==|!=|>=|<=|>|<)\s*(.+)$/))
+          left = match[1].strip
+          operator = match[2]
+          right = match[3].strip
+
+          left_val = get_value(left, context)
+          # If get_value returned nil, try using the original string as a literal
+          left_val = left if left_val.nil? && numeric_value(left)
+          right_val = get_value(right, context)
+          # If get_value returned nil, try using the original string as a literal
+          right_val = right if right_val.nil? && numeric_value(right)
+
+          # Try to convert to numbers
+          left_num = numeric_value(left_val)
+          right_num = numeric_value(right_val)
+
+          # If both are numeric, use numeric comparison
+          if left_num && right_num
+            case operator
+            when '=='
+              left_num == right_num
+            when '!='
+              left_num != right_num
+            when '>'
+              left_num > right_num
+            when '>='
+              left_num >= right_num
+            when '<'
+              left_num < right_num
+            when '<='
+              left_num <= right_num
+            else
+              false
+            end
+          # Otherwise use string comparison for == and !=, or return false for others
+          else
+            case operator
+            when '=='
+              # Handle nil comparisons
+              left_val.nil? == right_val.nil? && (left_val.nil? || left_val.to_s == right_val.to_s)
+            when '!='
+              left_val.nil? != right_val.nil? || (!left_val.nil? && !right_val.nil? && left_val.to_s != right_val.to_s)
+            else
+              # For >, >=, <, <=, return false if not numeric
+              false
+            end
+          end
+        # Handle string-only comparisons: **= (fuzzy match), *= (contains), ^= (starts with), $= (ends with)
+        # Note: **= must come before *= in the regex to avoid matching *= first
+        elsif (match = condition.match(/^(.+?)\s*(\*\*=|\*=|\^=|\$=)\s*(.+)$/))
+          left = match[1].strip
+          operator = match[2]
+          right = match[3].strip
+
+          left_val = get_value(left, context)
+          right_val = get_value(right, context)
+          # If right side is nil (variable not found), treat it as a literal string
+          right_val = right if right_val.nil?
+
+          return false if left_val.nil? || right_val.nil?
+
+          case operator
+          when '*='
+            left_val.to_s.include?(right_val.to_s)
+          when '^='
+            left_val.to_s.start_with?(right_val.to_s)
+          when '$='
+            left_val.to_s.end_with?(right_val.to_s)
+          when '**='
+            # Fuzzy match: split search string into chars and join with .*? for regex
+            pattern = "^.*?#{right_val.to_s.split('').map { |c| Regexp.escape(c) }.join('.*?')}.*?$"
+            !!(left_val.to_s =~ /#{pattern}/)
+          else
+            false
+          end
+        # Simple existence check (just a variable name)
+        else
+          val = get_value(condition, context)
+          !val.nil? && val.to_s != ''
+        end
+      end
+
+      ##
+      ## Get value from various sources
+      ##
+      def get_value(expr, context)
+        expr = expr.strip
+
+        # Remove quotes if present
+        return Regexp.last_match(1) if expr =~ /^["'](.+)["']$/
+
+        # Remove ${} wrapper if present (for consistency with variable substitution syntax)
+        expr = Regexp.last_match(1) if expr =~ /^\$\{(.+)\}$/
+
+        # Check positional arguments
+        if expr =~ /^\$(\d+)$/
+          idx = Regexp.last_match(1).to_i - 1
+          return Howzit.arguments[idx] if Howzit.arguments && Howzit.arguments[idx]
+        end
+
+        # Check named arguments
+        return Howzit.named_arguments[expr.to_sym] if Howzit.named_arguments&.key?(expr.to_sym)
+        return Howzit.named_arguments[expr] if Howzit.named_arguments&.key?(expr)
+
+        # Check metadata (from context only, to avoid circular dependencies)
+        metadata = context[:metadata]
+        return metadata[expr] if metadata&.key?(expr)
+        return metadata[expr.downcase] if metadata&.key?(expr.downcase)
+
+        # Check environment variables
+        return ENV[expr] if ENV.key?(expr)
+        return ENV[expr.upcase] if ENV.key?(expr.upcase)
+
+        # Check for special values: cwd, working directory
+        return Dir.pwd if expr =~ /^(cwd|working\s+directory)$/i
+
+        # Return nil if nothing matched (variable is undefined)
+        nil
+      end
+
+      ##
+      ## Convert value to numeric if possible
+      ##
+      def numeric_value(val)
+        return val if val.is_a?(Numeric)
+
+        str = val.to_s.strip
+        return nil if str.empty?
+
+        # Try integer first
+        return str.to_i if str =~ /^-?\d+$/
+
+        # Try float
+        return str.to_f if str =~ /^-?\d+\.\d+$/
+
+        nil
+      end
+
+      ##
+      ## Evaluate special conditions
+      ##
+      def evaluate_special(condition, context)
+        condition = condition.downcase.strip
+
+        if condition =~ /^git\s+dirty$/i
+          git_dirty?
+        elsif condition =~ /^git\s+clean$/i
+          !git_dirty?
+        elsif (match = condition.match(/^file\s+exists\s+(.+)$/i))
+          file = match[1].strip
+          # get_value returns nil if not found, so use original path if nil
+          file_val = get_value(file, context)
+          file_path = file_val.nil? ? file : file_val.to_s
+          File.exist?(file_path) && !File.directory?(file_path)
+        elsif (match = condition.match(/^dir\s+exists\s+(.+)$/i))
+          dir = match[1].strip
+          dir_val = get_value(dir, context)
+          dir_path = dir_val.nil? ? dir : dir_val.to_s
+          File.directory?(dir_path)
+        elsif (match = condition.match(/^topic\s+exists\s+(.+)$/i))
+          topic_name = match[1].strip
+          topic_name = get_value(topic_name, context).to_s
+          find_topic(topic_name)
+        else
+          false
+        end
+      end
+
+      ##
+      ## Check if git repository is dirty
+      ##
+      def git_dirty?
+        return false unless `which git`.strip != ''
+
+        Dir.chdir(Dir.pwd) do
+          `git diff --quiet 2>/dev/null`
+          $CHILD_STATUS.exitstatus != 0
+        end
+      end
+
+      ##
+      ## Check if topic exists in buildnote
+      ##
+      def find_topic(topic_name)
+        return false unless Howzit.buildnote
+
+        matches = Howzit.buildnote.find_topic(topic_name)
+        !matches.empty?
+      end
+
+      ##
+      ## Evaluate file contents condition
+      ## Reads file and performs string comparison
+      ##
+      def evaluate_file_contents(condition, context)
+        match = condition.match(/^file\s+contents\s+(.+?)\s+(\*\*=|\*=|\^=|\$=|==|!=|=~)\s*(.+)$/i)
+        return false unless match
+
+        file_path = match[1].strip
+        operator = match[2]
+        search_value = match[3].strip
+
+        # Resolve file path (could be a variable)
+        file_path_val = get_value(file_path, context)
+        file_path = file_path_val.nil? ? file_path : file_path_val.to_s
+
+        # Resolve search value (could be a variable)
+        search_val = get_value(search_value, context)
+        search_val = search_val.nil? ? search_value : search_val.to_s
+
+        # Read file contents
+        return false unless File.exist?(file_path) && !File.directory?(file_path)
+
+        begin
+          file_contents = File.read(file_path).strip
+        rescue StandardError
+          return false
+        end
+
+        # Perform comparison based on operator
+        case operator
+        when '=='
+          file_contents == search_val.to_s
+        when '!='
+          file_contents != search_val.to_s
+        when '*='
+          file_contents.include?(search_val.to_s)
+        when '^='
+          file_contents.start_with?(search_val.to_s)
+        when '$='
+          file_contents.end_with?(search_val.to_s)
+        when '**='
+          # Fuzzy match: split search string into chars and join with .*? for regex
+          pattern = "^.*?#{search_val.to_s.split('').map { |c| Regexp.escape(c) }.join('.*?')}.*?$"
+          !!(file_contents =~ /#{pattern}/)
+        when '=~'
+          # Regex match - search_value should be a regex pattern
+          pattern = search_val.to_s
+          # Remove leading/trailing slashes if present
+          pattern = pattern[1..-2] if pattern.start_with?('/') && pattern.end_with?('/')
+          !!(file_contents =~ /#{pattern}/)
+        else
+          false
+        end
+      end
+    end
+  end
+end