markdown_exec 3.3.0 → 3.5.0

data/lib/resize_terminal.rb

@@ -5,15 +5,16 @@
 require 'io/console'
 require 'timeout'
 require_relative 'env_interface'
+require_relative 'ww'
 
 # This function attempts to resize the terminal to its maximum supported size.
 # It checks if the script is running in an interactive terminal with no arguments.
 # If so, it sends escape sequences to query the terminal size and reads the response.
 # It then compares the current terminal size with the calculated size and adjusts if necessary.
 # If the terminal emulator is unsupported, it prints an error message.
-# 2024-8-23 add require_stdout to allow for testing
+# 2024-08-23 add require_stdout to allow for testing
 def resize_terminal(show_dims: false, show_rectangle: false,
-                    require_stdout: true)
+                    require_stdout: true, debug: $debug)
   # Check if running in an interactive terminal and no arguments are provided
   unless $stdin.tty?
     warn 'Usage: resize_terminal'
@@ -37,14 +38,14 @@ def resize_terminal(show_dims: false, show_rectangle: false,
   end
 
   if response.empty?
-    warn "Error: No response received from terminal. Response: #{response.inspect}"
+    wwe "Error: No response received from terminal. Response: #{response.inspect}" if debug
     return 1
   end
 
   # Match the response to extract the terminal dimensions
   match_data = response.match(/\[(\d+);(\d+)R/)
   unless match_data
-    warn "Error: Failed to match terminal response pattern. Response: #{response.inspect}"
+    wwe "Error: Failed to match terminal response pattern. Response: #{response.inspect}" if debug
     return 1
   end
 
@@ -60,7 +61,7 @@ def resize_terminal(show_dims: false, show_rectangle: false,
                                         nil)} -> #{calculated_columns}x#{calculated_rows}" if show_dims
     system("stty cols #{calculated_columns} rows #{calculated_rows}")
   else
-    warn "Error: Calculated terminal size is invalid. Columns: #{calculated_columns}, Rows: #{calculated_rows}"
+    wwe "Error: Calculated terminal size is invalid. Columns: #{calculated_columns}, Rows: #{calculated_rows}" if debug
     return 1
   end
 
@@ -68,10 +69,10 @@ def resize_terminal(show_dims: false, show_rectangle: false,
   display_terminal_rectangle(calculated_columns,
                              calculated_rows) if show_rectangle
 rescue Timeout::Error
-  warn 'Error: Timeout while reading terminal response. Unsupported terminal emulator.'
+  wwe 'Error: Timeout while reading terminal response. Unsupported terminal emulator.' if debug
   1
 rescue StandardError => err
-  warn "Error: #{err.message}. Unsupported terminal emulator."
+  wwe "Error: #{err.message}. Unsupported terminal emulator." if debug
   1
 ensure
   EnvInterface.set('COLUMNS', @original_columns)
@@ -141,11 +142,10 @@ class ResizeTerminalTest < Minitest::Test
     $stdin.stub(:tty?, true) do
       ARGV.replace([])
       $stdin.stub(:getch, -> { '' }) do
-        # assert_output(nil, /Error: No response received from terminal/) do
-        assert_output(nil,
-                      "Error: Timeout while reading terminal response. Unsupported terminal emulator.\n") do
-          assert_equal 1, resize_terminal(require_stdout: false)
+        error = assert_raises(StandardError) do
+          resize_terminal(require_stdout: false, debug: true)
         end
+        assert_equal 'Error: Timeout while reading terminal response. Unsupported terminal emulator.', error.message
       end
     end
   end
@@ -156,10 +156,11 @@ class ResizeTerminalTest < Minitest::Test
       ARGV.replace([])
       response = "\e[999;999H\e[6n\e[InvalidResponse".dup
       $stdin.stub(:getch, -> { response.slice!(0) || '' }) do
-        assert_output(nil,
-                      /Error: Failed to match terminal response pattern/) do
-          assert_equal 1, resize_terminal(require_stdout: false)
+        error = assert_raises(StandardError) do
+          resize_terminal(require_stdout: false, debug: true)
         end
+        assert_match /Error: Failed to match terminal response pattern/, error.message
+
       end
     end
   end
@@ -169,9 +170,11 @@ class ResizeTerminalTest < Minitest::Test
     $stdin.stub(:tty?, true) do
       ARGV.replace([])
       Timeout.stub(:timeout, ->(_) { raise Timeout::Error }) do
-        assert_output(nil, /Error: Timeout while reading terminal response/) do
-          assert_equal 1, resize_terminal(require_stdout: false)
+        error = assert_raises(StandardError) do
+          resize_terminal(require_stdout: false, debug: true)
         end
+        assert_match /Error: Timeout while reading terminal response/, error.message
+
       end
     end
   end

data/lib/ww.rb

@@ -1,3 +1,4 @@
+#!/usr/bin/env -S bundle exec ruby
 # frozen_string_literal: true
 
 # encoding=utf-8
@@ -12,16 +13,16 @@ DEPTH_ICON = '›'
 LOG_LEVELS = %i[debug info warn error fatal].freeze
 
 # is enabled
-def enable_debugging
+private def enable_debugging
   ENV.fetch('WW', '0').to_i.positive?
 end
 
 # is enabled, not silent
-def env_show_attribution
+private def env_show_attribution
   ENV['WW'] != '0'
 end
 
-def is_new_alg?
+private def is_new_alg?
   # use the new algo only if env var is ALG is not empty
   !ENV.fetch('ALG', '').empty?
 
@@ -84,6 +85,11 @@ def wwa(*objs, **kwargs)
   exit 1
 end
 
+# break into the debugger if enabled
+def wwb
+  binding.irb if $debug
+end
+
 # output the object and backtrace for the error
 # raise the error for the caller to handle
 def wwe(*objs, **kwargs)
@@ -136,9 +142,33 @@ def wwt(*objs, **kwargs)
       ))
 end
 
+# enhanced expression wrapper with better context
+# usage: wwx { some_expression } or wwx(expression)
+def wwx(expression = nil, **kwargs, &block)
+  if block_given?
+    # Block form: wwx { some_expression }
+    result = block.call
+    return result unless $debug
+
+    # Capture the source location of the block
+    locations = kwargs[:locations] || caller_locations
+    ww0(result, **kwargs.merge(locations: locations, context: 'block'))
+  elsif expression
+    # Direct form: wwx(some_expression)
+    return expression unless $debug
+
+    locations = kwargs[:locations] || caller_locations
+    ww0(expression, **kwargs.merge(locations: locations, context: 'direct'))
+  else
+    # No arguments - just return nil
+    nil
+  end
+end
+
 # output the formatted data and location
 def ww0(*objs,
         category: $ww_category,
+        context: nil,
         full_backtrace: false,
         level: :debug,
         locations: caller_locations,
@@ -172,12 +202,13 @@ def ww0(*objs,
   # Add optional timestamp
   time_prefix = timestamp ? "[#{Time.now.strftime('%Y-%m-%d %H:%M:%S')}] " : ''
 
-  # Add log level and category prefix
+  # Add log level, category, and context prefix
   level_prefix = "[#{level.to_s.upcase}]"
   category_prefix = category ? "[#{category}] " : ''
+  context_prefix = context ? "[#{context}] " : ''
 
   # Combine all parts into the final message
-  header = "#{time_prefix}#{level_prefix} #{category_prefix}"
+  header = "#{time_prefix}#{level_prefix} #{category_prefix}#{context_prefix}"
   trace = backtrace + objs
   io = StringIO.new
   formatted_message = if single_line
@@ -197,21 +228,16 @@ def ww0(*objs,
   output.flush
 
   # Optionally log to a file
-  return objs.size == 1 ? objs.first : objs unless log_file
-
-  File.open(log_file, 'a') do |file|
-    file.puts(formatted_message)
+  if log_file
+    File.open(log_file, 'a') do |file|
+      file.puts(formatted_message)
+    end
   end
 
-  # return the last item in the list, as the label is usually first
+  # Always return the last item in the list, as the label is usually first
   objs.last
 end
 
-# break into the debugger if enabled
-def wwb
-  binding.irb if $debug
-end
-
 class Array
   unless defined?(deref)
 
@@ -430,3 +456,455 @@ class Array
     []
   end
 end
+
+return if $PROGRAM_NAME != __FILE__
+
+require 'minitest/autorun'
+
+class TestWwFunction < Minitest::Test
+  def setup
+    # Save original global state
+    @original_debug = $debug
+    @original_ww_log_file = $ww_log_file
+    @original_ww_output = $ww_output
+    @original_ww_category = $ww_category
+
+    # Redirect output to capture it - ensure it's writable
+    @output_buffer = StringIO.new
+    @output_buffer.sync = true
+    $ww_output = @output_buffer
+    $ww_category = nil
+  end
+
+  def teardown
+    # Restore original global state
+    $debug = @original_debug
+    $ww_log_file = @original_ww_log_file
+    $ww_output = @original_ww_output
+    $ww_category = @original_ww_category
+
+    # Clean up any test log files
+    Dir.glob('test*.log').each { |f| FileUtils.rm_f(f) }
+  end
+
+  # Core functionality tests
+  def test_ww_returns_last_item_with_debug_disabled
+    $debug = false
+    $ww_log_file = nil
+
+    # Test with single item
+    result = ww('single_item')
+    assert_equal 'single_item', result,
+                 'ww should return the single item when debug is disabled'
+
+    # Test with multiple items
+    result = ww('first', 'second', 'third')
+    assert_equal 'third', result,
+                 'ww should return the last item when debug is disabled'
+
+    # Test with various data types
+    result = ww(1, 'string', :symbol, [1, 2, 3])
+    assert_equal [1, 2, 3], result,
+                 'ww should return the last item regardless of type'
+
+    # Verify no output when debug is disabled
+    assert_empty @output_buffer.string,
+                 'No output should be generated when debug is disabled'
+  end
+
+  def test_ww_returns_last_item_with_debug_enabled_no_log_file
+    $debug = true
+    $ww_log_file = nil
+
+    # Test with single item
+    result = ww('single_item')
+    assert_equal 'single_item', result,
+                 'ww should return the single item when debug is enabled and no log file'
+
+    # Test with multiple items
+    result = ww('first', 'second', 'third')
+    assert_equal 'third', result,
+                 'ww should return the last item when debug is enabled and no log file'
+
+    # Test with mixed types
+    result = ww(42, 'hello', :world, { key: 'value' })
+    assert_equal({ key: 'value' }, result,
+                 'ww should return the last item even with hash')
+
+    # Verify output is generated when debug is enabled
+    refute_empty @output_buffer.string,
+                 'Output should be generated when debug is enabled'
+  end
+
+  def test_ww_returns_last_item_with_debug_enabled_with_log_file
+    $debug = true
+    $ww_log_file = 'test_ww.log'
+
+    begin
+      # Test with single item
+      result = ww('single_item')
+      assert_equal 'single_item', result,
+                   'ww should return the single item when debug is enabled with log file'
+
+      # Test with multiple items
+      result = ww('first', 'second', 'third')
+      assert_equal 'third', result,
+                   'ww should return the last item when debug is enabled with log file'
+
+      # Test with various data types
+      result = ww(1, 'string', :symbol, [1, 2, 3])
+      assert_equal [1, 2, 3], result,
+                   'ww should return the last item regardless of type with log file'
+
+      # Verify log file was created and contains content
+      assert File.exist?('test_ww.log'), 'Log file should be created'
+      refute_empty File.read('test_ww.log'), 'Log file should contain content'
+    ensure
+      # Clean up test log file
+      FileUtils.rm_f('test_ww.log')
+    end
+  end
+
+  def test_ww_with_named_options
+    $debug = false
+
+    # Test that named options don't affect the return value
+    result = ww('first', 'second', category: 'test', level: :info)
+    assert_equal 'second', result,
+                 'ww should return the last item even with named options'
+
+    # Test with single item and options
+    result = ww('only_item', timestamp: true, single_line: true)
+    assert_equal 'only_item', result,
+                 'ww should return the single item even with named options'
+
+    # Test with various option combinations
+    result = ww('a', 'b', 'c', category: 'testing', level: :warn,
+                               timestamp: true, single_line: false)
+    assert_equal 'c', result,
+                 'ww should return the last item with complex options'
+  end
+
+  # Test all ww function variants
+  def test_wwr_function_returns_last_item
+    $debug = true
+    $ww_log_file = nil
+
+    # Test wwr with multiple items
+    result = wwr('first', 'second', 'third')
+    assert_equal 'third', result, 'wwr should return the last item'
+
+    # Test wwr with single item
+    result = wwr('only_item')
+    assert_equal 'only_item', result, 'wwr should return the single item'
+
+    # Test wwr with debug disabled
+    $debug = false
+    result = wwr('a', 'b', 'c')
+    assert_equal 'c', result,
+                 'wwr should return the last item even when debug is disabled'
+  end
+
+  def test_wwp_function_returns_last_item
+    $debug = true
+    $ww_log_file = nil
+
+    # Test wwp with multiple items
+    result = wwp('first', 'second', 'third')
+    assert_equal 'third', result, 'wwp should return the last item'
+
+    # Test wwp with single item
+    result = wwp('only_item')
+    assert_equal 'only_item', result, 'wwp should return the single item'
+
+    # Test wwp with debug disabled
+    $debug = false
+    result = wwp('a', 'b', 'c')
+    assert_equal 'c', result,
+                 'wwp should return the last item even when debug is disabled'
+  end
+
+  def test_wwt_function_returns_last_item
+    $debug = true
+    $ww_log_file = nil
+
+    # Test wwt with multiple items (first item is tag)
+    result = wwt(:test_tag, 'first', 'second', 'third')
+    assert_equal 'third', result, 'wwt should return the last item'
+
+    # Test wwt with single data item after tag
+    result = wwt(:tag, 'only_data_item')
+    assert_equal 'only_data_item', result,
+                 'wwt should return the single data item'
+
+    # Test wwt with skipped tags
+    result = wwt(:blocks, 'data')
+    assert_equal 'data', result, 'wwt should return data even for skipped tags'
+
+    # Test wwt with debug disabled
+    $debug = false
+    result = wwt(:any_tag, 'a', 'b', 'c')
+    assert_equal 'c', result,
+                 'wwt should return the last item even when debug is disabled'
+  end
+
+  def test_wwt_multiline_continuation
+    $debug = true
+    $ww_log_file = nil
+
+    # Test multiline continuation pattern
+    var1 = 'test_value'
+    result = wwt :tag1, \
+                 var1
+    assert_equal 'test_value', result,
+                 'wwt should work with multiline continuation'
+
+    # Test with complex expression
+    complex_var = [1, 2, 3]
+    result = wwt(:processing, \
+                 complex_var.map { |x| x * 2 })
+    assert_equal [2, 4, 6], result,
+                 'wwt should work with complex expressions in multiline'
+
+    # Test with debug disabled
+    $debug = false
+    simple_var = 'no_debug'
+    result = wwt :disabled, \
+                 simple_var
+    assert_equal 'no_debug', result,
+                 'wwt should return correct value even with debug disabled'
+  end
+
+  def test_ww_multiline_continuation
+    $debug = true
+    $ww_log_file = nil
+
+    # Test ww with multiline continuation
+    var1 = 'test_value'
+    result = ww \
+      var1
+    assert_equal 'test_value', result,
+                 'ww should work with multiline continuation'
+
+    # Test with multiple items in multiline
+    result = ww 'prefix', \
+                'value'
+    assert_equal 'value', result,
+                 'ww should work with multiple items in multiline'
+
+    # Test with debug disabled
+    $debug = false
+    result = ww \
+      'no_debug_value'
+    assert_equal 'no_debug_value', result,
+                 'ww should return correct value with debug disabled'
+  end
+
+  def test_wwa_function_behavior
+    $debug = true
+
+    # Test that wwa exits (we can't easily test exit behavior in minitest)
+    # So we'll just verify it would call ww0 properly by testing the structure
+    # Note: wwa calls exit, so we can't test it directly without special handling
+    skip 'wwa exits the program, cannot test directly in minitest'
+  end
+
+  def test_wwe_function_behavior
+    $debug = true
+
+    # Test that wwe raises an error
+    assert_raises(StandardError) do
+      wwe('error message')
+    end
+
+    # Test that wwe raises with the first object as the error message
+    error = assert_raises(StandardError) do
+      wwe('custom error', 'additional', 'data')
+    end
+    assert_equal 'custom error', error.message
+  end
+
+  # Edge case tests
+  def test_edge_cases
+    $debug = false
+
+    # Test with nil values
+    result = ww(nil, 'not_nil')
+    assert_equal 'not_nil', result, 'ww should handle nil values correctly'
+
+    # Test with empty array as last item
+    result = ww('first', [])
+    assert_equal [], result,
+                 'ww should return empty array if it is the last item'
+
+    # Test with false as last item
+    result = ww('first', false)
+    assert_equal false, result, 'ww should return false if it is the last item'
+
+    # Test with zero as last item
+    result = ww('first', 0)
+    assert_equal 0, result, 'ww should return zero if it is the last item'
+
+    # Test with empty string as last item
+    result = ww('first', '')
+    assert_equal '', result,
+                 'ww should return empty string if it is the last item'
+  end
+
+  def test_complex_data_structures
+    $debug = false
+
+    # Test with nested arrays
+    nested = [1, [2, [3, 4]], 5]
+    result = ww('start', nested)
+    assert_equal nested, result, 'ww should handle nested arrays'
+
+    # Test with complex hash
+    complex_hash = {
+      users: [{ name: 'Alice', age: 30 }, { name: 'Bob', age: 25 }],
+      metadata: { created: Time.now, version: '1.0' }
+    }
+    result = ww('prefix', complex_hash)
+    assert_equal complex_hash, result, 'ww should handle complex hashes'
+
+    # Test with objects
+    string_obj = String.new('test')
+    result = ww('object', string_obj)
+    assert_equal string_obj, result, 'ww should handle object instances'
+  end
+
+  def test_options_validation
+    $debug = true
+    $ww_log_file = nil
+
+    # Test valid log levels
+    %i[debug info warn error fatal].each do |level|
+      result = ww('test', level: level)
+      assert_equal 'test', result, "ww should work with log level #{level}"
+    end
+
+    # Test invalid log level raises error
+    assert_raises(ArgumentError) do
+      ww('test', level: :invalid)
+    end
+  end
+
+  def test_output_formatting_options
+    $debug = true
+    $ww_log_file = nil
+
+    # Create fresh buffer for this test
+    fresh_buffer = StringIO.new
+    $ww_output = fresh_buffer
+
+    # Test single_line option
+    ww('test', 'data', single_line: true)
+    output = fresh_buffer.string
+    refute_includes output, "\n        [",
+                    'single_line should format output on one line'
+
+    # Reset buffer
+    fresh_buffer = StringIO.new
+    $ww_output = fresh_buffer
+
+    # Test timestamp option
+    ww('test', timestamp: true)
+    output = fresh_buffer.string
+    assert_match(/\[\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\]/, output,
+                 'timestamp should be included in output')
+
+    # Reset buffer
+    fresh_buffer = StringIO.new
+    $ww_output = fresh_buffer
+
+    # Test category option
+    ww('test', category: 'MYCATEGORY')
+    output = fresh_buffer.string
+    assert_includes output, '[MYCATEGORY]',
+                    'category should be included in output'
+  end
+
+  def test_location_information
+    $debug = true
+    $ww_log_file = nil
+
+    # Create fresh buffer for this test
+    fresh_buffer = StringIO.new
+    $ww_output = fresh_buffer
+
+    # Test that location information is included
+    ww('location test')
+    output = fresh_buffer.string
+
+    # Should include file path and line number information
+    assert_includes output, 'lib/ww.rb', 'output should include filename'
+    assert_match(/\s:\s\d+\s:/, output,
+                 'output should include line number with format')
+  end
+
+  def test_full_backtrace_option
+    $debug = true
+    $ww_log_file = nil
+
+    # Create fresh buffer for this test
+    fresh_buffer = StringIO.new
+    $ww_output = fresh_buffer
+
+    # Test full_backtrace option
+    ww('test', full_backtrace: true)
+    output = fresh_buffer.string
+
+    # With full backtrace, we should see multiple stack levels
+    # (This is hard to test precisely since it depends on call stack depth)
+    refute_empty output, 'full_backtrace should produce output'
+  end
+
+  def test_multiple_consecutive_calls
+    $debug = false
+
+    # Test that multiple calls work correctly
+    results = []
+    results << ww('call1', 'result1')
+    results << ww('call2a', 'call2b', 'result2')
+    results << ww('call3a', 'call3b', 'call3c', 'result3')
+
+    assert_equal %w[result1 result2 result3], results,
+                 'Multiple consecutive calls should work correctly'
+  end
+
+  def test_return_value_consistency_across_debug_states
+    # Test the same call with debug enabled and disabled
+    test_args = %w[first second third]
+
+    # With debug disabled
+    $debug = false
+    $ww_log_file = nil
+    result_no_debug = ww(*test_args)
+
+    # With debug enabled, no log file
+    $debug = true
+    $ww_log_file = nil
+    result_debug_no_log = ww(*test_args)
+
+    # With debug enabled, with log file
+    $debug = true
+    $ww_log_file = 'consistency_test.log'
+    begin
+      result_debug_with_log = ww(*test_args)
+    ensure
+      FileUtils.rm_f('consistency_test.log')
+    end
+
+    # All should return the same value
+    assert_equal 'third', result_no_debug,
+                 'Should return last item with debug disabled'
+    assert_equal 'third', result_debug_no_log,
+                 'Should return last item with debug enabled, no log'
+    assert_equal 'third', result_debug_with_log,
+                 'Should return last item with debug enabled, with log'
+    assert_equal result_no_debug, result_debug_no_log,
+                 'Results should be consistent across debug states'
+    assert_equal result_no_debug, result_debug_with_log,
+                 'Results should be consistent across log file states'
+  end
+end