howzit 2.1.35 → 2.1.39

data/lib/howzit/script_support.rb

@@ -267,11 +267,30 @@ module Howzit
 
           # Log functions
           log() {
+            local report_mode=false
+            # Check for -r or --report flag
+            if [ "$1" = "-r" ] || [ "$1" = "--report" ]; then
+              report_mode=true
+              shift
+            fi
             local level="$1"
             shift
             local message="$*"
-            if [ -n "$HOWZIT_COMM_FILE" ]; then
+
+            if [ "$report_mode" = true ] && [ -n "$HOWZIT_COMM_FILE" ]; then
+              # Report mode: write to communication file
               echo "LOG:$level:$message" >> "$HOWZIT_COMM_FILE"
+            else
+              # Immediate mode: output with colors
+              local color=""
+              local reset="\\033[0m"
+              case "$level" in
+                info)  color="\\033[36m" ;;  # cyan
+                warn)  color="\\033[33m" ;;  # yellow
+                error) color="\\033[31m" ;;  # red
+                debug) color="\\033[2m"  ;;  # dim
+              esac
+              echo -e "${color}${message}${reset}" >&2
             fi
           }
 
@@ -306,11 +325,34 @@ module Howzit
           # Howzit helper functions for fish
 
           function log -d "Log a message at the specified level"
+            set report_mode false
+            # Check for -r or --report flag
+            if test "$argv[1]" = "-r"; or test "$argv[1]" = "--report"
+              set report_mode true
+              set -e argv[1]
+            end
             set level $argv[1]
             set -e argv[1]
             set message (string join " " $argv)
-            if test -n "$HOWZIT_COMM_FILE"
+
+            if test "$report_mode" = true; and test -n "$HOWZIT_COMM_FILE"
+              # Report mode: write to communication file
               echo "LOG:$level:$message" >> "$HOWZIT_COMM_FILE"
+            else
+              # Immediate mode: output with colors
+              set color ""
+              set reset "\\033[0m"
+              switch "$level"
+                case info
+                  set color "\\033[36m"  # cyan
+                case warn
+                  set color "\\033[33m"  # yellow
+                case error
+                  set color "\\033[31m"  # red
+                case debug
+                  set color "\\033[2m"   # dim
+              end
+              echo -e "$color$message$reset" >&2
             end
           end
 
@@ -362,30 +404,43 @@ module Howzit
               end
 
               class Logger
-                def info(message)
-                  log(:info, message)
+                def info(message, report: false)
+                  log(:info, message, report: report)
                 end
 
-                def warn(message)
-                  log(:warn, message)
+                def warn(message, report: false)
+                  log(:warn, message, report: report)
                 end
 
-                def error(message)
-                  log(:error, message)
+                def error(message, report: false)
+                  log(:error, message, report: report)
                 end
 
-                def debug(message)
-                  log(:debug, message)
+                def debug(message, report: false)
+                  log(:debug, message, report: report)
                 end
 
                 private
 
-                def log(level, message)
-                  comm_file = ENV['HOWZIT_COMM_FILE']
-                  return unless comm_file
+                def log(level, message, report: false)
+                  if report
+                    comm_file = ENV['HOWZIT_COMM_FILE']
+                    return unless comm_file
 
-                  File.open(comm_file, 'a') do |f|
-                    f.puts "LOG:#{level}:#{message}"
+                    File.open(comm_file, 'a') do |f|
+                      f.puts "LOG:#{level}:#{message}"
+                    end
+                  else
+                    # Immediate mode: output with colors
+                    color = case level
+                            when :info then "\033[36m"  # cyan
+                            when :warn then "\033[33m"  # yellow
+                            when :error then "\033[31m" # red
+                            when :debug then "\033[2m"   # dim
+                            else ""
+                            end
+                    reset = "\033[0m"
+                    $stderr.puts "#{color}#{message}#{reset}"
                   end
                 end
               end
@@ -419,25 +474,39 @@ module Howzit
           # Howzit helper module for Python
 
           import os
+          import sys
 
           class _Logger:
-              def _log(self, level, message):
-                  comm_file = os.environ.get('HOWZIT_COMM_FILE')
-                  if comm_file:
-                      with open(comm_file, 'a') as f:
-                          f.write(f"LOG:{level}:{message}\\n")
-
-              def info(self, message):
-                  self._log('info', message)
-
-              def warn(self, message):
-                  self._log('warn', message)
-
-              def error(self, message):
-                  self._log('error', message)
-
-              def debug(self, message):
-                  self._log('debug', message)
+              def _log(self, level, message, report=False):
+                  if report:
+                      comm_file = os.environ.get('HOWZIT_COMM_FILE')
+                      if comm_file:
+                          with open(comm_file, 'a') as f:
+                              f.write(f"LOG:{level}:{message}\\n")
+                  else:
+                      # Immediate mode: output with colors
+                      colors = {
+                          'info': '\\033[36m',   # cyan
+                          'warn': '\\033[33m',   # yellow
+                          'error': '\\033[31m',  # red
+                          'debug': '\\033[2m'    # dim
+                      }
+                      reset = '\\033[0m'
+                      color = colors.get(level, '')
+                      sys.stderr.write(f"{color}{message}{reset}\\n")
+                      sys.stderr.flush()
+
+              def info(self, message, report=False):
+                  self._log('info', message, report=report)
+
+              def warn(self, message, report=False):
+                  self._log('warn', message, report=report)
+
+              def error(self, message, report=False):
+                  self._log('error', message, report=report)
+
+              def debug(self, message, report=False):
+                  self._log('debug', message, report=report)
 
           class Howzit:
               logger = _Logger()
@@ -471,13 +540,33 @@ module Howzit
           use warnings;
 
           sub log {
+            my $report = 0;
+            # Check for -r or --report flag
+            if (@_ > 0 && ($_[0] eq '-r' || $_[0] eq '--report')) {
+              $report = 1;
+              shift;
+            }
             my ($level, $message) = @_;
-            my $comm_file = $ENV{'HOWZIT_COMM_FILE'};
-            return unless $comm_file;
 
-            open(my $fh, '>>', $comm_file) or return;
-            print $fh "LOG:$level:$message\\n";
-            close($fh);
+            if ($report) {
+              my $comm_file = $ENV{'HOWZIT_COMM_FILE'};
+              return unless $comm_file;
+
+              open(my $fh, '>>', $comm_file) or return;
+              print $fh "LOG:$level:$message\\n";
+              close($fh);
+            } else {
+              # Immediate mode: output with colors
+              my %colors = (
+                'info'  => "\\033[36m",  # cyan
+                'warn'  => "\\033[33m",  # yellow
+                'error' => "\\033[31m",  # red
+                'debug' => "\\033[2m"    # dim
+              );
+              my $reset = "\\033[0m";
+              my $color = $colors{$level} || '';
+              print STDERR "$color$message$reset\\n";
+            }
           }
 
           sub log_info { log('info', $_[0]); }
@@ -516,27 +605,40 @@ module Howzit
           const path = require('path');
 
           class Logger {
-            _log(level, message) {
-              const commFile = process.env.HOWZIT_COMM_FILE;
-              if (commFile) {
-                fs.appendFileSync(commFile, `LOG:${level}:${message}\\n`);
+            _log(level, message, report = false) {
+              if (report) {
+                const commFile = process.env.HOWZIT_COMM_FILE;
+                if (commFile) {
+                  fs.appendFileSync(commFile, `LOG:${level}:${message}\\n`);
+                }
+              } else {
+                // Immediate mode: output with colors
+                const colors = {
+                  'info': '\\033[36m',   // cyan
+                  'warn': '\\033[33m',   // yellow
+                  'error': '\\033[31m',  // red
+                  'debug': '\\033[2m'     // dim
+                };
+                const reset = '\\033[0m';
+                const color = colors[level] || '';
+                process.stderr.write(`${color}${message}${reset}\\n`);
               }
             }
 
-            info(message) {
-              this._log('info', message);
+            info(message, report = false) {
+              this._log('info', message, report);
             }
 
-            warn(message) {
-              this._log('warn', message);
+            warn(message, report = false) {
+              this._log('warn', message, report);
             }
 
-            error(message) {
-              this._log('error', message);
+            error(message, report = false) {
+              this._log('error', message, report);
             }
 
-            debug(message) {
-              this._log('debug', message);
+            debug(message, report = false) {
+              this._log('debug', message, report);
             }
           }
 

data/lib/howzit/stringutils.rb

@@ -91,7 +91,26 @@ module Howzit
     def build_note?
       return false if downcase !~ /^(howzit[^.]*|build[^.]+)/
 
-      return false if Howzit.config.should_ignore(self)
+      # Avoid recursion: only check ignore patterns if config is fully initialized
+      # and we're not in the middle of loading ignore patterns or initializing
+      begin
+        # Check if config exists without triggering initialization
+        return true unless Howzit.instance_variable_defined?(:@config)
+
+        config = Howzit.instance_variable_get(:@config)
+        return true unless config
+
+        # Check if config is initializing or loading ignore patterns to prevent recursion
+        return true if config.instance_variable_defined?(:@initializing) && config.instance_variable_get(:@initializing)
+        if config.instance_variable_defined?(:@loading_ignore_patterns) && config.instance_variable_get(:@loading_ignore_patterns)
+          return true
+        end
+
+        return false if config.respond_to?(:should_ignore) && config.should_ignore(self)
+      rescue StandardError
+        # If config access fails for any reason, skip the ignore check
+        # This prevents recursion and handles initialization edge cases
+      end
 
       true
     end

data/lib/howzit/task.rb

@@ -5,7 +5,7 @@ require 'English'
 module Howzit
   # Task object
   class Task
-    attr_reader :type, :title, :action, :arguments, :parent, :optional, :default, :last_status, :log_level
+    attr_reader :type, :title, :action, :arguments, :parent, :optional, :default, :last_status, :log_level, :source_file
 
     ##
     ## Initialize a Task object
@@ -21,6 +21,7 @@ module Howzit
     ## @option attributes :action [String] task action
     ## @option attributes :parent [String] title of nested (included) topic origin
     ## @option attributes :log_level [String] log level for this task (debug, info, warn, error)
+    ## @option attributes :source_file [String] path to the build note file this task came from
     def initialize(attributes, optional: false, default: true)
       @prefix = "{bw}\u{25B7}\u{25B7} {x}"
       # arrow = "{bw}\u{279F}{x}"
@@ -32,6 +33,9 @@ module Howzit
 
       @action = attributes[:action].render_arguments || nil
       @log_level = attributes[:log_level]
+      # Get source_file from parent topic if available, or from attributes
+      parent_obj = attributes[:parent]
+      @source_file = attributes[:source_file] || parent_obj&.source_file
 
       @optional = optional
       @default = default
@@ -68,7 +72,35 @@ module Howzit
       script = Tempfile.new('howzit_script')
       comm_file = ScriptComm.setup
       old_log_level = apply_log_level
+
+      # Get execution directory from source_file
+      # Only change directory in stack mode, and only if source_file is from a parent directory (not a template)
+      exec_dir = nil
+      if @source_file && Howzit.options[:stack]
+        expanded_source = File.expand_path(@source_file)
+        source_dir = File.dirname(expanded_source)
+
+        # Check if this is a template file - don't change directory for templates
+        is_template = false
+        if Howzit.config.respond_to?(:template_folder) && Howzit.config.template_folder
+          template_folder = File.expand_path(Howzit.config.template_folder)
+          is_template = expanded_source.start_with?(template_folder)
+        end
+
+        # Only change directory if not a template
+        exec_dir = source_dir unless is_template
+      end
+      original_dir = Dir.pwd
+
       begin
+        # Change to source file directory if available and different from current
+        # Only change if the directory exists and is actually different
+        if exec_dir && Dir.exist?(exec_dir)
+          expanded_exec_dir = File.expand_path(exec_dir)
+          expanded_original = File.expand_path(original_dir)
+          Dir.chdir(expanded_exec_dir) if expanded_exec_dir != expanded_original
+        end
+
         # Ensure support directory exists and install helpers
         ScriptSupport.ensure_support_dir
         ENV['HOWZIT_SUPPORT_DIR'] = ScriptSupport.support_dir
@@ -89,6 +121,12 @@ module Howzit
                 system(cmd)
               end
       ensure
+        # Restore original directory
+        if exec_dir && Dir.exist?(exec_dir)
+          expanded_exec_dir = File.expand_path(exec_dir)
+          expanded_original = File.expand_path(original_dir)
+          Dir.chdir(expanded_original) if expanded_exec_dir != expanded_original
+        end
         restore_log_level(old_log_level) if old_log_level
         script.close
         script.unlink
@@ -171,9 +209,43 @@ module Howzit
       ENV['HOWZIT_SCRIPTS'] = File.expand_path('~/.config/howzit/scripts')
       comm_file = ScriptComm.setup
       old_log_level = apply_log_level
+
+      # Get execution directory from source_file
+      # Only change directory in stack mode, and only if source_file is from a parent directory (not a template)
+      exec_dir = nil
+      if @source_file && Howzit.options[:stack]
+        expanded_source = File.expand_path(@source_file)
+        source_dir = File.dirname(expanded_source)
+
+        # Check if this is a template file - don't change directory for templates
+        is_template = false
+        if Howzit.config.respond_to?(:template_folder) && Howzit.config.template_folder
+          template_folder = File.expand_path(Howzit.config.template_folder)
+          is_template = expanded_source.start_with?(template_folder)
+        end
+
+        # Only change directory if not a template
+        exec_dir = source_dir unless is_template
+      end
+      original_dir = Dir.pwd
+
       begin
+        # Change to source file directory if available and different from current
+        # Only change if the directory exists and is actually different
+        if exec_dir && Dir.exist?(exec_dir)
+          expanded_exec_dir = File.expand_path(exec_dir)
+          expanded_original = File.expand_path(original_dir)
+          Dir.chdir(expanded_exec_dir) if expanded_exec_dir != expanded_original
+        end
+
         res = system(@action)
       ensure
+        # Restore original directory
+        if exec_dir && Dir.exist?(exec_dir)
+          expanded_exec_dir = File.expand_path(exec_dir)
+          expanded_original = File.expand_path(original_dir)
+          Dir.chdir(expanded_original) if expanded_exec_dir != expanded_original
+        end
         restore_log_level(old_log_level) if old_log_level
         # Process script communication
         ScriptComm.apply(comm_file) if comm_file
@@ -245,7 +317,13 @@ module Howzit
     ## @return     [String] List representation of the object.
     ##
     def to_list
-      "    * #{@type}: #{@title.preserve_escapes}"
+      # Highlight variables in title if parent topic has the method
+      display_title = if @parent.respond_to?(:highlight_variables)
+                        @parent.highlight_variables(@title.preserve_escapes)
+                      else
+                        @title.preserve_escapes
+                      end
+      "    * #{@type}: #{display_title}"
     end
   end
 end

data/lib/howzit/topic.rb

@@ -7,22 +7,24 @@ module Howzit
 
     attr_accessor :content
 
-    attr_reader :title, :tasks, :prereqs, :postreqs, :results, :named_args, :directives, :arg_definitions
+    attr_reader :title, :tasks, :prereqs, :postreqs, :results, :named_args, :directives, :arg_definitions, :source_file
 
     ##
     ## Initialize a topic object
     ##
-    ## @param      title    [String] The topic title
-    ## @param      content  [String] The raw topic content
-    ## @param      metadata [Hash] Optional metadata hash
+    ## @param      title       [String] The topic title
+    ## @param      content     [String] The raw topic content
+    ## @param      metadata    [Hash] Optional metadata hash
+    ## @param      source_file [String] Optional path to the build note file this topic came from
     ##
-    def initialize(title, content, metadata = nil)
+    def initialize(title, content, metadata = nil, source_file: nil)
       @title = title
       @content = content
       @parent = nil
       @nest_level = 0
       @named_args = {}
       @metadata = metadata
+      @source_file = source_file
       arguments
 
       @directives = parse_directives_with_conditionals

data/lib/howzit/version.rb

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

data/lib/howzit.rb

@@ -89,7 +89,13 @@ module Howzit
     ## Module storage for buildnote
     ##
     def buildnote(file = nil)
-      @buildnote ||= BuildNote.new(file: file)
+      # If a specific file is requested, always create a new instance
+      # Otherwise, use cached instance if available
+      if file
+        BuildNote.new(file: file)
+      else
+        @buildnote ||= BuildNote.new(file: file)
+      end
     end
 
     ##

data/spec/cli_spec.rb

@@ -6,20 +6,32 @@ require 'spec_helper'
 describe 'CLI' do
   include CliTest
 
+  before do
+    # Temporarily rename buildnotes.md so builda.md is selected
+    @original_buildnotes = 'buildnotes.md'
+    @backup_buildnotes = 'buildnotes.md.backup'
+    FileUtils.mv(@original_buildnotes, @backup_buildnotes) if File.exist?(@original_buildnotes)
+  end
+
+  after do
+    # Restore buildnotes.md
+    FileUtils.mv(@backup_buildnotes, @original_buildnotes) if File.exist?(@backup_buildnotes)
+  end
+
   it 'executes successfully' do
     execute_script('bin/howzit', use_bundler: true)
     expect(last_execution).to be_successful
   end
 
   it 'lists available topics' do
-    execute_script('bin/howzit', use_bundler: true, args: %w[-L])
+    execute_script('bin/howzit', use_bundler: true, args: %w[--no-stack -L])
     expect(last_execution).to be_successful
     expect(last_execution.stdout).to match(/Topic Balogna/)
     expect(last_execution.stdout.split(/\n/).count).to eq 7
   end
 
   it 'lists available tasks' do
-    execute_script('bin/howzit', use_bundler: true, args: %w[-T])
+    execute_script('bin/howzit', use_bundler: true, args: %w[--no-stack -T])
     expect(last_execution).to be_successful
     expect(last_execution.stdout).to match(/Topic Balogna/)
     expect(last_execution.stdout.split(/\n/).count).to eq 2

data/spec/conditional_blocks_integration_spec.rb

@@ -5,6 +5,7 @@ require 'spec_helper'
 describe 'Conditional Blocks Integration' do
   before do
     Howzit.options[:include_upstream] = false
+    Howzit.options[:stack] = false
     Howzit.options[:default] = true
     Howzit.options[:matching] = 'partial'
     Howzit.options[:multiple_matches] = 'choose'
@@ -27,7 +28,7 @@ describe 'Conditional Blocks Integration' do
       EONOTE
       File.open('builda.md', 'w') { |f| f.puts note }
       Howzit.instance_variable_set(:@buildnote, nil) # Force reload
-      topic = Howzit.buildnote.find_topic('Test Topic')[0]
+      topic = Howzit.buildnote('builda.md').find_topic('Test Topic')[0]
       expect(topic).not_to be_nil
       output = topic.print_out
       expect(output.join("\n")).to include('This should be included')
@@ -47,7 +48,7 @@ describe 'Conditional Blocks Integration' do
       EONOTE
       File.open('builda.md', 'w') { |f| f.puts note }
       Howzit.instance_variable_set(:@buildnote, nil) # Force reload
-      topic = Howzit.buildnote.find_topic('Test Topic')[0]
+      topic = Howzit.buildnote('builda.md').find_topic('Test Topic')[0]
       expect(topic).not_to be_nil
       output = topic.print_out
       expect(output.join("\n")).not_to include('This should NOT be included')
@@ -65,7 +66,7 @@ describe 'Conditional Blocks Integration' do
       EONOTE
       File.open('builda.md', 'w') { |f| f.puts note }
       Howzit.instance_variable_set(:@buildnote, nil) # Force reload
-      topic = Howzit.buildnote.find_topic('Test Topic')[0]
+      topic = Howzit.buildnote('builda.md').find_topic('Test Topic')[0]
       expect(topic).not_to be_nil
       expect(topic.tasks.count).to eq(1)
       expect(topic.tasks[0].action).to include('echo "test"')
@@ -83,7 +84,7 @@ describe 'Conditional Blocks Integration' do
       EONOTE
       File.open('builda.md', 'w') { |f| f.puts note }
       Howzit.instance_variable_set(:@buildnote, nil) # Force reload
-      topic = Howzit.buildnote.find_topic('Test Topic')[0]
+      topic = Howzit.buildnote('builda.md').find_topic('Test Topic')[0]
       expect(topic).not_to be_nil
       expect(topic.tasks.count).to eq(0)
     end
@@ -104,7 +105,7 @@ describe 'Conditional Blocks Integration' do
       EONOTE
       File.open('builda.md', 'w') { |f| f.puts note }
       Howzit.instance_variable_set(:@buildnote, nil) # Force reload
-      topic = Howzit.buildnote.find_topic('Test Topic')[0]
+      topic = Howzit.buildnote('builda.md').find_topic('Test Topic')[0]
       expect(topic).not_to be_nil
       output = topic.print_out
       expect(output.join("\n")).to include('Outer content')
@@ -126,7 +127,7 @@ describe 'Conditional Blocks Integration' do
       EONOTE
       File.open('builda.md', 'w') { |f| f.puts note }
       Howzit.instance_variable_set(:@buildnote, nil) # Force reload
-      topic = Howzit.buildnote.find_topic('Test Topic')[0]
+      topic = Howzit.buildnote('builda.md').find_topic('Test Topic')[0]
       expect(topic).not_to be_nil
       output = topic.print_out
       expect(output.join("\n")).to include('Production content')
@@ -148,7 +149,7 @@ describe 'Conditional Blocks Integration' do
       EONOTE
       File.open('builda.md', 'w') { |f| f.puts note }
       Howzit.instance_variable_set(:@buildnote, nil) # Force reload
-      topic = Howzit.buildnote.find_topic('Test Topic')[0]
+      topic = Howzit.buildnote('builda.md').find_topic('Test Topic')[0]
       expect(topic).not_to be_nil
       output = topic.print_out
       expect(output.join("\n")).to include('This should be included')