howzit 2.1.28 → 2.1.29

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
 

data/lib/howzit/console_logger.rb

@@ -39,7 +39,13 @@ 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
+
+      begin
+        $stderr.puts msg
+      rescue Errno::EPIPE
+        # Pipe closed, ignore
+      end
     end
 
     ##
@@ -66,7 +72,13 @@ module Howzit
     ## @param      msg   The message
     ##
     def warn(msg)
-      write msg, :warn
+      return unless LOG_LEVELS[:warn] >= @log_level
+
+      begin
+        $stderr.puts msg
+      rescue Errno::EPIPE
+        # Pipe closed, ignore
+      end
     end
 
     ##

data/lib/howzit/prompt.rb

@@ -100,9 +100,7 @@ module Howzit
           return fzf_result(res)
         end
 
-        if Util.command_exist?('gum')
-          return gum_choose(matches, query: query, multi: true)
-        end
+        return gum_choose(matches, query: query, multi: true) if Util.command_exist?('gum')
 
         tty_menu(matches, query: query)
       end
@@ -150,7 +148,11 @@ module Howzit
         end
 
         if query
-          puts "\nSelect a topic for `#{query}`:"
+          begin
+            puts "\nSelect a topic for `#{query}`:"
+          rescue Errno::EPIPE
+            # Pipe closed, ignore
+          end
         end
         options_list(matches)
         read_selection(matches)
@@ -168,7 +170,11 @@ module Howzit
 
           return [matches[line - 1]] if line.positive? && line <= matches.length
 
-          puts 'Out of range'
+          begin
+            puts 'Out of range'
+          rescue Errno::EPIPE
+            # Pipe closed, ignore
+          end
           read_selection(matches)
         end
       ensure
@@ -229,9 +235,7 @@ module Howzit
           return res.empty? ? [] : res.split(/\n/)
         end
 
-        if Util.command_exist?('gum')
-          return gum_choose(matches, prompt: prompt_text, multi: true, required: false)
-        end
+        return gum_choose(matches, prompt: prompt_text, multi: true, required: false) if Util.command_exist?('gum')
 
         text_template_input(matches)
       end
@@ -265,7 +269,11 @@ module Howzit
           exit
         end
 
-        puts "\n{bw}Available templates:{x} #{available.join(', ')}".c
+        begin
+          puts "\n{bw}Available templates:{x} #{available.join(', ')}".c
+        rescue Errno::EPIPE
+          # Pipe closed, ignore
+        end
         printf '{bw}Enter templates to include, comma-separated (return to skip):{x} '.c
         input = Readline.readline('', true).strip
 
@@ -321,7 +329,7 @@ module Howzit
       ## @return     [String] the entered value
       ##
       def get_line(prompt_text, default: nil)
-        return (default || '') unless $stdout.isatty
+        return default || '' unless $stdout.isatty
 
         if Util.command_exist?('gum')
           result = gum_input(prompt_text, placeholder: default || '')
@@ -346,7 +354,7 @@ module Howzit
       ##
       def gum_choose(matches, prompt: nil, multi: false, required: true, query: nil)
         prompt_text = prompt || (query ? "Select for '#{query}'" : 'Select')
-        args = ['gum', 'choose']
+        args = %w[gum choose]
         args << '--no-limit' if multi
         args << "--header=#{Shellwords.escape(prompt_text)}"
         args << '--cursor.foreground=6'
@@ -376,7 +384,7 @@ module Howzit
       ## @return     [String] The entered value
       ##
       def gum_input(prompt_text, placeholder: '')
-        args = ['gum', 'input']
+        args = %w[gum input]
         args << "--header=#{Shellwords.escape(prompt_text)}"
         args << "--placeholder=#{Shellwords.escape(placeholder)}" unless placeholder.empty?
         args << '--cursor.foreground=6'

data/lib/howzit/run_report.rb

@@ -57,7 +57,7 @@ module Howzit
 
       # Build the table with emoji header - center emoji in 6-char column
       header = "|  🚥  | #{'Task'.ljust(task_width)} |"
-      separator = "| :--: | #{':' + '-' * (task_width - 1)} |"
+      separator = "| :--: | #{":#{'-' * (task_width - 1)}"} |"
 
       table_lines = [header, separator]
       rows.each do |row|

data/lib/howzit/script_comm.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Howzit
+  # Script Communication module
+  # Handles communication from scripts to Howzit via a communication file
+  module ScriptComm
+    class << self
+      ##
+      ## Create a communication file for scripts to write to
+      ##
+      ## @return     [String] Path to the communication file
+      ##
+      def create_comm_file
+        file = Tempfile.new('howzit_comm')
+        file.close
+        file.path
+      end
+
+      ##
+      ## Set up the communication file and environment variable
+      ##
+      ## @return     [String] Path to the communication file
+      ##
+      def setup
+        comm_file = create_comm_file
+        ENV['HOWZIT_COMM_FILE'] = comm_file
+        comm_file
+      end
+
+      ##
+      ## Read and process the communication file after script execution
+      ##
+      ## @param      comm_file  [String] Path to the communication file
+      ##
+      ## @return     [Hash] Hash with :logs and :vars keys
+      ##
+      def process(comm_file)
+        return { logs: [], vars: {} } unless File.exist?(comm_file)
+
+        logs = []
+        vars = {}
+
+        begin
+          content = File.read(comm_file)
+          content.each_line do |line|
+            line = line.strip
+            next if line.empty?
+
+            case line
+            when /^LOG:(info|warn|error|debug):(.+)$/i
+              level = Regexp.last_match(1).downcase.to_sym
+              message = Regexp.last_match(2)
+              logs << { level: level, message: message }
+            when /^VAR:([A-Z0-9_]+)=(.*)$/i
+              key = Regexp.last_match(1)
+              value = Regexp.last_match(2)
+              vars[key] = value
+            end
+          end
+        rescue StandardError => e
+          Howzit.console&.warn("Error reading communication file: #{e.message}")
+        ensure
+          # Clean up the file
+          File.unlink(comm_file) if File.exist?(comm_file)
+        end
+
+        { logs: logs, vars: vars }
+      end
+
+      ##
+      ## Process communication and apply logs/variables
+      ##
+      ## @param      comm_file  [String] Path to the communication file
+      ##
+      def apply(comm_file)
+        result = process(comm_file)
+        return if result[:logs].empty? && result[:vars].empty?
+
+        # Apply log messages
+        result[:logs].each do |log_entry|
+          level = log_entry[:level]
+          message = log_entry[:message]
+          next unless Howzit.console
+
+          case level
+          when :info
+            Howzit.console.info(message)
+          when :warn
+            Howzit.console.warn(message)
+          when :error
+            Howzit.console.error(message)
+          when :debug
+            Howzit.console.debug(message)
+          end
+        end
+
+        # Apply variables to named_arguments
+        return if result[:vars].empty?
+
+        Howzit.named_arguments ||= {}
+        Howzit.named_arguments.merge!(result[:vars])
+      end
+    end
+  end
+end

data/lib/howzit/stringutils.rb

@@ -38,7 +38,7 @@ module Howzit
       position = 0
       in_order = 0
       chars.each do |char|
-        new_pos = self[position..-1] =~ /#{char}/i
+        new_pos = self[position..] =~ /#{char}/i
         if new_pos
           position += new_pos
           in_order += 1
@@ -72,7 +72,7 @@ module Howzit
     ##
     def distance(chars)
       distance = 0
-      max = self.length - chars.length
+      max = length - chars.length
       return max unless in_order(chars) == chars.length
 
       while distance < max
@@ -219,7 +219,7 @@ module Howzit
     def uncolor
       # force UTF-8 and remove invalid characters, then remove color codes
       # and iTerm markers
-      gsub(Howzit::Color::COLORED_REGEXP, "").gsub(/\e\]1337;SetMark/, "")
+      gsub(Howzit::Color::COLORED_REGEXP, '').gsub(/\e\]1337;SetMark/, '')
     end
 
     # Wrap text at a specified width.
@@ -371,7 +371,7 @@ module Howzit
       gsub!(/\$\{(?<name>[A-Z0-9_]+(?::.*?)?)\}/i) do
         m = Regexp.last_match
         arg, default = m['name'].split(/:/).map(&:strip)
-        if Howzit.named_arguments && Howzit.named_arguments.key?(arg) && !Howzit.named_arguments[arg].nil?
+        if Howzit.named_arguments&.key?(arg) && !Howzit.named_arguments[arg].nil?
           Howzit.named_arguments[arg]
         elsif default
           default