markdown_exec 2.8.3 → 2.8.4

data/lib/link_history.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env ruby
+#!/usr/bin/env -S bundle exec ruby
 # frozen_string_literal: true
 
 # encoding=utf-8
@@ -52,45 +52,45 @@ module MarkdownExec
     end
 
     def inherited_lines
-      @inherited_lines.tap { |ret|
+      @inherited_lines.tap do |ret|
         pp ['LinkState.inherited_lines() ->', ret] if $pd
-      }
+      end
     end
 
     def inherited_lines=(value)
-      @inherited_lines = value.tap { |ret|
+      @inherited_lines = value.tap do |ret|
         pp ['LinkState.inherited_lines=() ->', ret] if $pd
-      }
+      end
     end
 
     def inherited_lines_append(value)
-      @inherited_lines = ((@inherited_lines || []) + value).tap { |ret|
+      @inherited_lines = ((@inherited_lines || []) + value).tap do |ret|
         pp ['LinkState.inherited_lines_append() ->', ret] if $pd
-      }
+      end
     end
 
     def inherited_lines_block
-      (@inherited_lines || []).join("\n").tap { |ret|
+      (@inherited_lines || []).join("\n").tap do |ret|
         pp ['LinkState.inherited_lines_block() ->', ret] if $pd
-      }
+      end
     end
 
     def inherited_lines_count
-      (@inherited_lines&.count || 0).tap { |ret|
+      (@inherited_lines&.count || 0).tap do |ret|
         pp ['LinkState.inherited_lines_count() ->', ret] if $pd
-      }
+      end
     end
 
-    def inherited_lines_map
-      @inherited_lines.map do |line|
-        yield line
-      end.tap { |ret| pp ['LinkState.inherited_lines_map() ->', ret] if $pd }
+    def inherited_lines_map(&block)
+      @inherited_lines.map(&block).tap do |ret|
+        pp ['LinkState.inherited_lines_map() ->', ret] if $pd
+      end
     end
 
     def inherited_lines_present?
-      @inherited_lines.present?.tap { |ret|
+      @inherited_lines.present?.tap do |ret|
         pp ['LinkState.inherited_lines_present?() ->', ret] if $pd
-      }
+      end
     end
   end
 

data/lib/logged_struct.rb

@@ -0,0 +1,429 @@
+#!/usr/bin/env -S bundle exec ruby
+# frozen_string_literal: true
+
+# encoding=utf-8
+
+require 'logger'
+require 'ostruct'
+require 'stringio'
+
+# LoggedStruct behaves like OpenStruct but logs all get and set operations
+# on its attributes, providing visibility into how the object is used.
+class LoggedStruct < OpenStruct
+  attr_reader :logger, :log_buffer
+
+  # Initializes a new LoggedStruct.
+  # @param hash [Hash] initial values.
+  # @param logger [Logger] logger instance; one is created if not provided.
+  # @param log_level [Symbol] logging level (:debug, :info, etc.).
+  def initialize(hash = nil, logger: nil, log_level: :debug)
+    @log_buffer = StringIO.new
+    @custom_log_level = log_level.to_sym
+    @logger = logger || Logger.new($stdout)
+    @logger.level = Logger.const_get(@custom_log_level.to_s.upcase)
+    @logger.formatter ||= proc { |severity, datetime, progname, msg| "#{msg}\n" }
+    
+    super({})
+    
+    (hash || {}).each { |key, value| self[key] = value }
+  end
+  
+  # Logs attribute retrieval.
+  def [](name)
+    value = super
+    log_get_operation(name.to_s, value)
+    value
+  end
+  
+  # Logs attribute setting.
+  def []=(name, value)
+    log_set_operation(name.to_s, value)
+    super
+    ensure_logging_methods(name.to_sym)
+    value
+  end
+  
+  # Overrides OpenStruct’s member creation to install logging methods.
+  def new_ostruct_member(name)
+    name = name.to_sym
+    result = super
+    ensure_logging_methods(name)
+    result
+  end
+  
+  # Installs logging versions of getters and setters.
+  # @param name [Symbol] attribute name.
+  def ensure_logging_methods(name)
+    eigen = singleton_class
+    if eigen.method_defined?(name) && eigen.instance_method(name).owner == eigen
+      eigen.send(:remove_method, name)
+    end
+    if eigen.method_defined?("#{name}=") && eigen.instance_method("#{name}=").owner == eigen
+      eigen.send(:remove_method, "#{name}=")
+    end
+
+    eigen.define_method(name) do
+      value = @table[name]
+      log_get_operation(name.to_s, value)
+      value
+    end
+
+    eigen.define_method("#{name}=") do |value|
+      log_set_operation(name.to_s, value)
+      @table[name] = value
+    end
+  end
+  
+  # Delegates missing method calls.
+  def method_missing(method, *args, &block)
+    method_name = method.to_s
+    if method_name.end_with?('=')
+      attribute = method_name.chop
+      self[attribute] = args.first
+    else
+      # If arguments are provided, delegate to super to raise NoMethodError.
+      if args.empty?
+        self[method_name]
+      else
+        super
+      end
+    end
+  end
+
+  # Checks if a method exists.
+  def respond_to_missing?(method, include_private = false)
+    method_name = method.to_s
+    return true if method_name.end_with?('=')
+    @table.key?(method) || super
+  end
+
+  # Logs conversion to a hash.
+  def to_h
+    hash = super
+    log_message("Converting LoggedStruct to Hash: #{hash.inspect}")
+    hash
+  end
+
+  # Returns the internal log buffer.
+  def log_content
+    @log_buffer.string
+  end
+
+  private
+
+  def log_get_operation(attribute, value)
+    message = "GET: #{attribute} => #{value.inspect}"
+    @logger.send(@custom_log_level, message)
+    formatted = @logger.formatter.call(@custom_log_level.to_s.upcase, Time.now, nil, message)
+    @log_buffer.puts(formatted.chomp)
+  end
+
+  def log_set_operation(attribute, value)
+    message = "SET: #{attribute} = #{value.inspect}"
+    @logger.send(@custom_log_level, message)
+    formatted = @logger.formatter.call(@custom_log_level.to_s.upcase, Time.now, nil, message)
+    @log_buffer.puts(formatted.chomp)
+  end
+  
+  def log_message(message)
+    @logger.send(@custom_log_level, message)
+    formatted = @logger.formatter.call(@custom_log_level.to_s.upcase, Time.now, nil, message)
+    @log_buffer.puts(formatted.chomp)
+  end
+end
+
+return unless $PROGRAM_NAME == __FILE__
+
+require 'bundler/setup'
+Bundler.require(:default)
+
+require 'minitest/autorun'
+require 'mocha/minitest'
+
+require_relative 'ww'
+
+require 'stringio'
+
+class LoggedStructTest < Minitest::Test
+  def setup
+    @log_output = StringIO.new
+    @logger = Logger.new(@log_output)
+    @logger.level = Logger::DEBUG
+    @logger.formatter = proc { |_, _, _, msg| "#{msg}\n" }
+  end
+
+  def test_initialization_with_hash
+    struct = LoggedStruct.new({ name: 'John', age: 30 }, logger: @logger)
+    
+    name = struct.name
+    assert_equal 'John', name
+    assert_includes struct.log_content, 'GET: name => "John"'
+    
+    age = struct.age
+    assert_equal 30, age
+    assert_includes struct.log_content, 'GET: age => 30'
+  end
+
+  def test_initialization_without_hash
+    struct = LoggedStruct.new(logger: @logger)
+    
+    assert_nil struct.name
+    assert_includes struct.log_content, 'GET: name => nil'
+  end
+
+  def test_method_style_getter
+    struct = LoggedStruct.new({ name: 'John' }, logger: @logger)
+    
+    result = struct.name
+    
+    assert_equal 'John', result
+    assert_includes struct.log_content, 'GET: name => "John"'
+  end
+
+  def test_method_style_setter
+    struct = LoggedStruct.new(logger: @logger)
+    
+    struct.name = 'John'
+    assert_includes struct.log_content, 'SET: name = "John"'
+    
+    result = struct.name
+    assert_equal 'John', result
+    assert_includes struct.log_content, 'GET: name => "John"'
+  end
+
+  def test_hash_style_getter
+    struct = LoggedStruct.new({ name: 'John' }, logger: @logger)
+    @log_output.truncate(0)
+    @log_output.rewind
+    
+    result = struct[:name]
+    
+    assert_equal 'John', result
+    assert_includes struct.log_content, 'GET: name => "John"'
+  end
+
+  def test_hash_style_setter
+    struct = LoggedStruct.new(logger: @logger)
+    @log_output.truncate(0)
+    @log_output.rewind
+    
+    struct[:name] = 'John'
+    
+    assert_equal 'John', struct[:name]
+    assert_includes struct.log_content, 'SET: name = "John"'
+    # The second line should be from the getter assertion
+    assert_includes struct.log_content, 'GET: name => "John"'
+  end
+
+  def test_to_h_method
+    struct = LoggedStruct.new({ name: 'John', age: 30 }, logger: @logger)
+    @log_output.truncate(0)
+    @log_output.rewind
+    
+    result = struct.to_h
+    
+    assert_equal({ name: 'John', age: 30 }, result)
+    assert_includes struct.log_content, 'Converting LoggedStruct to Hash: {:name=>"John", :age=>30}'
+  end
+
+  def test_custom_log_level
+    logger = Logger.new(@log_output)
+    logger.formatter = proc { |severity, _, _, msg| "#{severity}: #{msg}\n" }
+    
+    struct = LoggedStruct.new({ name: 'John' }, logger: logger, log_level: :info)
+    @log_output.truncate(0)
+    @log_output.rewind
+    
+    struct.name
+    
+    assert_includes struct.log_content, 'INFO: GET: name => "John"'
+  end
+
+  def test_method_missing_for_undefined_method
+    struct = LoggedStruct.new(logger: @logger)
+    
+    assert_raises(NoMethodError) do
+      struct.undefined_method('argument')
+    end
+  end
+
+  def test_nested_values
+    struct = LoggedStruct.new({ user: { name: 'John', age: 30 } }, logger: @logger)
+    @log_output.truncate(0)
+    @log_output.rewind
+    
+    result = struct.user
+    
+    assert_equal({ name: 'John', age: 30 }, result)
+    assert_includes struct.log_content, 'GET: user => {:name=>"John", :age=>30}'
+  end
+
+  def test_array_values
+    struct = LoggedStruct.new({ tags: ['ruby', 'testing'] }, logger: @logger)
+    @log_output.truncate(0)
+    @log_output.rewind
+    
+    result = struct.tags
+    
+    assert_equal(['ruby', 'testing'], result)
+    assert_includes struct.log_content, 'GET: tags => ["ruby", "testing"]'
+  end
+
+  def test_boolean_values
+    struct = LoggedStruct.new({ active: true }, logger: @logger)
+    @log_output.truncate(0)
+    @log_output.rewind
+    
+    result = struct.active
+    
+    assert_equal true, result
+    assert_includes struct.log_content, 'GET: active => true'
+  end
+
+  def test_nil_values
+    struct = LoggedStruct.new({ data: nil }, logger: @logger)
+    @log_output.truncate(0)
+    @log_output.rewind
+    
+    result = struct.data
+    
+    assert_nil result
+    assert_includes struct.log_content, 'GET: data => nil'
+  end
+
+  def test_numeric_values
+    struct = LoggedStruct.new({ count: 42, price: 99.99 }, logger: @logger)
+    @log_output.truncate(0)
+    @log_output.rewind
+    
+    count = struct.count
+    price = struct.price
+    
+    assert_equal 42, count
+    assert_equal 99.99, price
+    assert_includes struct.log_content, 'GET: count => 42'
+    assert_includes struct.log_content, 'GET: price => 99.99'
+  end
+
+  def test_debug_logging
+    # Create a struct with direct logging to STDOUT for visibility
+    stdout_logger = Logger.new($stdout)
+    stdout_logger.level = Logger::DEBUG
+    stdout_logger.formatter = proc { |_, _, _, msg| "STDOUT_LOG: #{msg}\n" }
+    
+    struct = LoggedStruct.new({ value: 'test' }, logger: stdout_logger)
+    
+    # Check the initial state of the log buffer
+    puts "Initial log buffer content: #{struct.log_buffer.string.inspect}"
+    
+    # Get a value to trigger logging
+    value = struct.value
+    puts "After get - log buffer: #{struct.log_buffer.string.inspect}"
+    
+    # Set a value to trigger logging
+    struct.new_value = 'hello world'
+    puts "After set - log buffer: #{struct.log_buffer.string.inspect}"
+    
+    # Make a direct assertion we can verify
+    assert_includes struct.log_buffer.string, "GET: value => \"test\""
+    assert_includes struct.log_buffer.string, "SET: new_value = \"hello world\""
+  end
+end
+
+__END__
+
+# ExampleUsage1 demonstrates basic usage with default logger settings.
+class ExampleUsage1
+  # Runs the basic usage example.
+  def self.run
+    puts "Example 1: Basic Usage with Default Logger"
+    logged = LoggedStruct.new(name: "John", age: 30)
+    # Method-style getter; logs GET operation.
+    puts "Name: #{logged.name}"
+    # Method-style setter; logs SET operation.
+    logged.age = 31
+    # Hash-style setter and getter.
+    logged[:email] = "john@example.com"
+    puts "Email: #{logged[:email]}"
+    # Conversion to hash; logs the conversion.
+    puts "Hash: #{logged.to_h.inspect}"
+    puts "Internal Log Buffer:"
+    puts logged.log_content
+  end
+end
+
+ExampleUsage1.run
+
+# ExampleUsage2 demonstrates using a custom logger configured at INFO level.
+class ExampleUsage2
+  # Runs the custom logger example.
+  def self.run
+    puts "\nExample 2: Custom Logger with INFO Level"
+    custom_logger = Logger.new($stdout)
+    custom_logger.level = Logger::INFO
+    custom_logger.formatter = proc { |severity, _datetime, _progname, msg| "#{severity}: #{msg}\n" }
+    logged = LoggedStruct.new({ count: 0 }, logger: custom_logger, log_level: :info)
+    # Setter call logs at INFO level.
+    logged.count = 1
+    # Getter call logs at INFO level.
+    puts "Count: #{logged.count}"
+    puts "Internal Log Buffer:"
+    puts logged.log_content
+  end
+end
+
+ExampleUsage2.run
+
+# ExampleUsage3 demonstrates dynamic attribute creation and proper method_missing behavior.
+class ExampleUsage3
+  # Runs the dynamic attribute and method_missing example.
+  def self.run
+    puts "\nExample 3: Dynamic Attribute Creation and Method Missing Handling"
+    custom_logger = Logger.new($stdout)
+    custom_logger.level = Logger::INFO
+    custom_logger.formatter = proc { |severity, _datetime, _progname, msg| "#{severity}: #{msg}\n" }
+    logged = LoggedStruct.new(logger: custom_logger, log_level: :info)
+    # Dynamic method call creates a new attribute and logs SET.
+    logged.city = "New York"
+    # Dynamic getter call logs GET.
+    puts "City: #{logged.city}"
+    # Calling an undefined method with arguments triggers NoMethodError.
+    begin
+      logged.undefined_method("argument")
+    rescue NoMethodError => e
+      puts "Caught expected NoMethodError: #{e.message}"
+    end
+    puts "Internal Log Buffer:"
+    puts logged.log_content
+  end
+end
+
+ExampleUsage3.run
+
+# ExampleUsage4 demonstrates handling of complex values such as nested hashes, arrays, booleans, numbers, and nil.
+class ExampleUsage4
+  # Runs the complex values example.
+  def self.run
+    puts "\nExample 4: Handling Complex Data Types"
+    custom_logger = Logger.new($stdout)
+    custom_logger.level = Logger::INFO
+    custom_logger.formatter = proc { |severity, _datetime, _progname, msg| "#{severity}: #{msg}\n" }
+    data = {
+      user: { name: "Alice", age: 28 },
+      tags: ["developer", "blogger"],
+      active: true,
+      score: 98.5,
+      data: nil
+    }
+    logged = LoggedStruct.new(data, logger: custom_logger, log_level: :info)
+    puts "User: #{logged.user}"
+    puts "Tags: #{logged.tags.inspect}"
+    puts "Active: #{logged.active}"
+    puts "Score: #{logged.score}"
+    puts "Data: #{logged.data.inspect}"
+    puts "Internal Log Buffer:"
+    puts logged.log_content
+  end
+end
+
+ExampleUsage4.run

data/lib/markdown_exec/version.rb

@@ -7,5 +7,5 @@ module MarkdownExec
   BIN_NAME = 'mde'
   GEM_NAME = 'markdown_exec'
   TAP_DEBUG = 'MDE_DEBUG'
-  VERSION = '2.8.3'
+  VERSION = '2.8.4'
 end

data/lib/markdown_exec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env ruby
+#!/usr/bin/env -S bundle exec ruby
 # frozen_string_literal: true
 
 # encoding=utf-8
@@ -30,10 +30,12 @@ require_relative 'hash_delegator'
 require_relative 'input_sequencer'
 require_relative 'markdown_exec/version'
 require_relative 'mdoc'
+require_relative 'null_result'
 require_relative 'option_value'
 require_relative 'saved_assets'
 require_relative 'saved_files_matcher'
 require_relative 'shared'
+require_relative 'success_result'
 require_relative 'tap'
 
 include CLI
@@ -826,7 +828,6 @@ module MarkdownExec
     def opts_menu_option_append(opts, options, item, options_parsed)
       return unless item[:long_name].present? || item[:short_name].present?
 
-      optname = "-#{item[:short_name]}"
       switches = [
         # - argument style = :NONE, :REQUIRED, :OPTIONAL
         case item[:procname]&.to_s
@@ -840,7 +841,6 @@ module MarkdownExec
 
         # - long name
         if item[:long_name].present?
-          optname = "--#{item[:long_name]}"
           "--#{item[:long_name]}" \
             "#{item[:arg_name].present? ? " #{item[:arg_name]}" : ''}"
         end,

data/lib/mdoc.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env ruby
+#!/usr/bin/env -S bundle exec ruby
 # frozen_string_literal: true
 
 # encoding=utf-8
@@ -92,10 +92,7 @@ module MarkdownExec
       # select blocks in order of appearance in source documents
       #
       blocks = @table.select do |fcb|
-        # 2024-08-04 match nickname
-        all_dependency_names.include?(fcb.pub_name) ||
-          all_dependency_names.include?(fcb.nickname) ||
-          all_dependency_names.include?(fcb.oname)
+        fcb.is_dependency_of?(all_dependency_names)
       end
       # !!t blocks.count
 
@@ -103,12 +100,7 @@ module MarkdownExec
       #
       unmet_dependencies = all_dependency_names.dup
       blocks = blocks.map do |fcb|
-        # 2024-08-04 match oname for long block names
-        # 2024-08-04 match nickname
-        # may not exist if block name is duplicated
-        unmet_dependencies.delete(fcb.pub_name) ||
-          unmet_dependencies.delete(fcb.nickname) ||
-          unmet_dependencies.delete(fcb.oname)
+        fcb.delete_matching_name!(unmet_dependencies)
         if (call = fcb.call)
           fcb1 = get_block_by_anyname("[#{call.match(/^%\((\S+) |\)/)[1]}]")
           fcb1.cann = call
@@ -333,12 +325,8 @@ module MarkdownExec
     # @return [Hash] The code block as a hash or the default value if not found.
     #
     def get_block_by_anyname(name, default = {})
-      # !!t name
       @table.select do |fcb|
-        fcb.nickname == name ||
-          fcb.dname == name ||
-          fcb.oname == name ||
-          fcb.pub_name == name
+        fcb.is_named?(name)
       end.fetch(0, default)
     end
 
@@ -528,7 +516,7 @@ if $PROGRAM_NAME == __FILE__
           { oname: 'block2', body: ['code for block2'], reqs: nil },
           { oname: 'block3', body: ['code for block3'], reqs: ['block1'] }
         ].map do |row|
-          OpenStruct.new(nickname: nil, **row)
+          FCB.new(nickname: nil, **row)
         end
         @doc = MDoc.new(@table)
       end

data/lib/menu.src.yml

@@ -914,7 +914,9 @@
 - :opt_name: menu_note_match
   :env_var: MDE_MENU_NOTE_MATCH
   :description: Pattern for notes in block selection menu
-  :default: "^(?<indent>[ \t]*)(?<line>(?!/)(?<text>.*?)(?<trailing>[ \t]*))?$"
+  # 'line' excludes 'indent' and 'trailing'
+  # 'text' group matches multiline from variable expansion
+  :default: "^(?'indent'[ \t]*)(?'line'(?!/)(?'text'.*))(?'trailing'[ \t]*)?$"
   :procname: val_as_str
 
 - :opt_name: menu_option_back_name

data/lib/menu.yml

@@ -772,7 +772,7 @@
 - :opt_name: menu_note_match
   :env_var: MDE_MENU_NOTE_MATCH
   :description: Pattern for notes in block selection menu
-  :default: "^(?<indent>[ \t]*)(?<line>(?!/)(?<text>.*?)(?<trailing>[ \t]*))?$"
+  :default: "^(?'indent'[ \t]*)(?'line'(?!/)(?'text'.*))(?'trailing'[ \t]*)?$"
   :procname: val_as_str
 - :opt_name: menu_option_back_name
   :env_var: MDE_MENU_OPTION_BACK_NAME

data/lib/namer.rb

@@ -1,4 +1,3 @@
-#!/usr/bin/env ruby
 # frozen_string_literal: true
 
 # encoding=utf-8
@@ -10,9 +9,9 @@ class Hash
   # block name in commands and documents
   def pub_name(**kwargs)
     full = fetch(:nickname, nil) || fetch(:oname, nil)
-    full&.to_s&.pub_name(**kwargs).tap { |ret|
+    full&.to_s&.pub_name(**kwargs).tap do |ret|
       pp [__LINE__, 'Hash.pub_name() ->', ret] if $pd
-    }
+    end
   end
 end
 
@@ -37,8 +36,8 @@ class String
                 self
               end
 
-    trimmed.gsub(pattern, replacement).tap { |ret|
+    trimmed.gsub(pattern, replacement).tap do |ret|
       pp [__LINE__, 'String.pub_name() ->', ret] if $pd
-    }
+    end
   end
 end