howzit 2.1.28 → 2.1.30

data/lib/howzit/directive.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require 'shellwords'
+
+module Howzit
+  # Directive class
+  # Represents a parsed directive from topic content (tasks, conditionals, etc.)
+  class Directive
+    attr_reader :type, :content, :condition, :directive_type, :optional, :default, :line_number, :conditional_path,
+                :log_level_value, :var_name, :var_value
+
+    ##
+    ## Initialize a Directive
+    ##
+    ## @param      type            [Symbol] :task, :if, :unless, :elsif, :else, :end, :log_level
+    ## @param      content         [String] The directive content (action, block, etc.)
+    ## @param      condition       [String, nil] Condition string for conditionals
+    ## @param      directive_type  [String, nil] 'if', 'unless', 'elsif', 'else' for conditionals
+    ## @param      optional        [Boolean] Whether task requires confirmation
+    ## @param      default         [Boolean] Default response for confirmation
+    ## @param      line_number     [Integer] Line number in original content
+    ## @param      conditional_path [Array] Array of conditional indices this directive is nested in
+    ## @param      log_level_value [String, nil] Log level value for @log_level directives
+    ## @param      var_name        [String, nil] Variable name for @set_var directives
+    ## @param      var_value       [String, nil] Variable value for @set_var directives
+    ##
+    def initialize(type:, content: nil, condition: nil, directive_type: nil, optional: false, default: true,
+                   line_number: nil, conditional_path: [], log_level_value: nil, var_name: nil, var_value: nil)
+      @type = type
+      @content = content
+      @condition = condition
+      @directive_type = directive_type
+      @optional = optional
+      @default = default
+      @line_number = line_number
+      @conditional_path = conditional_path || []
+      @log_level_value = log_level_value
+      @var_name = var_name
+      @var_value = var_value
+    end
+
+    ##
+    ## Is this a conditional directive?
+    ##
+    def conditional?
+      %i[if unless elsif else end].include?(@type)
+    end
+
+    ##
+    ## Is this a task directive?
+    ##
+    def task?
+      @type == :task
+    end
+
+    ##
+    ## Is this a log_level directive?
+    ##
+    def log_level?
+      @type == :log_level
+    end
+
+    ##
+    ## Is this a set_var directive?
+    ##
+    def set_var?
+      @type == :set_var
+    end
+
+    ##
+    ## Convert directive to a Task object (only works for task directives)
+    ##
+    ## @param      parent        [Topic] The parent topic
+    ## @param      current_log_level [String, nil] Current log level to apply to task
+    ##
+    ## @return     [Task] Task object
+    ##
+    def to_task(parent, current_log_level: nil)
+      return nil unless task?
+
+      task_data = @content.dup
+      task_type = task_data[:type]
+
+      # Apply current log level if set and task doesn't have its own
+      task_data[:log_level] = current_log_level if current_log_level && !task_data[:log_level]
+
+      # Set named_arguments before processing titles for variable substitution
+      Howzit.named_arguments = parent.named_args
+
+      case task_type
+      when :block
+        # Block tasks are already properly formatted
+        task_data[:parent] = parent
+        Howzit::Task.new(task_data, optional: @optional, default: @default)
+      when :run
+        # Run tasks need title rendering (similar to define_task_args)
+        title = task_data[:title]
+        title = title.render_arguments if title && !title.empty?
+        task_data[:title] = title
+        task_data[:parent] = parent
+        Howzit::Task.new(task_data, optional: @optional, default: @default)
+      when :copy
+        # Copy tasks need title rendering and action escaping
+        title = task_data[:title]
+        title = title.render_arguments if title && !title.empty?
+        task_data[:title] = title
+        task_data[:action] = Shellwords.escape(task_data[:action])
+        task_data[:parent] = parent
+        Howzit::Task.new(task_data, optional: @optional, default: @default)
+      when :open
+        # Open tasks need title rendering
+        title = task_data[:title]
+        title = title.render_arguments if title && !title.empty?
+        task_data[:title] = title
+        task_data[:parent] = parent
+        Howzit::Task.new(task_data, optional: @optional, default: @default)
+      when :include
+        # Include tasks need special handling (title processing, arguments, etc.)
+        title = task_data[:title]
+        if title =~ /\[(.*?)\] *$/
+          args = Regexp.last_match(1).split(/ *, */).map(&:render_arguments)
+          Howzit.arguments = args
+          parent.arguments
+          title.sub!(/ *\[.*?\] *$/, '')
+        end
+        title = title.render_arguments if title && !title.empty?
+        task_data[:title] = title
+        task_data[:parent] = parent
+        task_data[:arguments] = Howzit.named_arguments
+        Howzit::Task.new(task_data, optional: @optional, default: @default)
+      else
+        task_data[:parent] = parent
+        Howzit::Task.new(task_data, optional: @optional, default: @default)
+      end
+    end
+  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