howzit 2.1.28 → 2.1.29

data/lib/howzit/task.rb

@@ -26,7 +26,7 @@ module Howzit
       @arguments = attributes[:arguments] || []
 
       @type = attributes[:type] || :run
-      @title = attributes[:title].nil? ? nil : attributes[:title].to_s
+      @title = attributes[:title]&.to_s
       @parent = attributes[:parent] || nil
 
       @action = attributes[:action].render_arguments || nil
@@ -61,6 +61,7 @@ module Howzit
       Howzit.console.info "#{@prefix}{bg}Running block {bw}#{@title}{x}".c if Howzit.options[:log_level] < 2
       block = @action
       script = Tempfile.new('howzit_script')
+      comm_file = ScriptComm.setup
       begin
         script.write(block)
         script.close
@@ -69,6 +70,8 @@ module Howzit
       ensure
         script.close
         script.unlink
+        # Process script communication
+        ScriptComm.apply(comm_file) if comm_file
       end
 
       update_last_status(res ? 0 : 1)
@@ -112,7 +115,13 @@ module Howzit
                       end
       Howzit.console.info("#{@prefix}{bg}Running {bw}#{display_title}{x}".c)
       ENV['HOWZIT_SCRIPTS'] = File.expand_path('~/.config/howzit/scripts')
-      res = system(@action)
+      comm_file = ScriptComm.setup
+      begin
+        res = system(@action)
+      ensure
+        # Process script communication
+        ScriptComm.apply(comm_file) if comm_file
+      end
       update_last_status(res ? 0 : 1)
       res
     end

data/lib/howzit/topic.rb

@@ -14,13 +14,15 @@ module Howzit
     ##
     ## @param      title    [String] The topic title
     ## @param      content  [String] The raw topic content
+    ## @param      metadata [Hash] Optional metadata hash
     ##
-    def initialize(title, content)
+    def initialize(title, content, metadata = nil)
       @title = title
       @content = content
       @parent = nil
       @nest_level = 0
       @named_args = {}
+      @metadata = metadata
       arguments
 
       @tasks = gather_tasks
@@ -81,7 +83,11 @@ module Howzit
 
       if @tasks.count.positive?
         unless @prereqs.empty?
-          puts TTY::Box.frame("{by}#{@prereqs.join("\n\n").wrap(cols - 4)}{x}".c, width: cols)
+          begin
+            puts TTY::Box.frame("{by}#{@prereqs.join("\n\n").wrap(cols - 4)}{x}".c, width: cols)
+          rescue Errno::EPIPE
+            # Pipe closed, ignore
+          end
           res = Prompt.yn('Have the above prerequisites been met?', default: true)
           Process.exit 1 unless res
 
@@ -123,7 +129,13 @@ module Howzit
 
       output.push(@results[:message]) if Howzit.options[:log_level] < 2 && !nested && !Howzit.options[:run]
 
-      puts TTY::Box.frame("{bw}#{@postreqs.join("\n\n").wrap(cols - 4)}{x}".c, width: cols) unless @postreqs.empty?
+      unless @postreqs.empty?
+        begin
+          puts TTY::Box.frame("{bw}#{@postreqs.join("\n\n").wrap(cols - 4)}{x}".c, width: cols)
+        rescue Errno::EPIPE
+          # Pipe closed, ignore
+        end
+      end
 
       output
     end
@@ -254,14 +266,16 @@ module Howzit
         output.push(@title.format_header)
         output.push('')
       end
-      topic = @content.dup
+      # Process conditional blocks first
+      metadata = @metadata || Howzit.buildnote&.metadata
+      topic = ConditionalContent.process(@content.dup, { metadata: metadata })
       unless Howzit.options[:show_all_code]
         topic.gsub!(/(?mix)^(`{3,})run([?!]*)\s*
                     ([^\n]*)[\s\S]*?\n\1\s*$/, '@@@run\2 \3')
       end
       topic.split(/\n/).each do |l|
         case l
-        when /@(before|after|prereq|end)/
+        when /@(before|after|prereq|end|if|unless)/
           next
         when /@include(?<optional>[!?]{1,2})?\((?<action>[^)]+)\)/
           output.concat(process_include(Regexp.last_match.named_captures.symbolize_keys, opt))
@@ -300,7 +314,7 @@ module Howzit
       # Store the actual title (not overridden by show_all_code - that's only for display)
       task_args = { type: :include,
                     arguments: nil,
-                    title: title.dup,  # Make a copy to avoid reference issues
+                    title: title.dup, # Make a copy to avoid reference issues
                     action: obj,
                     parent: self }
       # Set named_arguments before processing titles for variable substitution
@@ -363,15 +377,21 @@ module Howzit
 
     def gather_tasks
       runnable = []
-      @prereqs = @content.scan(/(?<=@before\n).*?(?=\n@end)/im).map(&:strip)
-      @postreqs = @content.scan(/(?<=@after\n).*?(?=\n@end)/im).map(&:strip)
+      # Process conditional blocks first
+      # Set named_arguments before processing so conditions can access them
+      Howzit.named_arguments = @named_args
+      metadata = @metadata || Howzit.buildnote&.metadata
+      processed_content = ConditionalContent.process(@content, { metadata: metadata })
+
+      @prereqs = processed_content.scan(/(?<=@before\n).*?(?=\n@end)/im).map(&:strip)
+      @postreqs = processed_content.scan(/(?<=@after\n).*?(?=\n@end)/im).map(&:strip)
 
       rx = /(?mix)(?:
             @(?<cmd>include|run|copy|open|url)(?<optional>[!?]{1,2})?\((?<action>[^)]*?)\)(?<title>[^\n]+)?
             |(?<fence>`{3,})run(?<optional2>[!?]{1,2})?(?<title2>[^\n]+)?(?<block>.*?)\k<fence>
             )/
       matches = []
-      @content.scan(rx) { matches << Regexp.last_match }
+      processed_content.scan(rx) { matches << Regexp.last_match }
       matches.each do |m|
         c = m.named_captures.symbolize_keys
         Howzit.named_arguments = @named_args

data/lib/howzit/util.rb

@@ -118,7 +118,11 @@ module Howzit
       # Paginate the output
       def page(text)
         unless $stdout.isatty
-          puts text
+          begin
+            puts text
+          rescue Errno::EPIPE
+            # Pipe closed, ignore
+          end
           return
         end
 
@@ -181,7 +185,11 @@ module Howzit
         if options[:paginate] && Howzit.options[:paginate]
           page(output)
         else
-          puts output
+          begin
+            puts output
+          rescue Errno::EPIPE
+            # Pipe closed, ignore
+          end
         end
       end
 
@@ -219,7 +227,7 @@ module Howzit
       ##
       def os_paste
         os = RbConfig::CONFIG['target_os']
-        out = "{bg}Pasting from clipboard".c
+        out = '{bg}Pasting from clipboard'.c
         case os
         when /darwin.*/i
           Howzit.console.debug("#{out} (macOS){x}".c)

data/lib/howzit/version.rb

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

data/lib/howzit.rb

@@ -38,6 +38,9 @@ require_relative 'howzit/stringutils'
 
 require_relative 'howzit/console_logger'
 require_relative 'howzit/config'
+require_relative 'howzit/script_comm'
+require_relative 'howzit/condition_evaluator'
+require_relative 'howzit/conditional_content'
 require_relative 'howzit/task'
 require_relative 'howzit/topic'
 require_relative 'howzit/buildnote'

data/spec/condition_evaluator_spec.rb

@@ -0,0 +1,261 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Howzit::ConditionEvaluator do
+  describe '.evaluate' do
+    context 'with string comparisons' do
+      it 'evaluates == correctly' do
+        expect(described_class.evaluate('"test" == "test"', {})).to be true
+        expect(described_class.evaluate('"test" == "other"', {})).to be false
+      end
+
+      it 'evaluates =~ regex correctly' do
+        expect(described_class.evaluate('"test" =~ /es/', {})).to be true
+        expect(described_class.evaluate('"test" =~ /xyz/', {})).to be false
+      end
+
+      it 'evaluates *= (contains) correctly' do
+        expect(described_class.evaluate('"testing" *= "est"', {})).to be true
+        expect(described_class.evaluate('"testing" *= "xyz"', {})).to be false
+      end
+
+      it 'evaluates ^= (starts with) correctly' do
+        expect(described_class.evaluate('"testing" ^= "test"', {})).to be true
+        expect(described_class.evaluate('"testing" ^= "ing"', {})).to be false
+      end
+
+      it 'evaluates $= (ends with) correctly' do
+        expect(described_class.evaluate('"testing" $= "ing"', {})).to be true
+        expect(described_class.evaluate('"testing" $= "test"', {})).to be false
+      end
+
+      it 'evaluates **= (fuzzy match) correctly' do
+        expect(described_class.evaluate('"fluffy" **= "ffy"', {})).to be true
+        expect(described_class.evaluate('"fluffy" **= "fly"', {})).to be true
+        expect(described_class.evaluate('"fluffy" **= "fuf"', {})).to be true
+        expect(described_class.evaluate('"fluffy" **= "xyz"', {})).to be false
+        expect(described_class.evaluate('"fluffy" **= "fxy"', {})).to be false
+      end
+    end
+
+    context 'with numeric comparisons' do
+      it 'evaluates == correctly' do
+        expect(described_class.evaluate('5 == 5', {})).to be true
+        expect(described_class.evaluate('5 == 3', {})).to be false
+      end
+
+      it 'evaluates != correctly' do
+        expect(described_class.evaluate('5 != 3', {})).to be true
+        expect(described_class.evaluate('5 != 5', {})).to be false
+      end
+
+      it 'evaluates > correctly' do
+        expect(described_class.evaluate('5 > 3', {})).to be true
+        expect(described_class.evaluate('3 > 5', {})).to be false
+      end
+
+      it 'evaluates >= correctly' do
+        expect(described_class.evaluate('5 >= 5', {})).to be true
+        expect(described_class.evaluate('5 >= 3', {})).to be true
+        expect(described_class.evaluate('3 >= 5', {})).to be false
+      end
+
+      it 'evaluates < correctly' do
+        expect(described_class.evaluate('3 < 5', {})).to be true
+        expect(described_class.evaluate('5 < 3', {})).to be false
+      end
+
+      it 'evaluates <= correctly' do
+        expect(described_class.evaluate('3 <= 3', {})).to be true
+        expect(described_class.evaluate('3 <= 5', {})).to be true
+        expect(described_class.evaluate('5 <= 3', {})).to be false
+      end
+    end
+
+    context 'with negation' do
+      it 'handles not prefix' do
+        expect(described_class.evaluate('not "test" == "other"', {})).to be true
+        expect(described_class.evaluate('not "test" == "test"', {})).to be false
+      end
+
+      it 'handles ! prefix' do
+        expect(described_class.evaluate('! "test" == "other"', {})).to be true
+        expect(described_class.evaluate('! "test" == "test"', {})).to be false
+      end
+    end
+
+    context 'with positional arguments' do
+      before do
+        Howzit.arguments = %w[arg1 arg2 arg3]
+      end
+
+      after do
+        Howzit.arguments = nil
+      end
+
+      it 'evaluates $1, $2, etc.' do
+        expect(described_class.evaluate('$1 == "arg1"', {})).to be true
+        expect(described_class.evaluate('$2 == "arg2"', {})).to be true
+        expect(described_class.evaluate('$1 == "other"', {})).to be false
+      end
+    end
+
+    context 'with named arguments' do
+      before do
+        Howzit.named_arguments = { test: 'value', other: 'thing' }
+      end
+
+      after do
+        Howzit.named_arguments = nil
+      end
+
+      it 'evaluates named arguments' do
+        expect(described_class.evaluate('test == "value"', {})).to be true
+        expect(described_class.evaluate('other == "thing"', {})).to be true
+        expect(described_class.evaluate('test == "other"', {})).to be false
+      end
+
+      it 'evaluates named arguments with ${} syntax' do
+        Howzit.named_arguments = { var: 'val', env: 'production' }
+        expect(described_class.evaluate('${var} == "val"', {})).to be true
+        expect(described_class.evaluate('${env} == "production"', {})).to be true
+        expect(described_class.evaluate('${var} == "other"', {})).to be false
+      end
+    end
+
+    context 'with metadata' do
+      it 'evaluates metadata keys' do
+        context = { metadata: { 'key1' => 'value1', 'key2' => 'value2' } }
+        expect(described_class.evaluate('key1 == "value1"', context)).to be true
+        expect(described_class.evaluate('key2 == "value2"', context)).to be true
+        expect(described_class.evaluate('key1 == "other"', context)).to be false
+      end
+    end
+
+    context 'with environment variables' do
+      it 'evaluates environment variables' do
+        ENV['TEST_VAR'] = 'test_value'
+        expect(described_class.evaluate('TEST_VAR == "test_value"', {})).to be true
+        ENV.delete('TEST_VAR')
+      end
+    end
+
+    context 'with special conditions' do
+      it 'evaluates git dirty' do
+        # Just test that it doesn't crash
+        result = described_class.evaluate('git dirty', {})
+        expect([true, false]).to include(result)
+      end
+
+      it 'evaluates git clean' do
+        result = described_class.evaluate('git clean', {})
+        expect([true, false]).to include(result)
+      end
+
+      it 'evaluates file exists' do
+        expect(described_class.evaluate('file exists /dev/null', {})).to be true
+        expect(described_class.evaluate('file exists /nonexistent/file', {})).to be false
+      end
+
+      it 'evaluates dir exists' do
+        expect(described_class.evaluate('dir exists /tmp', {})).to be true
+        expect(described_class.evaluate('dir exists /nonexistent/dir', {})).to be false
+      end
+
+      it 'evaluates cwd' do
+        result = described_class.evaluate('cwd', {})
+        expect(result).to be true
+      end
+
+      it 'evaluates working directory' do
+        result = described_class.evaluate('working directory', {})
+        expect(result).to be true
+      end
+
+      it 'evaluates cwd with string comparisons' do
+        cwd = Dir.pwd
+        expect(described_class.evaluate("cwd == \"#{cwd}\"", {})).to be true
+        expect(described_class.evaluate("cwd =~ /#{Regexp.escape(File.basename(cwd))}/", {})).to be true
+        expect(described_class.evaluate("cwd *= \"#{File.basename(cwd)}\"", {})).to be true
+        expect(described_class.evaluate("cwd ^= \"#{cwd[0..10]}\"", {})).to be true
+        expect(described_class.evaluate("cwd $= \"#{cwd[-10..-1]}\"", {})).to be true
+      end
+    end
+
+    context 'with file contents conditions' do
+      let(:test_file) { 'test_version.txt' }
+
+      before do
+        File.write(test_file, '0.1.2')
+      end
+
+      after do
+        File.delete(test_file) if File.exist?(test_file)
+      end
+
+      it 'evaluates file contents ^= (starts with) correctly' do
+        expect(described_class.evaluate("file contents #{test_file} ^= 0.", {})).to be true
+        expect(described_class.evaluate("file contents #{test_file} ^= 1.", {})).to be false
+      end
+
+      it 'evaluates file contents *= (contains) correctly' do
+        expect(described_class.evaluate("file contents #{test_file} *= 1.2", {})).to be true
+        expect(described_class.evaluate("file contents #{test_file} *= 2.3", {})).to be false
+      end
+
+      it 'evaluates file contents $= (ends with) correctly' do
+        expect(described_class.evaluate("file contents #{test_file} $= .2", {})).to be true
+        expect(described_class.evaluate("file contents #{test_file} $= .3", {})).to be false
+      end
+
+      it 'evaluates file contents == correctly' do
+        expect(described_class.evaluate("file contents #{test_file} == 0.1.2", {})).to be true
+        expect(described_class.evaluate("file contents #{test_file} == 1.0.0", {})).to be false
+      end
+
+      it 'evaluates file contents != correctly' do
+        expect(described_class.evaluate("file contents #{test_file} != 1.0.0", {})).to be true
+        expect(described_class.evaluate("file contents #{test_file} != 0.1.2", {})).to be false
+      end
+
+      it 'evaluates file contents **= (fuzzy match) correctly' do
+        expect(described_class.evaluate("file contents #{test_file} **= 012", {})).to be true
+        expect(described_class.evaluate("file contents #{test_file} **= 021", {})).to be false
+      end
+
+      it 'evaluates file contents =~ (regex) correctly' do
+        expect(described_class.evaluate("file contents #{test_file} =~ /0\\.\\d+\\.\\d+/", {})).to be true
+        expect(described_class.evaluate("file contents #{test_file} =~ /1\\.\\d+\\.\\d+/", {})).to be false
+      end
+
+      it 'returns false for non-existent file' do
+        expect(described_class.evaluate('file contents nonexistent.txt ^= 0.', {})).to be false
+      end
+
+      it 'handles file path as variable' do
+        context = { metadata: { 'version_file' => test_file } }
+        expect(described_class.evaluate('file contents version_file ^= 0.', context)).to be true
+      end
+    end
+
+    context 'with simple existence checks' do
+      before do
+        Howzit.named_arguments = { defined_var: 'value' }
+      end
+
+      after do
+        Howzit.named_arguments = nil
+      end
+
+      it 'returns true for defined variables' do
+        expect(described_class.evaluate('defined_var', {})).to be true
+      end
+
+      it 'returns false for undefined variables' do
+        expect(described_class.evaluate('undefined_var', {})).to be false
+      end
+    end
+  end
+end
+

data/spec/conditional_blocks_integration_spec.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'Conditional Blocks Integration' do
+  before do
+    Howzit.options[:include_upstream] = false
+    Howzit.options[:default] = true
+    Howzit.options[:matching] = 'partial'
+    Howzit.options[:multiple_matches] = 'choose'
+  end
+
+  after do
+    FileUtils.rm_f('builda.md')
+  end
+
+  describe 'with conditional blocks in topics' do
+    it 'includes content when @if condition is true' do
+      note = <<~EONOTE
+        # Test
+
+        ## Test Topic
+
+        @if "test" == "test"
+        This should be included
+        @end
+      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]
+      expect(topic).not_to be_nil
+      output = topic.print_out
+      expect(output.join("\n")).to include('This should be included')
+      expect(output.join("\n")).not_to include('@if')
+      expect(output.join("\n")).not_to include('@end')
+    end
+
+    it 'excludes content when @if condition is false' do
+      note = <<~EONOTE
+        # Test
+
+        ## Test Topic
+
+        @if "test" == "other"
+        This should NOT be included
+        @end
+      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]
+      expect(topic).not_to be_nil
+      output = topic.print_out
+      expect(output.join("\n")).not_to include('This should NOT be included')
+    end
+
+    it 'includes tasks when condition is true' do
+      note = <<~EONOTE
+        # Test
+
+        ## Test Topic
+
+        @if 1 == 1
+        @run(echo "test") Test Command
+        @end
+      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]
+      expect(topic).not_to be_nil
+      expect(topic.tasks.count).to eq(1)
+      expect(topic.tasks[0].action).to include('echo "test"')
+    end
+
+    it 'excludes tasks when condition is false' do
+      note = <<~EONOTE
+        # Test
+
+        ## Test Topic
+
+        @if 1 == 2
+        @run(echo "hidden") Hidden Command
+        @end
+      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]
+      expect(topic).not_to be_nil
+      expect(topic.tasks.count).to eq(0)
+    end
+
+    it 'handles nested conditional blocks' do
+      note = <<~EONOTE
+        # Test
+
+        ## Test Topic
+
+        @if "outer" == "outer"
+        Outer content
+        @if "inner" == "inner"
+        Inner content
+        @end
+        More outer content
+        @end
+      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]
+      expect(topic).not_to be_nil
+      output = topic.print_out
+      expect(output.join("\n")).to include('Outer content')
+      expect(output.join("\n")).to include('Inner content')
+      expect(output.join("\n")).to include('More outer content')
+    end
+
+    it 'handles metadata in conditions' do
+      note = <<~EONOTE
+        env: production
+
+        # Test
+
+        ## Test Topic
+
+        @if env == "production"
+        Production content
+        @end
+      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]
+      expect(topic).not_to be_nil
+      output = topic.print_out
+      expect(output.join("\n")).to include('Production content')
+    end
+
+    it 'handles @unless blocks correctly' do
+      note = <<~EONOTE
+        # Test
+
+        ## Test Topic
+
+        @unless "test" == "other"
+        This should be included
+        @end
+
+        @unless "test" == "test"
+        This should NOT be included
+        @end
+      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]
+      expect(topic).not_to be_nil
+      output = topic.print_out
+      expect(output.join("\n")).to include('This should be included')
+      expect(output.join("\n")).not_to include('This should NOT be included')
+    end
+  end
+end
+