markdown_exec 2.2.0 → 2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 32532369e9eec3574b8bff6d6c79097f547e120c7b113c10a765364e20a311a4
-  data.tar.gz: 3773bab7197401361c06bace1921663679bbf53d77f2cbe5daa1c2975c091e87
+  metadata.gz: 40813cfbaca2f9b2e8b865e2f574ab71211c56120d5706d2f8ebc4fbb103d254
+  data.tar.gz: 880d121d18747d2370dff0caa90f84da9fca51633ec6e00919f690ea4821d1f0
 SHA512:
-  metadata.gz: e6ad41fdae333916ef13870498b6b1b9be7338af8ae39238b4a16a475b42430cb9282c59dbcecd124f422ab218848a70611ce6120e03074660a213a89e054df1
-  data.tar.gz: f9ef27a86c8a7cb4e15b4eb59705d1fdad6a15b8c6af176978b09f1108599569e0f74423b89c1baaa2cfaed249a4ff37fb18c8e7c6c87220d0ecb48a5e4cdd45
+  metadata.gz: df8c99ddc62b271b1fa74036ffcb485411a1461195d68c2e1825ae3ba606e4b20de456636d0094606c4579548d4532dd46287c5c486b4ab613217ab708144709
+  data.tar.gz: 4b812fa4808161beaa06c3de9b0639a031446294bb8a171d599e5baa4db157660233701c1068a130c93dfbd4cd0469853867cf4c751dfda4197ffb13ee81899a

data/.rubocop.yml

@@ -15,8 +15,8 @@ Layout/LineContinuationLeadingSpace:
 
 Layout/LineLength:  # 2024-01-21 temp disable
   # Enabled: false
-  # Max: 80
-  Max: 96
+  Max: 80
+  # Max: 96
   # Max: 120
 
 Lint/Debugger:
@@ -88,6 +88,9 @@ Style/FormatStringToken:
 Style/GlobalVars:
   Enabled: false
 
+Style/IfUnlessModifier: # 2024-08 suggests lines that are too long
+  Enabled: false
+
 Style/Lambda:
   Enabled: false
 

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## [2.3.0] - 2024-08-05
+
+### Added
+
+- In-line decoration of text
+- ANSI graphics modes for text decoration.
+- Translation from text to ANSI graphics.
+- Options for decorations in three stages, with default (Main) in the middle.
+
 ## [2.2.0] - 2024-07-27
 
 ### Added

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    markdown_exec (2.2.0)
+    markdown_exec (2.3.0)
       clipboard (~> 1.3.6)
       open3 (~> 0.1.1)
       optparse (~> 0.1.1)

data/bin/tab_completion.sh

@@ -13,7 +13,7 @@ __filedirs_all()
 }
 
 _mde_echo_version() {
-  echo "2.2.0"
+  echo "2.3.0"
 }
 
 _mde() {

data/examples/block-names.md

@@ -1,8 +1,32 @@
 ## Demonstrate handling of special characters in block names
-The hidden block "(success)" is required below. It prints "Success".
-```bash :(success)
-echo "Success"
-```
+
+::: Click below to trigger. If it prints "1","2","3","4", the Link blocks were required.
+Long block names can be required by a Bash block.
+    ```bash :calling-block +long_block_name_12345678901234567890123456789012345678901234567890 +(long_block_name_12345678901234567890123456789012345678901234567890) +[long_block_name_12345678901234567890123456789012345678901234567890]
+    echo '1'
+    ```
+Long block names can be used in Link blocks.
+    ```link
+    block: long_block_name_12345678901234567890123456789012345678901234567890
+    ```
+    ```link
+    block: "(long_block_name_12345678901234567890123456789012345678901234567890)"
+    ```
+    ```link
+    block: "[long_block_name_12345678901234567890123456789012345678901234567890]"
+    ```
+
+    Do not call these blocks directly.
+        ```bash :long_block_name_12345678901234567890123456789012345678901234567890
+        echo '2'
+        ```
+        ```bash :(long_block_name_12345678901234567890123456789012345678901234567890)
+        echo '3'
+        ```
+        ```bash :[long_block_name_12345678901234567890123456789012345678901234567890]
+        echo '4'
+        ```
+
 Block names with all chars.
 / UTF-8
 /   !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
@@ -25,3 +49,14 @@ The un-named block should display correctly.
     vars:
       page2_var_via_environment: for_page2_from_page1_via_current_environment
     ```
+The hidden block "(success)" is required above. It prints "Success".
+```bash :(success)
+echo "Success"
+```
+
+```opts :(document_options)
+execute_in_own_window: false
+output_execution_report: false
+output_execution_summary: false
+pause_after_script_execution: true
+```

data/lib/colorize.rb

@@ -101,4 +101,17 @@ class String
   def red;     fg_rgbh_FF_00_00; end
   def violet;  fg_rgbh_94_00_D3; end
   def yellow;  fg_rgbh_FF_FF_00; end
+
+  # graphics modes
+  def bold;             "\033[1m#{self}\033[22m"; end
+  def bold_italic;      "\033[1m\033[3m#{self}\033[22m\033[23m"; end
+  def bold_underline;   "\033[1m\033[4m#{self}\033[22m\033[24m"; end
+  def dim;              "\033[2m#{self}\033[22m"; end
+  def italic;           "\033[3m#{self}\033[23m"; end
+  def underline;        "\033[4m#{self}\033[24m"; end
+  def underline_italic; "\033[4m\033[3m#{self}\033[23m\033[24m"; end
+  def blinking;         "\033[5m#{self}\033[25m"; end
+  def inverse;          "\033[7m#{self}\033[27m"; end
+  def hidden;           "\033[8m#{self}\033[28m"; end
+  def strikethrough;    "\033[9m#{self}\033[29m"; end
 end

data/lib/hash_delegator.rb

@@ -29,6 +29,7 @@ require_relative 'fcb'
 require_relative 'filter'
 require_relative 'fout'
 require_relative 'hash'
+require_relative 'hierarchy_string'
 require_relative 'link_history'
 require_relative 'mdoc'
 require_relative 'namer'
@@ -37,6 +38,7 @@ require_relative 'resize_terminal'
 require_relative 'std_out_err_logger'
 require_relative 'streams_out'
 require_relative 'string_util'
+require_relative 'text_analyzer'
 
 $pd = false unless defined?($pd)
 
@@ -482,6 +484,7 @@ module MarkdownExec
 
     extend HashDelegatorSelf
     include CompactionHelpers
+    include TextAnalyzer
 
     def initialize(delegate_object = {})
       @delegate_object = delegate_object
@@ -668,6 +671,16 @@ module MarkdownExec
       end
     end
 
+    def apply_tree_decorations(text, color_method, decor_patterns)
+      tree = HierarchyString.new([{ text: text, color: color_method }])
+      decor_patterns.each do |pc|
+        analyzed_hierarchy = TextAnalyzer.analyze_hierarchy(tree.substrings, pc[:pattern],
+                                                            color_method, pc[:color_method])
+        tree = HierarchyString.new(analyzed_hierarchy)
+      end
+      tree.decorate
+    end
+
     def assign_key_value_in_bash(key, value)
       if value =~ /["$\\`]/
         # requiring ShellWords to write into Bash scripts
@@ -685,6 +698,7 @@ module MarkdownExec
     # @return [Array<FCB>] An array of FCB objects representing the blocks.
     def blocks_from_nested_files
       register_console_attributes(@delegate_object)
+      @decor_patterns_from_delegate_object_for_block_create = collect_line_decor_patterns(@delegate_object)
 
       blocks = []
       iter_blocks_from_nested_files do |btype, fcb|
@@ -700,9 +714,7 @@ module MarkdownExec
     # if matched, the block returned has properties that it is from cli and not ui
     def block_state_for_name_from_cli(block_name)
       SelectedBlockMenuState.new(
-        @dml_blocks_in_file.find do |item|
-          block_name == item.pub_name
-        end,
+        blocks_find_by_block_name(@dml_blocks_in_file, block_name),
         OpenStruct.new(
           block_name_from_cli: true,
           block_name_from_ui: false
@@ -711,6 +723,14 @@ module MarkdownExec
       )
     end
 
+    def blocks_find_by_block_name(blocks, block_name)
+      @dml_blocks_in_file.find do |item|
+        # 2024-08-04 match oname for long block names
+        # 2024-08-04 match nickname for long block names
+        block_name == item.pub_name || block_name == item.nickname || block_name == item.oname
+      end
+    end
+
     # private
 
     def calc_logged_stdout_filename(block_name:)
@@ -752,6 +772,23 @@ module MarkdownExec
       true
     end
 
+    def collect_line_decor_patterns(delegate_object)
+      extract_patterns = lambda do |key|
+        return [] unless delegate_object[key].present?
+
+        HashDelegator.safeval(delegate_object[key]).map do |pc|
+          {
+            color_method: pc[:color_method].to_sym,
+            pattern: Regexp.new(pc[:pattern])
+          }
+        end
+      end
+
+      %i[line_decor_pre line_decor_main line_decor_post].flat_map do |key|
+        extract_patterns.call(key)
+      end
+    end
+
     # Collects required code lines based on the selected block and the delegate object's configuration.
     # If the block type is VARS, it also sets environment variables based on the block's content.
     #
@@ -920,6 +957,7 @@ module MarkdownExec
                                     format_option:, color_method:,
                                     case_conversion: nil,
                                     center: nil,
+                                    decor_patterns: [],
                                     wrap: nil)
       line_cap = match_data.named_captures.transform_keys(&:to_sym)
 
@@ -970,11 +1008,14 @@ module MarkdownExec
         # format expects :line to be text only
         line_obj[:line] = line_obj[:text]
         oname = format(format_option, line_obj)
+
+        decorated = apply_tree_decorations(oname, color_method, decor_patterns)
+
         line_obj[:line] = line_obj[:indent] + line_obj[:text]
         blocks.push FCB.new(
           chrome: true,
           disabled: '',
-          dname: line_obj[:indent] + oname.send(color_method),
+          dname: line_obj[:indent] + decorated,
           oname: line_obj[:text]
         )
       end
@@ -988,6 +1029,7 @@ module MarkdownExec
     # @param opts [Hash] Options containing configuration for line processing.
     # @param use_chrome [Boolean] Indicates if the chrome styling should be applied.
     def create_and_add_chrome_blocks(blocks, fcb)
+      # rubocop:disable Layout/LineLength
       match_criteria = [
         { color: :menu_heading1_color, format: :menu_heading1_format, match: :heading1_match, center: true, case_conversion: :upcase, wrap: true },
         { color: :menu_heading2_color, format: :menu_heading2_format, match: :heading2_match, center: true, wrap: true },
@@ -996,6 +1038,7 @@ module MarkdownExec
         { color: :menu_note_color,     format: :menu_note_format,     match: :menu_note_match, wrap: true },
         { color: :menu_task_color,     format: :menu_task_format,     match: :menu_task_match, wrap: true }
       ]
+      # rubocop:enable Layout/LineLength
       # rubocop:enable Style/UnlessElse
       match_criteria.each do |criteria|
         unless @delegate_object[criteria[:match]].present? &&
@@ -1008,6 +1051,7 @@ module MarkdownExec
           case_conversion: criteria[:case_conversion],
           center: criteria[:center],
           color_method: @delegate_object[criteria[:color]].to_sym,
+          decor_patterns: @decor_patterns_from_delegate_object_for_block_create,
           format_option: @delegate_object[criteria[:format]],
           match_data: mbody,
           wrap: criteria[:wrap]
@@ -1224,9 +1268,8 @@ module MarkdownExec
         when :user_choice
           if @dml_link_state.block_name.present?
             # @prior_block_was_link = true
-            @dml_block_state.block = @dml_blocks_in_file.find do |item|
-              item.pub_name == @dml_link_state.block_name || item.oname == @dml_link_state.block_name
-            end
+            @dml_block_state.block = blocks_find_by_block_name(@dml_blocks_in_file,
+                                                               @dml_link_state.block_name)
             @dml_link_state.block_name = nil
           else
             # puts "? - Select a block to execute (or type #{$texit} to exit):"
@@ -2433,8 +2476,7 @@ module MarkdownExec
         %i[blocks line]
       when :line
         unless @delegate_object[:no_chrome]
-          create_and_add_chrome_blocks(blocks,
-                                       fcb)
+          create_and_add_chrome_blocks(blocks, fcb)
         end
       end
     end
@@ -3496,7 +3538,8 @@ module MarkdownExec
 
       def test_block_find_with_default
         blocks = [FCB.new(text: 'value1'), FCB.new(text: 'value2')]
-        result = HashDelegator.block_find(blocks, :text, 'missing_value', 'default')
+        result = HashDelegator.block_find(blocks, :text, 'missing_value',
+                                          'default')
         assert_equal 'default', result
       end
     end

data/lib/hierarchy_string.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+# Class representing a hierarchy of substrings stored as Hash nodes
+class HierarchyString
+  attr_accessor :substrings
+
+  # Initialize with a single hash or an array of hashes
+  def initialize(substrings)
+    @substrings = parse_substrings(substrings)
+  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]
+      tree[:text] = 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]
+        node[:text] = 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]
+      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[:color]
+          s[:text].send(s[:color]) + prior_color
+        else
+          s[:text]
+        end
+      when Array
+        decorate_substrings(s, prior_color)
+      end
+    end.join
+  end
+end
+
+return if $PROGRAM_NAME != __FILE__
+
+# require 'bundler/setup'
+# Bundler.require(:default)
+
+# require 'fcb'
+# require 'minitest/autorun'
+
+# Usage
+hierarchy = HierarchyString.new([{ text: 'Hello ', color: :red },
+                                 [{ text: 'World', color: :upcase },
+                                  { text: '!' }]])
+puts hierarchy.decorate
+puts hierarchy.length
+# puts hierarchy.concatenate           # Outputs: Hello World!
+# puts hierarchy.upcase                # Outputs: HELLO WORLD!
+# puts hierarchy.length                # Outputs: 12
+# puts hierarchy.gsub('World', 'Ruby') # Outputs: Hello Ruby!

data/lib/input_sequencer.rb

@@ -79,7 +79,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'
 
@@ -92,7 +93,8 @@ class InputSequencer
         choice = run_yield :user_choice, &block
 
         raise 'Block not recognized.' if choice.nil?
-        break if run_yield(:exit?, choice&.downcase, &block) # Exit loop and method to terminate the app
+        # Exit loop and method to terminate the app
+        break if run_yield(:exit?, choice&.downcase, &block)
 
         next_state = run_yield :execute_block, choice, &block
         # imw_ins next_state, 'next_state'

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.3.0'
 end

data/lib/markdown_exec.rb

@@ -125,7 +125,10 @@ module MarkdownExec
       return if max <= min # Ensure the range is valid
 
       # Normalize the value within the range 0 to 1
-      normalized_value = [0, [(integer_value - min).to_f / (max - min), 1].min].max
+      normalized_value = [
+        0,
+        [(integer_value - min).to_f / (max - min), 1].min
+      ].max
 
       # Calculate how many characters should be filled
       filled_length = (normalized_value * width).round
@@ -146,11 +149,13 @@ module MarkdownExec
       @o_color = :red
     end
 
-    def build_menu(file_names, directory_names, found_in_block_names, files_in_directories, vbn)
+    def build_menu(file_names, directory_names, found_in_block_names,
+                   files_in_directories, vbn)
       choices = []
 
       # Adding section title and data for file names
-      choices << { disabled: '', name: "in #{file_names[:section_title]}".send(@chrome_color) }
+      choices << { disabled: '',
+                   name: "in #{file_names[:section_title]}".send(@chrome_color) }
       choices += file_names[:data].map { |str| FileInMenu.for_menu(str) }
 
       # Conditionally add directory names if data is present
@@ -464,7 +469,8 @@ module MarkdownExec
                                                                   :menu_chrome_color)}"
       searcher = SearchResultsReport.new(value, [find_path])
       file_names = searcher.file_names(options, value)
-      found_in_block_names = searcher.found_in_block_names(options, value, formspec: '%<line>s')
+      found_in_block_names = searcher.found_in_block_names(options, value,
+                                                           formspec: '%<line>s')
       directory_names = searcher.directory_names(options, value)
 
       ### search in file contents (block names, chrome, or text)
@@ -498,9 +504,10 @@ module MarkdownExec
           details,
           highlight: [value]
         )
-        [FileInMenu.for_menu(filename)] + nexo.map do |str|
-                                            { disabled: '', name: (' ' * 20) + str }
-                                          end
+        [FileInMenu.for_menu(filename)] +
+          nexo.map do |str|
+            { disabled: '', name: (' ' * 20) + str }
+          end
       end.flatten
 
       choices = MenuBuilder.new.build_menu(file_names, directory_names, found_in_block_names,

data/lib/mdoc.rb

@@ -87,11 +87,11 @@ module MarkdownExec
       all_dependency_names = collect_unique_names(dependencies).push(nickname).uniq
       # &bt all_dependency_names.count
 
-      # select non-chrome blocks in order of appearance in source documents
+      # select blocks in order of appearance in source documents
       #
       blocks = @table.select do |fcb|
-        # !fcb.fetch(:chrome, false) && all_dependency_names.include?(fcb.pub_name)
-        all_dependency_names.include?(fcb.pub_name)
+        # 2024-08-04 match nickname
+        all_dependency_names.include?(fcb.pub_name) || all_dependency_names.include?(fcb.nickname) || all_dependency_names.include?(fcb.oname)
       end
       # &bt blocks.count
 
@@ -99,7 +99,9 @@ module MarkdownExec
       #
       unmet_dependencies = all_dependency_names.dup
       blocks = blocks.map do |fcb|
-        unmet_dependencies.delete(fcb.pub_name) # may not exist if block name is duplicated
+        # 2024-08-04 match oname for long block names
+        # 2024-08-04 match nickname
+        unmet_dependencies.delete(fcb.pub_name) || unmet_dependencies.delete(fcb.nickname) || unmet_dependencies.delete(fcb.oname) # may not exist if block name is duplicated
         if (call = fcb.call)
           [get_block_by_anyname("[#{call.match(/^%\((\S+) |\)/)[1]}]")
             .merge({ cann: call })]
@@ -262,7 +264,8 @@ module MarkdownExec
     #   and `label_format_below` is "End of %{block_name}", the method will return:
     #     ["Start of Example_Block", "line1", "line2", "End of Example_Block"]
     #
-    def generate_label_body_code(fcb, block_source, label_format_above, label_format_below)
+    def generate_label_body_code(fcb, block_source, label_format_above,
+                                 label_format_below)
       block_name_for_bash_comment = fcb.pub_name.gsub(/\s+/, '_')
 
       label_above = if label_format_above
@@ -387,7 +390,9 @@ module MarkdownExec
 
       memo[source] = block.reqs
 
-      block.reqs.each { |req| collect_dependencies(req, memo) unless memo.key?(req) }
+      block.reqs.each do |req|
+        collect_dependencies(req, memo) unless memo.key?(req)
+      end
       memo
     end
 
@@ -456,7 +461,9 @@ if $PROGRAM_NAME == __FILE__
 
       if false # must raise error
         def test_collect_dependencies_with_nonexistent_source
-          assert_raises(RuntimeError) { @mdoc.collect_dependencies('nonexistent') }
+          assert_raises(RuntimeError) do
+            @mdoc.collect_dependencies('nonexistent')
+          end
         end
       end
 

data/lib/menu.src.yml

@@ -397,6 +397,43 @@
   :opt_name: import_pattern
   :procname: val_as_str
 
+- :default:
+    - :color_method: :bold_underline
+      :pattern: '\*\*_([^_]{0,64})_\*\*'
+
+    - :color_method: :bold_italic
+      :pattern: '\*\*~([^~]{0,64})~\*\*'
+
+    - :color_method: :bold
+      :pattern: '\*\*([^*]{0,64})\*\*'
+    - :color_method: :bold
+      :pattern: '__([^_]{0,64})__'
+
+    - :color_method: :underline
+      :pattern: '\*([^*]{0,64})\*'
+
+    - :color_method: :underline_italic
+      :pattern: '_~([^_]{0,64})~_'
+
+    - :color_method: strikethrough
+      :pattern: '~~([^~]{0,64})~~'
+  :description: Line-oriented text decoration (Main)
+  :env_var: MDE_LINE_DECOR_MAIN
+  :opt_name: line_decor_main
+  :procname: val_as_str
+
+- :default: []
+  :description: Line-oriented text decoration (Post)
+  :env_var: MDE_LINE_DECOR_POST
+  :opt_name: line_decor_post
+  :procname: val_as_str
+
+- :default: []
+  :description: Line-oriented text decoration (Pre)
+  :env_var: MDE_LINE_DECOR_PRE
+  :opt_name: line_decor_pre
+  :procname: val_as_str
+
 - :description: List blocks
   :long_name: list-blocks
   :opt_name: list_blocks

data/lib/menu.yml

@@ -339,6 +339,35 @@
   :env_var: MDE_IMPORT_PATTERN
   :opt_name: import_pattern
   :procname: val_as_str
+- :default:
+  - :color_method: :bold_underline
+    :pattern: "\\*\\*_([^_]{0,64})_\\*\\*"
+  - :color_method: :bold_italic
+    :pattern: "\\*\\*~([^~]{0,64})~\\*\\*"
+  - :color_method: :bold
+    :pattern: "\\*\\*([^*]{0,64})\\*\\*"
+  - :color_method: :bold
+    :pattern: __([^_]{0,64})__
+  - :color_method: :underline
+    :pattern: "\\*([^*]{0,64})\\*"
+  - :color_method: :underline_italic
+    :pattern: _~([^_]{0,64})~_
+  - :color_method: strikethrough
+    :pattern: "~~([^~]{0,64})~~"
+  :description: Line-oriented text decoration (Main)
+  :env_var: MDE_LINE_DECOR_MAIN
+  :opt_name: line_decor_main
+  :procname: val_as_str
+- :default: []
+  :description: Line-oriented text decoration (Post)
+  :env_var: MDE_LINE_DECOR_POST
+  :opt_name: line_decor_post
+  :procname: val_as_str
+- :default: []
+  :description: Line-oriented text decoration (Pre)
+  :env_var: MDE_LINE_DECOR_PRE
+  :opt_name: line_decor_pre
+  :procname: val_as_str
 - :description: List blocks
   :long_name: list-blocks
   :opt_name: list_blocks

data/lib/text_analyzer.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module TextAnalyzer
+  # Analyzes a hierarchical structure (String or Array) and highlights segments based on the pattern
+  #
+  # @param hierarchy [String, Array] the hierarchical structure to be analyzed
+  # @param pattern [Regexp] the pattern to match against the text
+  # @param default_color [String] the color for non-matching segments
+  # @param match_color [String] the color for matching segments
+  #
+  # @return [Array<Hash>, Array<Array<Hash>>] an array or nested arrays of highlighted segments
+  #
+  # @raise [ArgumentError] if the hierarchy structure is neither a String nor an Array
+  def self.analyze_hierarchy(hierarchy, pattern, default_color, match_color)
+    case hierarchy
+    when String
+      highlight_segments(hierarchy, pattern, default_color, match_color)
+    when Hash
+      decorated = highlight_segments(hierarchy[:text], pattern,
+                                     hierarchy[:color], match_color)
+
+      case decorated
+      when String
+        hierarchy
+      when Array
+        if decorated.length == 1
+          hierarchy
+        else
+          decorated
+        end
+      else
+        decorated
+      end
+    when Array
+      hierarchy.map do |element|
+        analyze_hierarchy(element, pattern, default_color, match_color)
+      end
+    when HierarchyString
+
+      hierarchy.replace_text! do |substring|
+        substring ### no change
+      end
+
+    else
+      binding.irb
+      raise ArgumentError, 'Invalid hierarchy structure'
+    end
+  end
+
+  # Highlights segments of the text based on the pattern
+  #
+  # @param text [String] the text to be analyzed
+  # @param pattern [Regexp] the pattern to match against the text
+  # @param default_color [String] the color for non-matching segments
+  # @param match_color [String] the color for matching segments
+  #
+  # @return [Array<Hash>] an array of hashes, each containing a segment of text and its corresponding color
+  def self.highlight_segments(text, pattern, default_color, match_color)
+    segments = []
+
+    yield_matches_and_non_matches(text, pattern) do |segment, is_match|
+      segments << if is_match
+                    { text: segment, color: match_color }
+                  else
+                    { text: segment, color: default_color }
+                  end
+    end
+
+    segments
+  end
+
+  # Yields matching and non-matching segments of the text based on the pattern
+  #
+  # @param text [String] the text to be analyzed
+  # @param pattern [Regexp] the pattern to match against the text
+  #
+  # @yieldparam segment [String] a segment of the text
+  # @yieldparam is_match [Boolean] true if the segment matches the pattern, false otherwise
+  def self.yield_matches_and_non_matches(text, pattern)
+    last_end = 0
+
+    text.scan(pattern) do |match|
+      match_start = Regexp.last_match.begin(0)
+      match_end = Regexp.last_match.end(0)
+
+      # Yield the non-matching segment before the match
+      yield text[last_end...match_start], false if match_start > last_end
+
+      # Yield the matching segment
+      yield match.first, true
+
+      last_end = match_end
+    end
+
+    # Yield any remaining non-matching segment after the last match
+    return unless last_end < text.length
+
+    yield text[last_end..-1], false
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: markdown_exec
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 2.3.0
 platform: ruby
 authors:
 - Fareed Stevenson
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-08-04 00:00:00.000000000 Z
+date: 2024-08-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: clipboard
@@ -171,6 +171,7 @@ files:
 - lib/fout.rb
 - lib/hash.rb
 - lib/hash_delegator.rb
+- lib/hierarchy_string.rb
 - lib/input_sequencer.rb
 - lib/instance_method_wrapper.rb
 - lib/link_history.rb
@@ -193,6 +194,7 @@ files:
 - lib/streams_out.rb
 - lib/string_util.rb
 - lib/tap.rb
+- lib/text_analyzer.rb
 homepage: https://rubygems.org/gems/markdown_exec
 licenses:
 - MIT