markdown_exec 2.2.0 → 2.4.0

data/lib/hierarchy_string.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+require_relative 'ansi_string'
+
+# Class representing a hierarchy of substrings stored as Hash nodes
+# HierarchyString is a class that represents and manipulates strings based on a hierarchical structure.
+# The input to the class can be a single hash or an array of nested hashes, where each hash contains a
+# text string and an optional decoration or transformation (like `:downcase`, `:upcase`, etc.).
+#
+# The primary functionalities of the class include:
+#
+# - **Initialization**: The class can be initialized with either a single hash or an array of nested hashes.
+#   Each hash contains a @text_sym key representing the string and a @style_sym key representing the transformation
+#   (optional).
+#
+# - **Concatenation**: The `concatenate` method concatenates all text strings in the hierarchy into a single string.
+#
+# - **Decoration**: The `decorate` method applies the specified transformation (like `:downcase`, `:upcase`) to the
+#   text in the hierarchy and returns the decorated string.
+#
+# - **Text Replacement**: The `replace_text!` method allows in-place replacement of text in the hierarchy by applying
+#   a block to each text string.
+#
+# - **Method Delegation**: The class uses `method_missing` and `respond_to_missing?` to delegate undefined method calls
+#   to the string object, allowing for dynamic method handling on the concatenated string (e.g., `capitalize`).
+#
+# This class is useful for situations where strings are represented in a hierarchical or nested structure and need
+# to be manipulated or transformed in a consistent and customizable manner.
+class HierarchyString
+  attr_accessor :substrings
+
+  # Initialize with a single hash or an array of hashes
+  def initialize(substrings, text_sym: :text, style_sym: :color)
+    @substrings = parse_substrings(substrings)
+    @text_sym = text_sym
+    @style_sym = style_sym
+  end
+
+  def map_substring_text_yield(tree, &block)
+    case tree
+    when Array
+      tree.each.with_index do |node, ind|
+        case node
+        when String
+          tree[ind] = yield node
+        else
+          map_substring_text_yield(node, &block)
+        end
+      end
+    when Hash
+      text = yield tree[@text_sym]
+      tree[@text_sym] = text
+
+      tree
+    when String
+      yield tree
+    else
+      raise ArgumentError, 'Invalid type.'
+    end
+  end
+
+  # operate on substring
+  def replace_text!
+    map_substring_text_yield(@substrings) do |node|
+      case node
+      when Hash
+        text = yield node[@text_sym]
+        node[@text_sym] = text
+      when String
+        yield node
+      end
+    end
+  end
+
+  # Method to concatenate all substrings into a single string
+  def concatenate
+    concatenate_substrings(@substrings)
+  end
+
+  # Method to decorate all substrings into a single string
+  def decorate
+    decorate_substrings(@substrings)
+  end
+
+  # Handle string inspection methods and pass them to the concatenated string
+  def method_missing(method_name, *arguments, &block)
+    if ''.respond_to?(method_name)
+      concatenate.send(method_name, *arguments, &block)
+    else
+      super
+    end
+  end
+
+  # Ensure proper handling of method checks
+  def respond_to_missing?(method_name, include_private = false)
+    ''.respond_to?(method_name) || super
+  end
+
+  private
+
+  # Parse the input substrings into a nested array of hashes structure
+  def parse_substrings(substrings)
+    case substrings
+    when Hash
+      [substrings]
+    when Array
+      substrings.map { |s| parse_substrings(s) }
+    else
+      substrings
+      # raise ArgumentError, 'Invalid input type. Expected Hash or Array.'
+    end
+  end
+
+  # Recursively concatenate substrings
+  def concatenate_substrings(substrings)
+    substrings.map do |s|
+      case s
+      when Hash
+        s[@text_sym]
+      when Array
+        concatenate_substrings(s)
+      end
+    end.join
+  end
+
+  # Recursively decorate substrings
+  def decorate_substrings(substrings, prior_color = '')
+    substrings.map do |s|
+      case s
+      when Hash
+        if s[@style_sym]
+          AnsiString.new(s[@text_sym]).send(s[@style_sym]) + prior_color
+        else
+          s[@text_sym]
+        end
+      when Array
+        decorate_substrings(s, prior_color)
+      end
+    end.join
+  end
+end
+
+return if $PROGRAM_NAME != __FILE__
+
+require 'minitest/autorun'
+
+class TestHierarchyString < Minitest::Test
+  def setup
+    text_sym = :text
+    style_sym = :color
+
+    @single_hash = { text_sym => 'Hello', style_sym => :downcase }
+    @nested_hashes = [
+      { text_sym => 'Hello', style_sym => :downcase },
+      [
+        { text_sym => ' ', style_sym => nil },
+        { text_sym => 'World', style_sym => :upcase }
+      ]
+    ]
+    @hierarchy_single = HierarchyString.new(@single_hash)
+    @hierarchy_nested = HierarchyString.new(@nested_hashes)
+  end
+
+  def test_initialize_single_hash
+    text_sym = :text
+    style_sym = :color
+
+    assert_equal [{ text_sym => 'Hello', style_sym => :downcase }],
+                 @hierarchy_single.substrings
+  end
+
+  def test_initialize_nested_hashes
+    text_sym = :text
+    style_sym = :color
+
+    expected = [
+      [{ text_sym => 'Hello', style_sym => :downcase }],
+      [
+        [{ text_sym => ' ', style_sym => nil }],
+        [{ text_sym => 'World', style_sym => :upcase }]
+      ]
+    ]
+    assert_equal expected, @hierarchy_nested.substrings
+  end
+
+  def test_concatenate_single_hash
+    assert_equal 'Hello', @hierarchy_single.concatenate
+  end
+
+  def test_concatenate_nested_hashes
+    assert_equal 'Hello World', @hierarchy_nested.concatenate
+  end
+
+  def test_decorate_single_hash
+    assert_equal 'Hello'.downcase, @hierarchy_single.decorate
+  end
+
+  def test_decorate_nested_hashes
+    assert_equal "#{'Hello'.downcase} #{'World'.upcase}",
+                 @hierarchy_nested.decorate
+  end
+
+  def test_replace_text_single_hash
+    @hierarchy_single.replace_text!(&:upcase)
+    assert_equal 'HELLO', @hierarchy_single.concatenate
+  end
+
+  def test_replace_text_nested_hashes
+    @hierarchy_nested.replace_text!(&:upcase)
+    assert_equal 'HELLO WORLD', @hierarchy_nested.concatenate
+  end
+
+  def test_method_missing
+    assert_equal 'Hello', @hierarchy_single.capitalize
+  end
+
+  def test_respond_to_missing
+    assert @hierarchy_single.respond_to?(:capitalize)
+    refute @hierarchy_single.respond_to?(:non_existent_method)
+  end
+end

data/lib/input_sequencer.rb

@@ -47,11 +47,16 @@ class InputSequencer
 
   # Generates the next menu state based on provided attributes.
 
-  def self.next_link_state(block_name: nil, display_menu: nil, document_filename: nil, prior_block_was_link: false)
+  def self.next_link_state(
+    block_name: nil, display_menu: nil, document_filename: nil,
+    inherited_lines: nil, keep_code: false, prior_block_was_link: false
+  )
     MarkdownExec::LinkState.new(
       block_name: block_name,
       display_menu: display_menu,
       document_filename: document_filename,
+      inherited_lines: inherited_lines,
+      keep_code: keep_code,
       prior_block_was_link: prior_block_was_link
     )
   end
@@ -59,6 +64,8 @@ class InputSequencer
   # Orchestrates the flow of menu states and user interactions.
   def run_yield(sym, *args, &block)
     block.call sym, *args
+  rescue AppInterrupt
+    raise
   # rubocop:disable Style/RescueStandardError
   rescue
     pp $!, $@
@@ -79,7 +86,8 @@ class InputSequencer
     )
     exit_when_bq_empty = !bq_is_empty? # true when running blocks from cli; unless "stay" is used
     loop do
-      break if run_yield(:parse_document, now_menu.document_filename, &block) == :break
+      break if run_yield(:parse_document, now_menu.document_filename,
+                         &block) == :break
 
       # self.imw_ins now_menu, 'now_menu'
 
@@ -90,16 +98,17 @@ class InputSequencer
         run_yield :display_menu, &block
 
         choice = run_yield :user_choice, &block
+        break if choice == :break
 
-        raise 'Block not recognized.' if choice.nil?
-        break if run_yield(:exit?, choice&.downcase, &block) # Exit loop and method to terminate the app
+        raise BlockMissing, 'Block not recognized.' if choice.nil?
+        # Exit loop and method to terminate the app
+        break if run_yield(:exit?, choice&.to_s.downcase, &block)
 
         next_state = run_yield :execute_block, choice, &block
         # imw_ins next_state, 'next_state'
-        return :break if next_state == :break
+        break if next_state == :break
 
         next_menu = next_state
-
       else
         if now_menu.block_name && !now_menu.block_name.empty?
           block_name = now_menu.block_name
@@ -115,6 +124,8 @@ class InputSequencer
                       InputSequencer.next_link_state(display_menu: true)
                     else
                       state = run_yield :execute_block, block_name, &block
+                      break if state == :break
+
                       state.display_menu = bq_is_empty?
                       state
                     end
@@ -123,11 +134,8 @@ class InputSequencer
       end
       now_menu = InputSequencer.merge_link_state(now_menu, next_menu)
     end
-  # rubocop:disable Style/RescueStandardError
-  rescue
-    pp $!, $@
-    exit 1
-    # rubocop:enable Style/RescueStandardError
+
+    run_yield :close_ux, &block
   end
 end
 

data/lib/instance_method_wrapper.rb

@@ -68,7 +68,8 @@ module InstanceMethodWrapper
 
   def self.prepended(base)
     base.instance_methods(false).each do |method_name|
-      wrap_method(base, method_name) unless %i[method_missing].include? method_name
+      wrap_method(base,
+                  method_name) unless %i[method_missing].include? method_name
     end
 
     base.singleton_class.send(:define_method, :method_added) do |method_name|

data/lib/layered_hash.rb

@@ -0,0 +1,143 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# encoding=utf-8
+
+class LayeredHash
+  def initialize(table = {}, layers: %i[main])
+    @layers = layers.map { |layer| [layer, {}] }.to_h
+    @current_layer = layers.first
+    @layers[@current_layer] = table
+  end
+
+  private
+
+  def method_missing(method, *args, &block)
+    method_name = method.to_s
+    if @layers.respond_to?(method_name)
+      @layers.send(method_name, *args, &block)
+    elsif method_name[-1] == '='
+      @layers[method_name.chop.to_sym] = args[0]
+    elsif @layers.respond_to?(method_name)
+      @layers.send(method_name, *args)
+    else
+      @layers[method_name.to_sym]
+    end
+  rescue StandardError => err
+    warn("ERROR ** LayeredHash.method_missing(method: #{method_name}," \
+         " *args: #{args.inspect}, &block)")
+    warn err.inspect
+    warn(caller[0..4])
+    raise err
+  end
+
+  public
+
+  # Retrieves the value of a key from the current layer using hash notation
+  def [](key)
+    raise "Current layer not set" unless @current_layer
+
+    get_from_layer(@current_layer, key)
+  end
+
+  # Sets a key-value pair in the current layer using hash notation
+  def []=(key, value)
+    raise "Current layer not set" unless @current_layer
+
+    set(@current_layer, key, value)
+  end
+
+  def fetch(key, *args)
+    key_sym = key.to_sym
+    if respond_to?("get_#{key}")
+      send("get_#{key}")
+    # elsif @table.key?(key_sym)
+    elsif @layers[@current_layer].key?(key_sym)
+      # @table[key_sym]
+      @layers[@current_layer][key_sym]
+    elsif block_given?
+      yield key_sym
+    elsif args.count.positive?
+      args.first
+    else
+      binding.irb
+      raise KeyError, "key not found: #{key}"
+    end.tap { |ret|
+      pp([__LINE__, "Poly.fetch #{key} #{args}", '->',
+          ret]) if $pd
+    }
+  end
+
+  # Retrieves the value of a key from the highest priority layer that has a value
+  def get(key)
+    @layers.reverse_each do |_, hash|
+      return hash[key] if hash.key?(key)
+    end
+    nil
+  end
+
+  # Retrieves the value of a key from the specified layer
+  def get_from_layer(layer, key)
+    if @layers.key?(layer)
+      @layers[layer][key]
+    else
+      raise ArgumentError, "Layer #{layer} does not exist"
+    end
+  end
+
+  def merge(*args)
+    @layers.merge(*args).tap { |ret|
+      pp([__LINE__, "LayeredHash.merge", '->', ret]) if $pd
+    }
+  end
+
+  def respond_to_missing?(method_name, include_private = false)
+    @layers.key?(method_name.to_sym) || super
+  end
+
+  # Sets a key-value pair in the specified layer
+  def set(layer, key, value)
+    if @layers.key?(layer)
+      @layers[layer][key] = value
+    else
+      raise ArgumentError, "Layer #{layer} does not exist"
+    end
+  end
+
+  # Sets the current layer for use with hash notation ([])
+  def set_current_layer(layer)
+    if @layers.key?(layer)
+      @current_layer = layer
+    else
+      raise ArgumentError, "Layer #{layer} does not exist"
+    end
+  end
+
+  def to_h
+    @layers.to_h
+  end
+end
+
+return if $PROGRAM_NAME != __FILE__
+
+layered_hash = LayeredHash.new(layers: %i[low high])
+
+# Set current layer
+layered_hash.set_current_layer(:low)
+
+# Set values in the current layer using hash notation
+layered_hash[:key1] = 'low_value'
+layered_hash[:key2] = 'low_only_value'
+
+# Switch current layer
+layered_hash.set_current_layer(:high)
+
+# Set values in the new current layer using hash notation
+layered_hash[:key1] = 'high_value'
+
+# Get value from the specific current layer using hash notation
+puts layered_hash[:key1] # Output: 'high_value'
+
+# Get value from the highest priority layer
+puts layered_hash.get(:key1) # Output: 'high_value'
+puts layered_hash.get(:key2) # Output: 'low_only_value'

data/lib/link_history.rb

@@ -9,7 +9,7 @@ module MarkdownExec
   class LinkState
     attr_accessor :block_name, :display_menu, :document_filename,
                   :inherited_block_names, :inherited_dependencies,
-                  :prior_block_was_link
+                  :keep_code, :prior_block_was_link
 
     # Initialize the LinkState with keyword arguments for each attribute.
     # @param block_name [String, nil] the name of the block.
@@ -19,13 +19,14 @@ module MarkdownExec
     # @param inherited_lines [Array<String>, nil] the inherited lines of code.
     def initialize(block_name: nil, display_menu: nil, document_filename: nil,
                    inherited_block_names: [], inherited_dependencies: nil, inherited_lines: nil,
-                   prior_block_was_link: nil)
+                   keep_code: false, prior_block_was_link: nil)
       @block_name = block_name
       @display_menu = display_menu
       @document_filename = document_filename
       @inherited_block_names = inherited_block_names
       @inherited_dependencies = inherited_dependencies
       @inherited_lines = inherited_lines
+      @keep_code = keep_code
       @prior_block_was_link = prior_block_was_link
     end
 
@@ -46,27 +47,38 @@ module MarkdownExec
         other.inherited_block_names == inherited_block_names &&
         other.inherited_dependencies == inherited_dependencies &&
         other.inherited_lines == inherited_lines &&
+        other.keep_code == keep_code &&
         other.prior_block_was_link == prior_block_was_link
     end
 
     def inherited_lines
-      @inherited_lines.tap { |ret| pp ['LinkState.inherited_lines() ->', ret] if $pd }
+      @inherited_lines.tap { |ret|
+        pp ['LinkState.inherited_lines() ->', ret] if $pd
+      }
     end
 
     def inherited_lines=(value)
-      @inherited_lines = value.tap { |ret| pp ['LinkState.inherited_lines=() ->', ret] if $pd }
+      @inherited_lines = value.tap { |ret|
+        pp ['LinkState.inherited_lines=() ->', ret] if $pd
+      }
     end
 
     def inherited_lines_append(value)
-      @inherited_lines = ((@inherited_lines || []) + value).tap { |ret| pp ['LinkState.inherited_lines_append() ->', ret] if $pd }
+      @inherited_lines = ((@inherited_lines || []) + value).tap { |ret|
+        pp ['LinkState.inherited_lines_append() ->', ret] if $pd
+      }
     end
 
     def inherited_lines_block
-      @inherited_lines.join("\n").tap { |ret| pp ['LinkState.inherited_lines_block() ->', ret] if $pd }
+      (@inherited_lines || []).join("\n").tap { |ret|
+        pp ['LinkState.inherited_lines_block() ->', ret] if $pd
+      }
     end
 
     def inherited_lines_count
-      (@inherited_lines&.count || 0).tap { |ret| pp ['LinkState.inherited_lines_count() ->', ret] if $pd }
+      (@inherited_lines&.count || 0).tap { |ret|
+        pp ['LinkState.inherited_lines_count() ->', ret] if $pd
+      }
     end
 
     def inherited_lines_map
@@ -76,7 +88,9 @@ module MarkdownExec
     end
 
     def inherited_lines_present?
-      @inherited_lines.present?.tap { |ret| pp ['LinkState.inherited_lines_present?() ->', ret] if $pd }
+      @inherited_lines.present?.tap { |ret|
+        pp ['LinkState.inherited_lines_present?() ->', ret] if $pd
+      }
     end
   end
 

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.2.0'
+  VERSION = '2.4.0'
 end