howzit 2.1.28 → 2.1.30

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

data/lib/howzit/conditional_content.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Howzit
+  # Conditional Content processor
+  # Handles @if/@unless/@end blocks in topic content
+  module ConditionalContent
+    class << self
+      ##
+      ## Process conditional blocks in content
+      ##
+      ## @param      content  [String] The content to process
+      ## @param      context  [Hash] Context for condition evaluation
+      ##
+      ## @return     [String] Content with conditional blocks processed
+      ##
+      def process(content, context = {})
+        lines = content.split(/\n/)
+        output = []
+        condition_stack = []
+        # Track if any condition in the current chain has been true
+        # This is used for @elsif and @else to know if a previous branch matched
+        chain_matched_stack = []
+
+        lines.each do |line|
+          # Check for @if or @unless
+          if line =~ /^@(if|unless)\s+(.+)$/i
+            directive = Regexp.last_match(1).downcase
+            condition = Regexp.last_match(2).strip
+
+            # Evaluate condition
+            result = ConditionEvaluator.evaluate(condition, context)
+            # For @unless, negate the result
+            result = !result if directive == 'unless'
+
+            condition_stack << result
+            chain_matched_stack << result
+
+            # Don't include the @if/@unless line itself
+            next
+          end
+
+          # Check for @elsif
+          if line =~ /^@elsif\s+(.+)$/i
+            condition = Regexp.last_match(1).strip
+
+            # If previous condition in chain was true, this branch is false
+            # Otherwise, evaluate the condition
+            if !condition_stack.empty? && chain_matched_stack.last
+              # Previous branch matched, so this one is false
+              condition_stack[-1] = false
+            else
+              # Previous branch didn't match, evaluate this condition
+              result = ConditionEvaluator.evaluate(condition, context)
+              condition_stack[-1] = result
+              chain_matched_stack[-1] = result if result
+            end
+
+            # Don't include the @elsif line itself
+            next
+          end
+
+          # Check for @else
+          if line =~ /^@else\s*$/i
+            # If any previous condition in chain was true, this branch is false
+            # Otherwise, this branch is true
+            if !condition_stack.empty? && chain_matched_stack.last
+              # Previous branch matched, so else is false
+              condition_stack[-1] = false
+            else
+              # No previous branch matched, so else is true
+              condition_stack[-1] = true
+              chain_matched_stack[-1] = true
+            end
+
+            # Don't include the @else line itself
+            next
+          end
+
+          # Check for @end - only skip if it's closing an @if/@unless/@elsif/@else block
+          if (line =~ /^@end\s*$/) && !condition_stack.empty?
+            # This @end closes a conditional block, so skip it
+            condition_stack.pop
+            chain_matched_stack.pop
+            next
+          end
+          # Otherwise, this @end is for @before/@after, so include it
+
+          # Include the line only if all conditions in stack are true
+          output << line if condition_stack.all? { |cond| cond }
+        end
+
+        output.join("\n")
+      end
+    end
+  end
+end

data/lib/howzit/config.rb

@@ -129,14 +129,26 @@ module Howzit
 
     ## Update editor config
     def update_editor
-      puts 'No $EDITOR defined, no value in config'
+      begin
+        puts 'No $EDITOR defined, no value in config'
+      rescue Errno::EPIPE
+        # Pipe closed, ignore
+      end
       editor = Prompt.read_editor
       if editor.nil?
-        puts 'Cancelled, no editor stored.'
+        begin
+          puts 'Cancelled, no editor stored.'
+        rescue Errno::EPIPE
+          # Pipe closed, ignore
+        end
         Process.exit 1
       end
       update_config_option({ config_editor: editor, editor: editor })
-      puts "Default editor set to #{editor}, modify in config file"
+      begin
+        puts "Default editor set to #{editor}, modify in config file"
+      rescue Errno::EPIPE
+        # Pipe closed, ignore
+      end
       editor
     end
 
@@ -182,6 +194,19 @@ module Howzit
       config = load_config
       load_theme
       @options = flags.merge(config)
+
+      # Check for HOWZIT_LOG_LEVEL environment variable
+      return unless ENV['HOWZIT_LOG_LEVEL']
+
+      level_str = ENV['HOWZIT_LOG_LEVEL'].downcase
+      level_map = {
+        'debug' => 0,
+        'info' => 1,
+        'warn' => 2,
+        'warning' => 2,
+        'error' => 3
+      }
+      @options[:log_level] = level_map[level_str] || level_str.to_i
     end
 
     ##

data/lib/howzit/console_logger.rb

@@ -31,6 +31,50 @@ module Howzit
       @log_level = Howzit.options[:log_level]
     end
 
+    ##
+    ## Get emoji for log level
+    ##
+    ## @param      level  [Symbol] The level
+    ##
+    ## @return     [String] Emoji for the level
+    ##
+    def emoji_for_level(level)
+      case level
+      when :debug
+        '🔍'
+      when :info
+        'ℹ️'
+      when :warn
+        '⚠️'
+      when :error
+        '❌'
+      else
+        ''
+      end
+    end
+
+    ##
+    ## Get color prefix for log level
+    ##
+    ## @param      level  [Symbol] The level
+    ##
+    ## @return     [String] Color template string
+    ##
+    def color_for_level(level)
+      case level
+      when :debug
+        '{d}'
+      when :info
+        '{c}'
+      when :warn
+        '{y}'
+      when :error
+        '{r}'
+      else
+        ''
+      end
+    end
+
     ##
     ## Write a message to the console based on the urgency
     ## level and user's log level setting
@@ -39,7 +83,21 @@ module Howzit
     ## @param      level  [Symbol] The level
     ##
     def write(msg, level = :info)
-      $stderr.puts msg if LOG_LEVELS[level] >= @log_level
+      return unless LOG_LEVELS[level] >= @log_level
+
+      emoji = emoji_for_level(level)
+      color = color_for_level(level)
+      formatted_msg = if emoji && color
+                        "#{emoji} #{color}#{msg}{x}".c
+                      else
+                        msg
+                      end
+
+      begin
+        $stderr.puts formatted_msg
+      rescue Errno::EPIPE
+        # Pipe closed, ignore
+      end
     end
 
     ##
@@ -66,7 +124,21 @@ module Howzit
     ## @param      msg   The message
     ##
     def warn(msg)
-      write msg, :warn
+      return unless LOG_LEVELS[:warn] >= @log_level
+
+      emoji = emoji_for_level(:warn)
+      color = color_for_level(:warn)
+      formatted_msg = if emoji && color
+                        "#{emoji} #{color}#{msg}{x}".c
+                      else
+                        msg
+                      end
+
+      begin
+        $stderr.puts formatted_msg
+      rescue Errno::EPIPE
+        # Pipe closed, ignore
+      end
     end
 
     ##