markdown_exec 2.3.0 → 2.4.0

data/examples/text-markup.md

@@ -0,0 +1,58 @@
+# Demonstrate Decoration of Text
+
+## LINE_DECOR_MAIN
+These are the Main decorations predefined:
+
+- **_Bold-Underline_**
+- **Bold**
+- **~Bold-Italic~**
+- __Underline__
+- _~Underline-Italic~_
+- `Italic`
+- ~~Strikethrough~~
+
+## LINE_DECOR_PRE
+These decorations are performed before Main, allowing for overrides without redefining Main.
+
+### Override Bold Underline
+This **_text_** is bold and underlined by default.
+::: Select below to trigger. If it changes to yellow, the option was processed.
+    ```opts :[bold-underline]
+    line_decor_pre:
+      - :color_method: :yellow
+        :pattern: '\*\*_([^_]{0,64})_\*\*'
+    ```
+This **_text_** is yellow when the rule takes precedence over the Main decorations.
+
+## LINE_DECOR_POST
+These decorations are performed after the Main decorations.
+This !!text!! is not decorated by default.
+::: Select below to trigger. If it changes to green, the option was processed.
+    ```opts :[green]
+    line_decor_post:
+      - :color_method: :green
+        :pattern: '!!([^!]{0,64})!!'
+    ```
+
+## MDE Non-standard Markdown Configuration
+- `_text_`: A single underscore delimeter is a standard way of underlining text. Because this occurs in code often, this decoration is not a default for MDE.
+
+## Precedence
+The order decorations are processed affects results.
+A Bold delimiter `__` has to be processed before the Underline delimeter `_`. If reversed, bold `text` appears as underlined `_text_`.
+
+# Related MDE Options
+line_decor_main  |  Line-oriented text decoration (Main)
+line_decor_post  |  Line-oriented text decoration (Post)
+line_decor_pre   |  Line-oriented text decoration (Pre)
+menu_note_match  |  Pattern for notes in block selection menu
+
+```opts :(document_options)
+line_decor_post:
+  - :color_method: blue
+    :pattern: '!([^!]{0,64})!blue!'
+  - :color_method: green
+    :pattern: '!([^!]{0,64})!green!'
+  - :color_method: red
+    :pattern: '!([^!]{0,64})!red!'
+```

data/examples/vars-blocks.md

@@ -9,7 +9,7 @@ The hidden block "(defaults)" sets the environment variable VAULT to "default" i
 : ${VAULT:=default}
 ```
 
-::: Click below to trigger. If it prints "VAULT: default", the shell block was processed.
+::: Select below to trigger. If it prints "VAULT: default", the shell block was processed.
 The named block prints the environment variable VAULT. It requires hidden block "(defaults)" before printing.
     ```bash :show_vars +(defaults)
     source bin/colorize_env_vars.sh
@@ -24,7 +24,7 @@ When clicked, it adds the variable to the inherited code. It does not output.
 
 # DOES NOT WORK 2024-07-20
 ## This does not evaluate the shell block.
-::: Click below to trigger. If it prints "VAULT: 22", the shell block was processed.
+::: Select below to trigger. If it prints "VAULT: 22", the shell block was processed.
 The block sets the environment variable VAULT to "22". It requires block "show_vars". Notice block "show_vars" is called after the variable is set.
     ```vars :[set_with_show] +show_vars
     VAULT: 22

data/examples/wrap.md

@@ -1,17 +1,27 @@
 # Demo block wrapping
 
-::: This block is wrapped by the `{outer*}` pair of blocks.
+## Wrapped block
 
-```bash :single +{outer}
-echo single body - wrapped by outer
-```
+This block is wrapped by the `{outer*}` pair of blocks.
+  Expect output: "outer-before", "single body", and "outer-after".
+  ::: Select below to test a block wrapped by a named pair of blocks.
+    ```bash :[single] +{outer}
+    echo single body
+    ```
 
-::: This block is wrapped first by the `{outer*}` pair of blocks
-::: and nested inside, the `{inner*}` pair of blocks.
+## Nested wraps
 
-```bash :nested +{outer} +{inner}
-echo nested body - wrapped by outer and then inner
-```
+This block is wrapped first by the `{outer*}` pair of blocks and then the `{inner*}` pair of blocks.
+  Expect output: "outer-before", "inner-before", "nested body", "inner-after", and "outer-after".
+  Blocks for the left-most included wrapper are first and last.
+  ::: Select below to test a block wrapped by nested named pair of blocks.
+    ```bash :[nested] +{outer} +{inner}
+    echo nested body
+    ```
+  Expect output: "inner-before", "outer-before", "nested body", "outer-after", and "inner-after".
+    ```bash :[inverted-nesting] +{inner} +{outer}
+    echo inverted nesting
+    ```
 
 ::: This pair of hidden blocks are the `{inner*}` set.
 ```bash :{inner}
@@ -31,3 +41,71 @@ echo outer-before
 ```bash :{outer-after}
 echo outer-after
 ```
+
+## Requiring additional Bash blocks
+
+```bash :(inc1)
+echo included1
+```
+```bash :inc2
+echo included2
+```
+Main block without a name.
+	Inc2 + Outer
+		```bash +{outer} +inc2
+		echo expecting11
+		```
+	Inc1 + Outer
+		```bash +{outer} +(inc1)
+		echo expecting12
+		```
+Main block with a name.
+	Inc2 + Outer
+		```bash :ex21 +{outer} +inc2
+		echo expecting21
+		```
+	Inc1 + Outer
+		```bash :ex22 +{outer} +(inc1)
+		echo expecting22
+		```
+
+## Requiring additional Bash blocks from wrapper block
+
+::: Does not work
+
+Inc1 + wrap-with-req
+	```bash :ex31 +{wrap-with-req}
+	echo expecting31
+	```
+
+```bash :{wrap-with-req} +(inc1)
+echo wrap-with-req-before
+```
+
+```bash :{wrap-with-req-after}
+echo wrap-with-req-after
+```
+
+::: Debug Inherited Code
+```opts
+dump_blocks_in_file: true
+dump_dependencies: true
+dump_inherited_block_names: true
+dump_inherited_dependencies: true
+dump_menu_blocks: true
+```
+
+```opts :add_shell_code_labels
+shell_code_label_format_above: "#  -^-"
+shell_code_label_format_below: "#  -v-  +%{block_name}  -o-  %{document_filename}  -o-  %{time_now_date}  -v-"
+```
+
+```opts :(document_options)
+execute_in_own_window: false
+output_execution_report: false
+output_execution_summary: false
+pause_after_script_execution: true
+line_decor_pre:
+  - :color_method: :underline_italic
+    :pattern: '"([^"]{0,64})"'
+```

data/lib/ansi_formatter.rb

@@ -3,6 +3,8 @@
 
 # encoding=utf-8
 
+require_relative 'ansi_string'
+
 class AnsiFormatter
   def initialize(options = {})
     @options = options
@@ -18,10 +20,10 @@ class AnsiFormatter
     line_postfix: '',
     detail_sep: ''
   )
-    (data&.map do |item|
+    data&.map do |item|
       scan_and_process_multiple_substrings(item, highlight, plain_color_sym,
                                            highlight_color_sym).join
-    end || [])
+    end || []
   end
 
   # Function to scan a string and process its segments based on multiple substrings
@@ -30,8 +32,10 @@ class AnsiFormatter
   # @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?)
+  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?)
 
     substring_patterns = substrings.map do |value|
       [value, Regexp.new(value, Regexp::IGNORECASE)]
@@ -41,7 +45,9 @@ class AnsiFormatter
     remaining_str = str.dup
 
     while remaining_str.length.positive?
-      match_indices = substring_patterns.map { |_, pattern| remaining_str.index(pattern) }.compact
+      match_indices = substring_patterns.map do |_, pattern|
+        remaining_str.index(pattern)
+      end.compact
       earliest_match = match_indices.min
 
       if earliest_match
@@ -112,6 +118,6 @@ class AnsiFormatter
   # @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)
+    AnsiString.new(string.to_s).send(color_method)
   end
 end

data/lib/ansi_string.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+# encoding=utf-8
+
+# Extends Ruby's native String class to include ANSI coloring functionality.
+# Adds methods to apply RGB colors, named colors, and other formatting to strings.
+class AnsiString < String
+  # Handles dynamic method calls to create RGB colors.
+  #
+  # @param method_name [Symbol] The name of the method being called.
+  # @param args [Array] The arguments passed to the method.
+  # @param block [Proc] An optional block.
+  # @return [AnsiString] The formatted string.
+  def method_missing(method_name, *args, &block)
+    if dynamic_color_method?(method_name)
+      case method_name.to_s
+      when /^fg_bg_rgb_/
+        bytes = $'.split('_')
+        fg_bg_rgb_color(bytes[0..2].join(';'), bytes[3..5].join(';'))
+      when /^fg_bg_rgbh_/
+        hex_to_fg_bg_rgb($')
+      when /^fg_rgb_/
+        fg_rgb_color($'.gsub('_', ';'))
+      when /^fg_rgbh_/
+        hex_to_rgb($')
+      else
+        super
+      end
+    else
+      super
+    end
+  end
+
+  # Checks if the AnsiString instance responds to a particular method.
+  #
+  # @param method_name [Symbol] The name of the method being checked.
+  # @param include_private [Boolean] Whether to include private methods in the check.
+  # @return [Boolean] True if the method is supported, otherwise false.
+  def respond_to_missing?(method_name, include_private = false)
+    dynamic_color_method?(method_name) || super
+  end
+
+  # Generates an ANSI control sequence for the string.
+  #
+  # @return [AnsiString] The string wrapped in an ANSI control sequence.
+  def ansi_control_sequence
+    self.class.new("\033[#{self}\033[0m")
+  end
+
+  # Applies a 24-bit RGB foreground and background color to the string.
+  #
+  # @param fg_rgb [String] The RGB foreground color, expressed as a string like "1;2;3".
+  # @param bg_rgb [String] The RGB background color, expressed as a string like "4;5;6".
+  # @return [AnsiString] The string with the applied RGB foreground and background colors.
+  def fg_bg_rgb_color(fg_rgb, bg_rgb)
+    self.class.new("38;2;#{fg_rgb}m\033[48;2;#{bg_rgb}m#{self}").ansi_control_sequence
+  end
+
+  # Applies a 24-bit RGB foreground color to the string.
+  #
+  # @param rgb [String] The RGB color, expressed as a string like "1;2;3".
+  # @return [AnsiString] The string with the applied RGB foreground color.
+  def fg_rgb_color(rgb)
+    self.class.new("38;2;#{rgb}m#{self}").ansi_control_sequence
+  end
+
+  # Converts hex color codes to RGB and applies them to the string.
+  #
+  # @param hex_str [String] The RGB color, expressed as a hex string like "FF00FF".
+  # @return [AnsiString] The string with the applied RGB foreground color.
+  def hex_to_fg_bg_rgb(hex_str)
+    values = hex_str.split('_').map { |hex| hex.to_i(16).to_s }
+    fg_bg_rgb_color(
+      values[0..2].join(';'),
+      values[3..5].join(';')
+    )
+  end
+
+  # Converts hex color codes to RGB and applies them to the string.
+  #
+  # @param hex_str [String] The RGB color, expressed as a hex string like "FF00FF".
+  # @return [AnsiString] The string with the applied RGB foreground color.
+  def hex_to_rgb(hex_str)
+    self.class.new(
+      fg_rgb_color(
+        hex_str.split('_').map { |hex| hex.to_i(16).to_s }.join(';')
+      )
+    )
+  end
+
+  # Provides a plain, unmodified version of the string.
+  #
+  # @return [AnsiString] The original string.
+  def plain
+    self.class.new(self)
+  end
+
+  # A collection of methods for applying named colors.
+  #
+  # For example, #black applies a black foreground color to the string.
+  # These are provided for convenience and easy readability.
+  def black;   self.class.new("30m#{self}").ansi_control_sequence; end
+  def bred;    self.class.new("1;31m#{self}").ansi_control_sequence; end
+  def bgreen;  self.class.new("1;32m#{self}").ansi_control_sequence; end
+  def byellow; self.class.new("1;33m#{self}").ansi_control_sequence; end
+  def magenta; self.class.new("35m#{self}").ansi_control_sequence; end
+  def cyan;    self.class.new("36m#{self}").ansi_control_sequence; end
+  def white;   self.class.new("37m#{self}").ansi_control_sequence; end
+  def bwhite;  self.class.new("1;37m#{self}").ansi_control_sequence; end
+
+  # More named colors using RGB hex values
+  def blue;    fg_rgbh_00_00_FF; end
+  def green;   fg_rgbh_00_FF_00; end
+  def indigo;  fg_rgbh_4B_00_82; end
+  def orange;  fg_rgbh_FF_7F_00; end
+  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; self.class.new("\033[1m#{self}\033[22m"); end
+
+  def bold_italic;
+    self.class.new("\033[1m\033[3m#{self}\033[22m\033[23m");
+  end
+
+  def bold_underline;
+    self.class.new("\033[1m\033[4m#{self}\033[22m\033[24m");
+  end
+
+  def dim;              self.class.new("\033[2m#{self}\033[22m"); end
+  def italic;           self.class.new("\033[3m#{self}\033[23m"); end
+  def underline;        self.class.new("\033[4m#{self}\033[24m"); end
+
+  def underline_italic;
+    self.class.new("\033[4m\033[3m#{self}\033[23m\033[24m");
+  end
+
+  def blinking;         self.class.new("\033[5m#{self}\033[25m"); end
+  def inverse;          self.class.new("\033[7m#{self}\033[27m"); end
+  def hidden;           self.class.new("\033[8m#{self}\033[28m"); end
+  def strikethrough;    self.class.new("\033[9m#{self}\033[29m"); end
+
+  private
+
+  # Checks if the method name matches any of the dynamic color methods.
+  #
+  # @param method_name [Symbol] The name of the method being checked.
+  # @return [Boolean] True if the method name matches a dynamic color method.
+  def dynamic_color_method?(method_name)
+    method_name.to_s =~ /^(fg_bg_rgb_|fg_bg_rgbh_|fg_rgb_|fg_rgbh_)/
+  end
+end

data/lib/argument_processor.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+# encoding=utf-8
+require_relative 'constants'
+require_relative 'object_present'
+
+def process_arguments(arguments, loose_args, options_parsed)
+  # &bt arguments, loose_args, options_parsed
+  # loose_args will be empty first command contains pass-through arguments
+  while loose_args.any?
+    if arguments.first == loose_args.first
+      yield ArgPro::ArgIsPosition, arguments.shift
+
+      loose_args.shift
+      next
+    end
+
+    yield ArgPro::ArgIsOption, options_parsed.first
+
+    arguments.shift(options_parsed.first[:procname].present? ? 2 : 1)
+    options_parsed.shift
+  end
+end
+
+def process_commands(options_parsed:, arguments:, enable_search:,
+                     named_procs:, rest:)
+  # &bt arguments,options_parsed
+  command_processed = false
+  block_executed = false
+  requested_menu = false
+  position = 0
+
+  process_arguments(arguments.dup, rest.dup,
+                    options_parsed.dup) do |type, item|
+    # &bt type,item
+    case type
+    when ArgPro::ArgIsOption
+      if named_procs.include?(item[:name])
+        command_processed = true
+        yield ArgPro::CallProcess, item[:name]
+      else
+        converted = if item[:proccode]
+                      yield ArgPro::ConvertValue, [item[:proccode],
+                                                   item[:value]]
+                    else
+                      item[:value]
+                    end
+        if item[:name]
+          yield ArgPro::ActSetOption, [item[:name], converted]
+        end
+      end
+    when ArgPro::ArgIsPosition
+      case position
+      when 0
+        # position 0: file, folder, or search term (optional)
+        if Dir.exist?(item)
+          yield ArgPro::ActSetPath, item
+        elsif File.exist?(item)
+          yield ArgPro::ActSetFileName, item
+        elsif enable_search
+          yield ArgPro::ActFind, item
+        else
+          yield ArgPro::ActFileIsMissing, item
+        end
+      else
+        # position 1: block (optional)
+        if item == '.'
+          requested_menu = true
+        else
+          block_executed = true
+          yield ArgPro::ActSetBlockName, item
+        end
+      end
+      position += 1
+      rest.shift
+    else
+      raise
+    end
+  end
+end
+
+return if $PROGRAM_NAME != __FILE__
+
+require 'minitest/autorun'
+
+class ArgumentProcessorTest < Minitest::Test
+  def setup
+    @arguments = ['fixtures/sample1.md', 'block', '--option', 'value',
+                  'ignored']
+    @rest = ['fixtures/sample1.md', 'block', 'ignored']
+    @options_parsed = [{ name: '--option', procname: 'VAL', value: 'value' }]
+  end
+
+  def test_process_arguments_with_position
+    result = []
+    process_arguments(@arguments,
+                      @rest, @options_parsed) do |type, item|
+      result << [type, item]
+    end
+
+    expected = [
+      [ArgPro::ArgIsPosition, 'fixtures/sample1.md'],
+      [ArgPro::ArgIsPosition, 'block'],
+      [ArgPro::ArgIsOption, { name: '--option', procname: 'VAL', value: 'value' }],
+      [ArgPro::ArgIsPosition, 'ignored']
+    ]
+    assert_equal expected, result
+  end
+end
+
+class CommandProcessorTest < Minitest::Test
+  def setup
+    @exisiting_file_name = Dir.glob('fixtures/*').first
+    @missing_file_name = 'missing-file.tmp'
+    @arguments = [@exisiting_file_name, 'process', '--option', 'value',
+                  'ignored']
+    @named_procs = []
+    @options_parsed = [{ name: '--option', procname: 'VAL', value: 'value' }]
+    @rest = [@exisiting_file_name, 'process', 'ignored']
+    @enable_search = true
+  end
+
+  def test_process_commands_with_valid_file
+    result = []
+    process_commands(
+      arguments: @arguments, named_procs: @named_procs,
+      options_parsed: @options_parsed,
+      rest: @rest, enable_search: @enable_search
+    ) do |type, item|
+      result << [type, item]
+    end
+
+    expected = [
+      [ArgPro::ActSetFileName, @exisiting_file_name],
+      [ArgPro::ActSetBlockName, 'process'],
+      [ArgPro::ActSetOption, ['--option', 'value']],
+      [ArgPro::ActSetBlockName, 'ignored']
+    ]
+
+    assert_equal expected, result
+  end
+
+  def test_process_commands_with_search
+    result = []
+    process_commands(arguments: [@missing_file_name, 'process'],
+                     named_procs: @named_procs,
+                     options_parsed: [],
+                     rest: [@missing_file_name, 'process'],
+                     enable_search: @enable_search) do |type, item|
+      result << [type, item]
+    end
+
+    expected = [
+      [ArgPro::ActFind, @missing_file_name],
+      [ArgPro::ActSetBlockName, 'process']
+    ]
+
+    assert_equal expected, result
+  end
+end

data/lib/cached_nested_file_reader.rb

@@ -53,7 +53,8 @@ class CachedNestedFileReader
         included_file_path = if name_strip =~ %r{^/}
                                name_strip
                              elsif import_paths
-                               find_files(name_strip, import_paths + [directory_path])&.first
+                               find_files(name_strip,
+                                          import_paths + [directory_path])&.first
                              else
                                File.join(directory_path, name_strip)
                              end
@@ -72,7 +73,8 @@ class CachedNestedFileReader
     @file_cache[filename] = processed_lines
   rescue Errno::ENOENT
     # Exceptions.error_handler('readlines', { abort: true })
-    warn_format('readlines', "No such file -- #{filename} @@ #{context}", { abort: true })
+    warn_format('readlines', "No such file -- #{filename} @@ #{context}",
+                { abort: true })
   end
 end
 

data/lib/ce_get_cost_and_usage.rb

@@ -8,15 +8,16 @@ text = system(cmd)
 data = YAML.load(text)
 
 # Extracting the relevant information
-services = data["ResultsByTime"][0]["Groups"].map do |group|
-  service_name = group["Keys"][0]
+services = data['ResultsByTime'][0]['Groups'].map do |group|
+  service_name = group['Keys'][0]
   unblended_cost = "#{group['Metrics']['UnblendedCost']['Amount']} #{group['Metrics']['UnblendedCost']['Unit']}"
   usage_quantity = "#{group['Metrics']['UsageQuantity']['Amount']} #{group['Metrics']['UsageQuantity']['Unit']}"
   [service_name, unblended_cost, usage_quantity]
 end
 
 # Create a table
-table = Terminal::Table.new :headings => ['Service', 'Unblended Cost', 'Usage Quantity'], :rows => services
+table = Terminal::Table.new headings: ['Service', 'Unblended Cost', 'Usage Quantity'],
+                            rows: services
 
 # Output the table
 puts table

data/lib/cli.rb

@@ -11,7 +11,7 @@ module CLI
     when 'String'
       Shellwords.escape value
     when 'FalseClass', 'TrueClass'
-      value ? '1' : '0'
+      value ? 't' : 'f'
     else
       Shellwords.escape value.to_s
     end