markdown_exec 1.6 → 1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 97323ce7d6c677603ca89432c9ca64e45ff205a5b6cc03a71f4be1210bf8104a
-  data.tar.gz: ccce852fe96571b00c4443012371ea5ad29caec29dfdc9649cec7da2c091defe
+  metadata.gz: c4fdb41b414911d16030ffbfb8c4b07ca8c09e3684f21e123d0d99cd738dba3d
+  data.tar.gz: 70c1ec9fb9b795d0cbdcc87ceb03809a57af5901a70dc2b1d319c9451592d687
 SHA512:
-  metadata.gz: bc08d47d135d9a078240c6e3001322ec8b35b8fb4f7febeabec02729240d7524a40464d9d563aeb15e5c8d09695bd0b512251d970dfede46cf07bd377af72181
-  data.tar.gz: ec61f969d204b0216c02e2e13d270363aef35ecf3ad6ff5a26d653e2d5c8f1608ff3e70a24ab65ab3bd48d8c546e1a6c627734c8e03e08a2440c18b1d9db7fed
+  metadata.gz: abea63db83a4d785bce7c2ec1c9babebe6d78637872a068c4d6b2169832de8ea707a2c3ae426f6cd5ea548269194a797d95abdd7fceb286c4efa49da9d591bfe
+  data.tar.gz: 1b102cb3e898789d6ddf2a401f90cfee04403ea135a14a5067673b250855aef569ca3b39a171570930ef5946d52874d022fb19fd9cf7c1561737144aefc5ef3c

data/.rubocop.yml

@@ -14,9 +14,9 @@ Layout/LineContinuationLeadingSpace:
   Enabled: false
 
 Layout/LineLength:
-  Max: 72
+  # Max: 78
   # Max: 80
-  # Max: 96
+  Max: 96
 
 Lint/Debugger:
   Enabled: false
@@ -72,6 +72,9 @@ Style/FormatStringToken:
 Style/GlobalVars:
   Enabled: false
 
+Style/Lambda:
+  Enabled: false
+
 Style/MixinUsage:
   Enabled: false
 

data/Gemfile.lock

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

data/Rakefile

@@ -79,8 +79,10 @@ task :minitest do
   commands = [
     './lib/block_label.rb',
     './lib/cached_nested_file_reader.rb',
+    './lib/directory_searcher.rb',
     './lib/fcb.rb',
     './lib/filter.rb',
+    './lib/hash_delegator.rb',
     './lib/markdown_exec.rb',
     './lib/mdoc.rb',
     './lib/object_present.rb',

data/bin/tab_completion.sh

@@ -13,7 +13,7 @@ __filedirs_all()
 }
 
 _mde_echo_version() {
-  echo "1.6"
+  echo "1.8"
 }
 
 _mde() {
@@ -40,6 +40,14 @@ _mde() {
             
               -f) COMPREPLY="."; return 0 ;;
             
+              --find) COMPREPLY="''"; return 0 ;;
+            
+              -?) COMPREPLY="''"; return 0 ;;
+            
+              --how) COMPREPLY="''"; return 0 ;;
+            
+              -?) COMPREPLY="''"; return 0 ;;
+            
               --list-count) COMPREPLY="32"; return 0 ;;
             
               --output-execution-summary) COMPREPLY="0"; return 0 ;;
@@ -74,7 +82,7 @@ _mde() {
   # present matching option names
   #
   if [[ ${cur} == -* ]] ; then
-    opts=("--block-name" "--config" "--debug" "--exit" "--filename" "--help" "--list-blocks" "--list-count" "--list-default-env" "--list-default-yaml" "--list-docs" "--list-recent-output" "--list-recent-scripts" "--output-execution-summary" "--output-script" "--output-stdout" "--path" "--pwd" "--run-last-script" "--save-executed-script" "--save-execution-output" "--saved-script-folder" "--saved-stdout-folder" "--select-recent-output" "--select-recent-script" "--tab-completions" "--user-must-approve" "--version" "--display-level")
+    opts=("--block-name" "--config" "--debug" "--exit" "--filename" "--find" "--help" "--how" "--list-blocks" "--list-count" "--list-default-env" "--list-default-yaml" "--list-docs" "--list-recent-output" "--list-recent-scripts" "--output-execution-summary" "--output-script" "--output-stdout" "--path" "--pwd" "--run-last-script" "--save-executed-script" "--save-execution-output" "--saved-script-folder" "--saved-stdout-folder" "--select-recent-output" "--select-recent-script" "--tab-completions" "--user-must-approve" "--version" "--display-level")
     COMPREPLY=( $(compgen -W "$(printf "'%s' " "${opts[@]}")" -- "${cur}") )
 
     return 0
@@ -101,6 +109,14 @@ _mde() {
         
           -f) COMPREPLY=".RELATIVE_PATH."; return 0 ;;
         
+          --find) COMPREPLY=".FIND."; return 0 ;;
+        
+          -?) COMPREPLY=".FIND."; return 0 ;;
+        
+          --how) COMPREPLY=".HOW."; return 0 ;;
+        
+          -?) COMPREPLY=".HOW."; return 0 ;;
+        
           --list-count) COMPREPLY=".INT.1-."; return 0 ;;
         
           --output-execution-summary) COMPREPLY=".BOOL."; return 0 ;;
@@ -138,4 +154,4 @@ _mde() {
 
 complete -o filenames -o nospace -F _mde mde
 # _mde_echo_version
-# echo "Updated: 2023-11-13 16:19:21 UTC"
+# echo "Updated: 2023-12-11 19:58:50 UTC"

data/examples/colors.md

@@ -0,0 +1,48 @@
+# Demo configuring options
+
+::: These Opts blocks set the color for all elements.
+
+```opts :(document_options)
+```
+```opts :(default)
+exception_color_detail:                fg_rgbh_E0_E0_20  # Color of exception detail
+exception_color_name:                  fg_rgbh_E0_20_20  # Color of exception name
+execution_report_preview_frame_color:  fg_rgbh_20_80_80  # execution_report_preview_frame_color
+menu_bash_color:                       fg_rgbh_40_C0_F0  # Color of menu bash
+menu_chrome_color:                     fg_rgbh_80_80_20  # Color of menu chrome
+menu_divider_color:                    fg_rgbh_20_98_80  # Color of menu divider
+menu_link_color:                       fg_rgbh_20_E0_20  # Color of menu link
+menu_note_color:                       fg_rgbh_40_A0_A0  # Color of menu note
+menu_opts_color:                       fg_rgbh_E0_60_E0  # Color of menu opts
+menu_opts_set_color:                   fg_rgbh_E0_20_20  # Color of menu opts
+menu_task_color:                       fg_rgbh_A0_20_D0  # Color of menu task
+menu_vars_color:                       fg_rgbh_E0_80_20  # Color of menu vars
+menu_vars_set_color:                   fg_rgbh_E0_80_20  # Color of menu vars
+output_execution_label_name_color:     fg_rgbh_20_D8_80  # Color of output_execution_label_name
+output_execution_label_value_color:    fg_rgbh_20_E0_80  # Color of output_execution_label_value
+prompt_color_after_script_execution:   fg_rgbh_20_E8_80  # Color of prompt after script execution
+script_execution_frame_color:          fg_rgbh_20_80_80  # script_execution_frame_color
+script_preview_frame_color:            fg_rgbh_20_80_80  # Color of output divider
+warning_color:                         fg_rgbh_E0_E0_20  # Color of warning message
+```
+
+::: Example blocks
+
+```bash :Bash1
+```
+```link :Link1
+```
+```opts :Opts1
+```
+```port :Port1
+```
+```vars :Vars1
+```
+[ ] Task1
+blue;    fg_rgbh_00_00_FF
+green;   fg_rgbh_00_FF_00
+indigo;  fg_rgbh_4B_00_82
+orange;  fg_rgbh_FF_7F_00
+red;     fg_rgbh_FF_00_00
+violet;  fg_rgbh_94_00_D3
+yellow;  fg_rgbh_FF_FF_00

data/examples/import0.md

@@ -1,8 +1,44 @@
-```bash :01
-01
-```
+This is Page 0
+
 @import import1.md
-```bash :03
-03
+
+```opts :(document_options)
+user_must_approve: true
+```
+
+::: Page 0 code blocks
+
+```bash :page0_block1 +(page0_block2) +(page1_block2)
+echo "page 0 block 1 visible"
+# requires page 0 block 2
+# imports page 1
+# requires page 1 block 2
+```
+
+```bash :(page0_block2)
+echo "page 0 block 2 hidden"
 ```
 
+::: Control display of code blocks
+
+```opts :hide_imported_blocks
+menu_include_imported_blocks: false
+```
+
+```opts :show_imported_blocks
+menu_include_imported_blocks: true
+```
+
+::: Control display of notes
+
+```opts :hide_imported_notes
+menu_include_imported_notes: false
+```
+
+```opts :show_imported_notes
+menu_include_imported_notes: true
+```
+
+```link :page_1
+file: examples/import1.md
+```

data/examples/import1.md

@@ -1,10 +1,11 @@
-```bash :11
-11
-```
-```bash :12
-12
-```
-```bash:13
-13
+This is Page 1
+
+::: Page 1 code blocks
+
+```bash :page1_block1
+echo "page 1 block 1 visible"
 ```
 
+```bash :(page1_block2)
+echo "page 1 block 2 hidden"
+```

data/examples/include.md

@@ -1,12 +1,19 @@
 ```bash :(one)
-a
+echo block "one"
 ```
+
 ```bash :two +(one)
-b
+echo block "two" requires one
 ```
+
 ```bash :(three) +two +(one)
-c
+echo block "three" requires two and one
 ```
+
 ```bash :four +(three)
-d
+echo block "four" requires three
+```
+
+```bash :trigger_unmet_dependency +(unmet)
+echo block "five" requires an unmet dependency
 ```

data/examples/linked1.md

@@ -11,16 +11,20 @@ colorize_env_vars 'vars for page2' PAGE2_VAR_VIA_INHERIT page2_var_via_environme
 colorize_env_vars 'vars for page3' PAGE3_VAR_VIA_INHERIT page3_var_via_environment
 ```
 
+```bash :(vars2)
+PAGE2_VAR_VIA_INHERIT=for_page2_from_page1_via_inherited_code_file
+```
+
+```link :(linked2)
+file: examples/linked2.md
+```
+
 ::: This Link block
 ::: 1. requires a block that sets environment variable PAGE2_VAR_VIA_INHERIT,
 ::: 2. navigates to document 2, and
 ::: 3. executes block "show_vars" to display the imported PAGE2_VAR_VIA_INHERIT.
 ::: Any script generated by page 2 will contain the inherited code.
 
-```bash :(vars2)
-PAGE2_VAR_VIA_INHERIT=for_page2_from_page1_via_inherited_code_file
-```
-
 ```link :linked2_import_vars +(vars2)
 file: examples/linked2.md
 block: show_vars

data/examples/opts.md

@@ -19,4 +19,11 @@ menu_task_color: fg_rgb_127_127_255
 menu_divider_color: green
 menu_link_color: fg_rgbh_88_cc_66
 menu_note_color: yellow
+
+menu_note_match: "^\\s*(?<line>[^\\s/].*)\\s*$" # Pattern for notes in block selection menu; start with any char except '/'
 ```
+
+note 1
+note 2 ends with /
+ / note 3 starts with /
+note 4

data/lib/ansi_formatter.rb

@@ -0,0 +1,161 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# encoding=utf-8
+
+class AnsiFormatter
+  def initialize(options = {})
+    @options = options
+  end
+
+  def format_and_highlight_array(
+    data,
+    highlight_color_sym: :exception_color_detail,
+    plain_color_sym: :menu_chrome_color,
+    label: 'Data:',
+    highlight: [],
+    line_prefix: '  ',
+    line_postfix: '',
+    detail_sep: ''
+  )
+    (data&.map do |item|
+      scan_and_process_multiple_substrings(item, highlight, plain_color_sym,
+                                           highlight_color_sym).join
+      # color_sym = highlight.include?(item) ? highlight_color_sym : c
+      # string_send_color(item, color_sym)
+    end || []) #.join
+    # formatted_deps
+    # "#{line_prefix}#{string_send_color(label, highlight_color_sym)}#{line_postfix}\n" + formatted_deps.join("\n")
+  end
+
+  # Formats and highlights a list of data. data are presented with indentation,
+  # and specific items can be highlighted in a specified color, while others are shown in a plain color.
+  #
+  # @param data [Hash] A hash of data, where each key is a dependency name,
+  #        and its value is an array of sub-items.
+  # @param highlight_color_sym [Symbol] The color method to apply to highlighted items.
+  #        Default is :exception_color_detail.
+  # @param plain_color_sym [Symbol] The color method for non-highlighted items.
+  #        Default is :menu_chrome_color.
+  # @param label [String] The label to prefix the list of data with.
+  #        Default is 'data:'.
+  # @param highlight [Array] An array of items to highlight. Each item in this array will be
+  #        formatted with the specified highlight color.
+  # @param line_prefix [String] Prefix for each line. Default is '  '.
+  # @param line_postfix [String] Postfix for each line. Default is ''.
+  # @param detail_sep [String] Separator for items in the sub-list. Default is '  '.
+  # @return [String] A formatted string representation of the data with highlighted items.
+  def format_and_highlight_hash(
+    data,
+    highlight_color_sym: :exception_color_detail,
+    plain_color_sym: :menu_chrome_color,
+    label: 'Data:',
+    highlight: [],
+    line_prefix: '  ',
+    line_postfix: '',
+    detail_sep: '  '
+  )
+    formatted_deps = data&.map do |dep_name, sub_items|
+      formatted_sub_items = sub_items.map do |item|
+        color_sym = highlight.include?(item) ? highlight_color_sym : plain_color_sym
+        string_send_color(item, color_sym)
+      end.join(detail_sep)
+
+      "#{line_prefix}- #{string_send_color(dep_name,
+                                           highlight.include?(dep_name) ? highlight_color_sym : plain_color_sym)}: #{formatted_sub_items}#{line_postfix}"
+    end || []
+
+    "#{line_prefix}#{string_send_color(label,
+                                       highlight_color_sym)}#{line_postfix}\n" + formatted_deps.join("\n")
+  end
+
+  # Function to scan a string and process its segments based on multiple substrings
+  # @param str [String] The string to scan.
+  # @param substrings [Array<String>] The substrings to match in the string.
+  # @param plain_sym [Symbol] The symbol for non-matching segments.
+  # @param color_sym [Symbol] The symbol for matching segments.
+  # @return [Array<String>] The processed segments.
+  def scan_and_process_multiple_substrings(str, substrings, plain_sym, color_sym)
+    return string_send_color(str, plain_sym) if substrings.empty? || substrings.any?(&:empty?)
+
+    results = []
+    remaining_str = str.dup
+
+    while remaining_str.length.positive?
+      match_indices = substrings.map { |substring| remaining_str.index(substring) }.compact
+      earliest_match = match_indices.min
+
+      if earliest_match
+        # Process non-matching segment before the earliest match, if any
+        unless earliest_match.zero?
+          non_matching_segment = remaining_str.slice!(0...earliest_match)
+          results << string_send_color(non_matching_segment, plain_sym)
+        end
+
+        # Find which substring has this earliest match
+        matching_substring = substrings.find do |substring|
+          remaining_str.index(substring) == earliest_match
+        end
+
+        if matching_substring
+          matching_segment = remaining_str.slice!(0...matching_substring.length)
+          results << string_send_color(matching_segment, color_sym)
+        end
+      else
+        # Process the remaining non-matching segment
+        results << string_send_color(remaining_str, plain_sym)
+        break
+      end
+    end
+
+    results
+  end
+
+  # Function to scan a string and process its segments
+  # @param str [String] The string to scan.
+  # @param substring [String] The substring to match in the string.
+  # @param plain_sym [Symbol] The symbol for non-matching segments.
+  # @param color_sym [Symbol] The symbol for matching segments.
+  # @return [Array<String>] The processed segments.
+  def scan_and_process_string(str, substring, plain_sym, color_sym)
+    return string_send_color(str, plain_sym) unless substring.present?
+
+    results = []
+    remaining_str = str.dup
+
+    while remaining_str.length.positive?
+      match_index = remaining_str.index(substring)
+      if match_index
+        # Process non-matching segment before the match, if any
+        unless match_index.zero?
+          non_matching_segment = remaining_str.slice!(0...match_index)
+          results << string_send_color(non_matching_segment, plain_sym)
+        end
+
+        # Process the matching segment
+        matching_segment = remaining_str.slice!(0...substring.length)
+        results << string_send_color(matching_segment, color_sym)
+      else
+        # Process the remaining non-matching segment
+        results << string_send_color(remaining_str, plain_sym)
+        break
+      end
+    end
+
+    results
+  end
+
+  # # Example usage
+  # scan_and_process_string("Hello world, hello universe", "hello", :plain, :color)
+
+  # Applies a color method to a string based on the provided color symbol.
+  # The color method is fetched from @options and applied to the string.
+  # @param string [String] The string to which the color will be applied.
+  # @param color_sym [Symbol] The symbol representing the color method.
+  # @param default [String] Default color method to use if color_sym is not found in @options.
+  # @return [String] The string with the applied color method.
+  def string_send_color(string, color_sym, default: 'plain')
+    color_method = @options.fetch(color_sym, default).to_sym
+    string.to_s.send(color_method)
+  end
+end

data/lib/array.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# encoding=utf-8
+
+class Array
+  # Processes each element of the array, yielding the previous, current, and next elements to the given block.
+  # Deletes the current element if the block returns true.
+  # @return [Array] The modified array after conditional deletions.
+  def process_and_conditionally_delete!
+    i = 0
+    while i < length
+      prev_item = self[i - 1] unless i.zero?
+      current_item = self[i]
+      next_item = self[i + 1]
+
+      should_delete = yield prev_item, current_item, next_item
+      if should_delete
+        delete_at(i)
+      else
+        i += 1
+      end
+    end
+
+    self
+  end
+end

data/lib/array_util.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# encoding=utf-8
+
+module ArrayUtil
+  def self.partition_by_predicate(arr)
+    true_list = []
+    false_list = []
+
+    arr.each do |element|
+      if yield(element)
+        true_list << element
+      else
+        false_list << element
+      end
+    end
+
+    [true_list, false_list]
+  end
+end

data/lib/cached_nested_file_reader.rb

@@ -5,6 +5,16 @@
 
 # version 2023-10-03
 
+require 'fileutils'
+require_relative 'exceptions'
+
+# a struct to hold the data for a single line
+NestedLine = Struct.new(:text, :depth) do
+  def to_s
+    text
+  end
+end
+
 ##
 # The CachedNestedFileReader class provides functionality to read file lines with the ability
 # to process '#import filename' directives. When such a directive is encountered in a file,
@@ -13,42 +23,58 @@
 # It allows clients to read lines with or without providing a block.
 #
 class CachedNestedFileReader
+  include Exceptions
+
   def initialize(import_pattern: /^ *#import (.+)$/)
     @file_cache = {}
     @import_pattern = import_pattern
   end
 
-  def readlines(filename, &block)
+  def error_handler(name = '', opts = {})
+    Exceptions.error_handler(
+      "CachedNestedFileReader.#{name} -- #{$!}",
+      opts
+    )
+  end
+
+  def warn_format(name, message, opts = {})
+    Exceptions.warn_format(
+      "CachedNestedFileReader.#{name} -- #{message}",
+      opts
+    )
+  end
+
+  def readlines(filename, depth = 0, &block)
     if @file_cache.key?(filename)
-      @file_cache[filename].each(&block) if block_given?
+      @file_cache[filename].each(&block) if block
       return @file_cache[filename]
     end
 
     directory_path = File.dirname(filename)
-    lines = File.readlines(filename, chomp: true)
+    # lines = File.readlines(filename, chomp: true)
     processed_lines = []
 
-    lines.each do |line|
-      if (match = line.match(@import_pattern))
-        included_file_path = if match[1].strip.match %r{^/}
-                               match[1].strip
+    File.readlines(filename, chomp: true).each do |line|
+      if Regexp.new(@import_pattern) =~ line
+        name_strip = $~[:name].strip
+        included_file_path = if name_strip =~ %r{^/}
+                               name_strip
                              else
-                               File.join(directory_path, match[1].strip)
+                               File.join(directory_path, name_strip)
                              end
-        processed_lines += readlines(included_file_path, &block)
+        processed_lines += readlines(included_file_path, depth + 1,
+                                     &block)
       else
-        processed_lines.push(line)
-        yield line if block_given?
+        nested_line = NestedLine.new(line, depth)
+        processed_lines.push(nested_line)
+        block&.call(nested_line)
       end
     end
 
     @file_cache[filename] = processed_lines
-  end
-
-  private
-
-  def fetch_lines(filename)
-    @fetch_lines_cache[filename] ||= File.readlines(filename, chomp: true)
+  rescue Errno::ENOENT
+    # Exceptions.error_handler('readlines', { abort: true })
+    warn_format('readlines', "No such file -- #{filename}", { abort: true })
   end
 end
 
@@ -56,10 +82,6 @@ if $PROGRAM_NAME == __FILE__
   require 'minitest/autorun'
   require 'tempfile'
 
-  ##
-  # The CachedNestedFileReaderTest class provides testing for
-  # the CachedNestedFileReader class.
-  #
   class CachedNestedFileReaderTest < Minitest::Test
     def setup
       @file2 = Tempfile.new('test2.txt')
@@ -69,7 +91,7 @@ if $PROGRAM_NAME == __FILE__
       @file1 = Tempfile.new('test1.txt')
       @file1.write("Line1\nLine2\n #insert #{@file2.path}\nLine3")
       @file1.rewind
-      @reader = CachedNestedFileReader.new(import_pattern: /^ *#insert (.+)$/)
+      @reader = CachedNestedFileReader.new(import_pattern: /^ *#insert (?'name'.+)$/)
     end
 
     def teardown
@@ -81,28 +103,26 @@ if $PROGRAM_NAME == __FILE__
     end
 
     def test_readlines_without_imports
-      result = []
-      @reader.readlines(@file2.path) { |line| result << line }
+      result = @reader.readlines(@file2.path).map(&:to_s)
       assert_equal %w[ImportedLine1 ImportedLine2], result
     end
 
     def test_readlines_with_imports
-      result = []
-      @reader.readlines(@file1.path) { |line| result << line }
-      assert_equal %w[Line1 Line2 ImportedLine1 ImportedLine2 Line3], result
+      result = @reader.readlines(@file1.path).map(&:to_s)
+      assert_equal %w[Line1 Line2 ImportedLine1 ImportedLine2 Line3],
+                   result
     end
 
     def test_caching_functionality
       # First read
-      result1 = []
-      @reader.readlines(@file2.path) { |line| result1 << line }
+
+      result1 = @reader.readlines(@file2.path).map(&:to_s)
 
       # Simulate file content change
       @file2.reopen(@file2.path, 'w') { |f| f.write('ChangedLine') }
 
       # Second read (should read from cache, not the changed file)
-      result2 = []
-      @reader.readlines(@file2.path) { |line| result2 << line }
+      result2 = @reader.readlines(@file2.path).map(&:to_s)
 
       assert_equal result1, result2
       assert_equal %w[ImportedLine1 ImportedLine2], result2