markdown_exec 1.3.7 → 1.3.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f4a8eee857b22f6ce92a03144f7eb68a2c8298e8888f0b538ff2bfb710aeb790
-  data.tar.gz: 651842b64a4ec92610d8f4ea00e002ffeaba952838d9142eb7da845edd2c7594
+  metadata.gz: 1f61a046f9f071edb4e123fd5ad1972de408c4a40c97d923322e416f643f4ffb
+  data.tar.gz: 8d00be273b75ac093809cbc168e585d36da49a26fa0bdde6ee242d06a94c3caf
 SHA512:
-  metadata.gz: afc863af78e1b75eec616e855625d1d5e8cae8a750bc51377c7110a8ed630d82a215242b2a09f8a49fdd549be7b57e96567c3b6bc384b61313feffa404600516
-  data.tar.gz: 41cd17fff38d663fd9b052496ec1f37d40ac8df2929d28f2ffd2e0b7fee5c002a982f4ed01618e82aa4c51dc71b85032d3772d8667727f63ec75a7795ccfe1dc
+  metadata.gz: 054de96356ebb625db55bccb693e498abebf01ab7eeb44b28f6391c3fec3ca87b72970916cbc3ba4dca9088905206b47a33213c9ded81fa67458c47827ba7068
+  data.tar.gz: 642a9e511a013c4485eb187e4be1d22a6516686b8815de1c6b1c230790269612357e9635d0b7b078dbc8f334b1e2d2e06980af71330f3bf8c1a273861bf902f4

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [1.3.8] - 2023-10-20
+
+### Added
+
+- Options for hidden, included, and wrapped blocks
+
+## [1.3.7] - 2023-10-16
+
+### Changed
+
+- Fix invocation of SavedAsset class
+
 ## [1.3.6] - 2023-10-15
 
 ### Added

data/Gemfile.lock

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

data/Rakefile

@@ -81,6 +81,7 @@ task :minitest do
     './lib/cached_nested_file_reader.rb',
     './lib/fcb.rb',
     './lib/filter.rb',
+    './lib/markdown_block_manager.rb',
     './lib/mdoc.rb',
     './lib/object_present.rb',
     './lib/option_value.rb',

data/bin/tab_completion.sh

@@ -13,7 +13,7 @@ __filedirs_all()
 }
 
 _mde_echo_version() {
-  echo "1.3.7"
+  echo "1.3.8"
 }
 
 _mde() {
@@ -138,4 +138,4 @@ _mde() {
 
 complete -o filenames -o nospace -F _mde mde
 # _mde_echo_version
-# echo "Updated: 2023-10-16 16:49:28 UTC"
+# echo "Updated: 2023-10-20 23:59:34 UTC"

data/lib/filter.rb

@@ -6,13 +6,22 @@
 module MarkdownExec
   # Filter
   #
-  # The Filter class provides utilities to determine the inclusion of fenced code blocks (FCB)
-  # based on a set of provided options. The primary function, `fcb_select?`, checks
-  # various properties of an FCB and decides whether to include or exclude it.
+  # The Filter class provides utilities to determine the inclusion of
+  # fenced code blocks (FCB) based on a set of provided options. The
+  # primary function, `fcb_select?`, checks various properties of an
+  # FCB and decides whether to include or exclude it.
   #
   # :reek:UtilityFunction
-
   class Filter
+    # Determines whether to include or exclude a fenced code block
+    # (FCB) based on the provided options.
+    #
+    # @param options [Hash] The options used for filtering FCBs.
+    # @param fcb [Hash] The fenced code block to be evaluated.
+    # @return [Boolean] True if the FCB should be included; false if
+    # it should be excluded.
+    # @raise [StandardError] If an error occurs during the evaluation.
+    #
     def self.fcb_select?(options, fcb)
       filters = {
         name_default: true,
@@ -21,7 +30,9 @@ module MarkdownExec
         shell_default: true,
         shell_exclude: nil,
         shell_select: nil,
-        hidden_name: nil
+        hidden_name: nil,
+        include_name: nil,
+        wrap_name: nil
       }
 
       name = fcb.fetch(:name, '')
@@ -37,6 +48,14 @@ module MarkdownExec
       raise err
     end
 
+    # Applies name-based filters to determine whether to include or
+    # exclude a fenced code block (FCB)
+    # based on the block's name and provided options.
+    #
+    # @param options [Hash] The options used for filtering FCBs.
+    # @param filters [Hash] The filter settings to be updated.
+    # @param name [String] The name of the fenced code block.
+    #
     def self.apply_name_filters(options, filters, name)
       if name.present? && options[:block_name]
         if name =~ /#{options[:block_name]}/
@@ -59,6 +78,14 @@ module MarkdownExec
       filters[:name_exclude] = !!(name =~ /#{options[:exclude_by_name_regex]}/)
     end
 
+    # Applies shell-based filters to determine whether to include or
+    # exclude a fenced code block (FCB)
+    # based on the block's shell type and provided options.
+    #
+    # @param options [Hash] The options used for filtering FCBs.
+    # @param filters [Hash] The filter settings to be updated.
+    # @param shell [String] The shell type of the fenced code block.
+    #
     def self.apply_shell_filters(options, filters, shell)
       filters[:shell_expect] = shell == 'expect'
 
@@ -71,34 +98,58 @@ module MarkdownExec
       filters[:shell_exclude] = !!(shell =~ /#{options[:exclude_by_shell_regex]}/)
     end
 
+    # Applies additional filters to determine whether to include or
+    # exclude a fenced code block (FCB)
+    # based on various criteria and provided options.
+    #
+    # @param options [Hash] The options used for filtering FCBs.
+    # @param filters [Hash] The filter settings to be updated.
+    # @param fcb [Hash] The fenced code block to be evaluated.
+    #
     def self.apply_other_filters(options, filters, fcb)
       name = fcb.fetch(:name, '')
       shell = fcb.fetch(:shell, '')
       filters[:fcb_chrome] = fcb.fetch(:chrome, false)
 
-      if name.present? && options[:hide_blocks_by_name] &&
-         options[:block_name_hidden_match].present?
-        filters[:hidden_name] = !!(name =~ /#{options[:block_name_hidden_match]}/)
-      end
-
-      if shell.present? && options[:hide_blocks_by_shell] &&
-         options[:block_shell_hidden_match].present?
-        !!(shell =~ /#{options[:block_shell_hidden_match]}/)
+      if name.present? && options[:hide_blocks_by_name]
+        filters[:hidden_name] =
+          !!(options[:block_name_hidden_match].present? &&
+                    name =~ /#{options[:block_name_hidden_match]}/)
       end
+      filters[:include_name] =
+        !!(options[:block_name_include_match].present? &&
+                  name =~ /#{options[:block_name_include_match]}/)
+      filters[:wrap_name] =
+        !!(options[:block_name_wrapper_match].present? &&
+                  name =~ /#{options[:block_name_wrapper_match]}/)
 
       return unless options[:bash_only]
 
       filters[:shell_default] = (shell == 'bash')
     end
 
+    # Evaluates the filter settings to make a final decision on
+    # whether to include or exclude a fenced
+    # code block (FCB) based on the provided options.
+    #
+    # @param options [Hash] The options used for filtering FCBs.
+    # @param filters [Hash] The filter settings to be evaluated.
+    # @return [Boolean] True if the FCB should be included; false
+    # if it should be excluded.
+    #
     def self.evaluate_filters(options, filters)
-      if options[:no_chrome] && filters[:fcb_chrome]
+      if options[:no_chrome] && filters[:fcb_chrome] == true
         false
-      elsif options[:exclude_expect_blocks] && filters[:shell_expect]
+      elsif options[:exclude_expect_blocks] && filters[:shell_expect] == true
         false
       elsif filters[:hidden_name] == true
+        false
+      elsif filters[:include_name] == true
         true
-      elsif filters[:name_exclude] == true || filters[:shell_exclude] == true || filters[:name_select] == false || filters[:shell_select] == false
+      elsif filters[:wrap_name] == true
+        true
+      elsif filters[:name_exclude] == true || filters[:shell_exclude] == true ||
+            filters[:name_select] == false || filters[:shell_select] == false
         false
       elsif filters[:name_select] == true || filters[:shell_select] == true
         true
@@ -112,70 +163,91 @@ module MarkdownExec
 end
 
 if $PROGRAM_NAME == __FILE__
+  require 'bundler/setup'
+  Bundler.require(:default)
+
   require 'minitest/autorun'
 
-  require_relative 'tap'
-  include Tap
+  module MarkdownExec
+    class FilterTest < Minitest::Test
+      def setup
+        @options = {}
+        @fcb = {}
+      end
 
-  class FilterTest < Minitest::Test
-    def test_no_chrome_condition
-      options = { no_chrome: true }
-      fcb = { chrome: true }
-      refute MarkdownExec::Filter.fcb_select?(options, fcb)
-    end
+      # Tests for fcb_select? method
+      def test_no_chrome_condition
+        @options[:no_chrome] = true
+        @fcb[:chrome] = true
+        refute Filter.fcb_select?(@options, @fcb)
+      end
 
-    def test_exclude_expect_blocks_condition
-      options = { exclude_expect_blocks: true }
-      fcb = { shell: 'expect' }
-      refute MarkdownExec::Filter.fcb_select?(options, fcb)
-    end
+      def test_exclude_expect_blocks_condition
+        @options[:exclude_expect_blocks] = true
+        @fcb[:shell] = 'expect'
+        refute Filter.fcb_select?(@options, @fcb)
+      end
 
-    def test_hidden_name_condition
-      options = { hide_blocks_by_name: true, block_name_hidden_match: 'hidden' }
-      fcb = { name: 'hidden_block' }
-      assert MarkdownExec::Filter.fcb_select?(options, fcb)
-    end
+      def test_hidden_name_condition
+        @options[:hide_blocks_by_name] = true
+        @options[:block_name_hidden_match] = 'hidden'
+        @fcb[:name] = 'hidden_block'
+        refute Filter.fcb_select?(@options, @fcb)
+      end
 
-    def test_name_exclude_condition
-      options = { block_name: 'test' }
-      fcb = { name: 'sample' }
-      refute MarkdownExec::Filter.fcb_select?(options, fcb)
-    end
+      def test_include_name_condition
+        @options[:hide_blocks_by_name] = true
+        @options[:block_name_indlude_match] = 'include'
+        @fcb[:name] = 'include_block'
+        assert Filter.fcb_select?(@options, @fcb)
+      end
 
-    def test_shell_exclude_condition
-      options = { exclude_by_shell_regex: 'exclude_this' }
-      fcb = { shell: 'exclude_this_shell' }
-      refute MarkdownExec::Filter.fcb_select?(options, fcb)
-    end
+      def test_wrap_name_condition
+        @options[:hide_blocks_by_name] = true
+        @options[:block_name_wrapper_match] = 'wrap'
+        @fcb[:name] = 'wrap_block'
+        assert Filter.fcb_select?(@options, @fcb)
+      end
 
-    def test_name_select_condition
-      options = { select_by_name_regex: 'select' }
-      fcb = { name: 'select_this' }
-      assert MarkdownExec::Filter.fcb_select?(options, fcb)
-    end
+      def test_name_exclude_condition
+        @options[:block_name] = 'test'
+        @fcb[:name] = 'sample'
+        refute Filter.fcb_select?(@options, @fcb)
+      end
 
-    def test_shell_select_condition
-      options = { select_by_shell_regex: 'select_this' }
-      fcb = { shell: 'select_this_shell' }
-      assert MarkdownExec::Filter.fcb_select?(options, fcb)
-    end
+      def test_shell_exclude_condition
+        @options[:exclude_by_shell_regex] = 'exclude_this'
+        @fcb[:shell] = 'exclude_this_shell'
+        refute Filter.fcb_select?(@options, @fcb)
+      end
 
-    def test_bash_only_condition_true
-      options = { bash_only: true }
-      fcb = { shell: 'bash' }
-      assert MarkdownExec::Filter.fcb_select?(options, fcb)
-    end
+      def test_name_select_condition
+        @options[:select_by_name_regex] = 'select'
+        @fcb[:name] = 'select_this'
+        assert Filter.fcb_select?(@options, @fcb)
+      end
 
-    def test_bash_only_condition_false
-      options = { bash_only: true }
-      fcb = { shell: 'zsh' }
-      refute MarkdownExec::Filter.fcb_select?(options, fcb)
-    end
+      def test_shell_select_condition
+        @options[:select_by_shell_regex] = 'select_this'
+        @fcb[:shell] = 'select_this_shell'
+        assert Filter.fcb_select?(@options, @fcb)
+      end
+
+      def test_bash_only_condition_true
+        @options[:bash_only] = true
+        @fcb[:shell] = 'bash'
+        assert Filter.fcb_select?(@options, @fcb)
+      end
 
-    def test_default_case
-      options = {}
-      fcb = {}
-      assert MarkdownExec::Filter.fcb_select?(options, fcb)
+      def test_bash_only_condition_false
+        @options[:bash_only] = true
+        @fcb[:shell] = 'zsh'
+        refute Filter.fcb_select?(@options, @fcb)
+      end
+
+      def test_default_case
+        assert Filter.fcb_select?(@options, @fcb)
+      end
     end
   end
 end

data/lib/markdown_block_manager.rb

@@ -16,115 +16,25 @@ module MarkdownExec
   class MarkdownBlockManager
     attr_reader :block_table
 
+    # initialize
+    #
+    # Initializes an instance of MarkdownBlockManager with the given block table.
+    #
+    # @param block_table [Array<Hash>] An array of hashes representing markdown blocks.
     def initialize(block_table)
       @block_table = block_table
     end
 
-    def collect_required_code(name)
-      gather_required_blocks(name)
-        .map do |block|
-        process_block_code(block)
-      end.flatten(1)
-    end
-
+    # get_block
+    #
+    # Retrieves a code block by its name.
+    #
+    # @param name [String] The name of the code block to retrieve.
+    # @param default [Hash] The default value to return if the code block is not found.
+    # @return [Hash] The code block as a hash or the default value if not found.
     def get_block(name, default = {})
       @block_table.select { |block| block.fetch(:name, '') == name }.fetch(0, default)
     end
-
-    def gather_required_blocks(name)
-      named_block = get_block(name)
-      if named_block.nil? || named_block.keys.empty?
-        raise "Named code block `#{name}` not found."
-      end
-
-      all_blocks = [named_block.fetch(:name, '')] + required_blocks(named_block[:reqs])
-      @block_table.select { |block| all_blocks.include? block.fetch(:name, '') }
-                  .map do |block|
-        process_block_references(block)
-      end.flatten(1)
-    end
-
-    def hide_block_given_options(opts, block)
-      (opts[:hide_blocks_by_name] &&
-       block[:name]&.match(Regexp.new(opts[:block_name_hidden_match])) &&
-       (block[:name]&.present? || block[:label]&.present?)
-      )
-    end
-
-    def blocks_per_options(opts = {})
-      filtered_blocks = @block_table.select do |block_group|
-        Filter.block_selected? opts, block_group
-      end
-      if opts[:hide_blocks_by_name]
-        filtered_blocks.reject { |block| hide_block_given_options opts, block }
-      else
-        filtered_blocks
-      end.map do |block|
-        block
-      end
-    end
-
-    def required_blocks(reqs)
-      return [] unless reqs
-
-      remaining = reqs
-      collected = []
-      while remaining.count.positive?
-        remaining = remaining.map do |req|
-          next if collected.include? req
-
-          collected += [req]
-          get_block(req).fetch(:reqs, [])
-        end
-                             .compact
-                             .flatten(1)
-      end
-      collected
-    end
-
-    # Helper method to process block code
-    def process_block_code(block)
-      body = block[:body].join("\n")
-
-      if block[:cann]
-        xcall = block[:cann][1..-2]
-        mstdin = xcall.match(/<(?<type>\$)?(?<name>[A-Za-z_\-.\w]+)/)
-        mstdout = xcall.match(/>(?<type>\$)?(?<name>[A-Za-z_\-.\w]+)/)
-
-        yqcmd = if mstdin[:type]
-                  "echo \"$#{mstdin[:name]}\" | yq '#{body}'"
-                else
-                  "yq e '#{body}' '#{mstdin[:name]}'"
-                end
-        if mstdout[:type]
-          "export #{mstdout[:name]}=$(#{yqcmd})"
-        else
-          "#{yqcmd} > '#{mstdout[:name]}'"
-        end
-      elsif block[:stdout]
-        stdout = block[:stdout]
-        body = block[:body].join("\n")
-        if stdout[:type]
-          %(export #{stdout[:name]}=$(cat <<"EOF"\n#{body}\nEOF\n))
-        else
-          "cat > '#{stdout[:name]}' <<\"EOF\"\n" \
-            "#{body}\n" \
-            "EOF\n"
-        end
-      else
-        block[:body]
-      end
-    end
-
-    # Helper method to process block references
-    def process_block_references(block)
-      if (call = block[:call])
-        [get_block("[#{call.match(/^%\((\S+) |\)/)[1]}]")
-          .merge({ cann: call })]
-      else
-        []
-      end + [block]
-    end
   end
 end
 
@@ -134,62 +44,21 @@ if $PROGRAM_NAME == __FILE__
 
   require 'minitest/autorun'
 
-  require_relative 'tap'
-  include Tap
-
-  module MarkdownExec
-    class TestMDoc < Minitest::Test
-      def setup
-        @table = [
-          { name: 'block1', body: ['code for block1'], reqs: ['block2'] },
-          { name: 'block2', body: ['code for block2'], reqs: nil },
-          { name: 'block3', body: ['code for block3'], reqs: ['block1'] }
-        ]
-        @doc = MDoc.new(@table)
-      end
-
-      def test_collect_recursively_required_code
-        result = @doc.collect_recursively_required_code('block1')
-        expected_result = @table[0][:body] + @table[1][:body]
-        assert_equal expected_result, result
-      end
-
-      def test_get_block_by_name
-        result = @doc.get_block_by_name('block1')
-        assert_equal @table[0], result
-
-        result_missing = @doc.get_block_by_name('missing_block')
-        assert_equal({}, result_missing)
-      end
-
-      def test_get_required_blocks
-        result = @doc.get_required_blocks('block3')
-        expected_result = [@table[0], @table[1], @table[2]]
-        assert_equal expected_result, result
-
-        assert_raises(RuntimeError) { @doc.get_required_blocks('missing_block') }
-      end
-
-      def test_hide_menu_block_per_options
-        opts = { hide_blocks_by_name: true, block_name_hidden_match: 'block1' }
-        block = { name: 'block1' }
-        result = @doc.hide_menu_block_per_options(opts, block)
-        assert result # this should be true based on the given logic
-      end
-
-      def test_fcbs_per_options
-        opts = { hide_blocks_by_name: true, block_name_hidden_match: 'block1' }
-        result = @doc.fcbs_per_options(opts)
-        assert_equal [@table[1], @table[2]], result
-      end
-
-      def test_recursively_required
-        result = @doc.recursively_required(['block3'])
-        assert_equal %w[block3 block1 block2], result
+  class MarkdownBlockManagerTest < Minitest::Test
+    def setup
+      @block_table = [
+        { name: 'block1', reqs: ['block2'], body: ['code1'] },
+        { name: 'block2', body: ['code2'] },
+        { name: 'block3', body: ['code3'] }
+      ]
+      @manager = MarkdownExec::MarkdownBlockManager.new(@block_table)
+    end
 
-        result_no_reqs = @doc.recursively_required(nil)
-        assert_equal [], result_no_reqs
-      end
+    # Test the get_block method
+    def test_get_block
+      block = @manager.get_block('block2')
+      expected_block = { name: 'block2', body: ['code2'] }
+      assert_equal expected_block, block
     end
   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 = '1.3.7'
+  VERSION = '1.3.8'
 end

data/lib/markdown_exec.rb

@@ -199,26 +199,40 @@ module MarkdownExec
       }
     end
 
+    # Execute a code block after approval and provide user interaction options.
+    #
+    # This method displays required code blocks, asks for user approval, and
+    # executes the code block if approved. It also allows users to copy the
+    # code to the clipboard or save it to a file.
+    #
+    # @param opts [Hash] Options hash containing configuration settings.
+    # @param mdoc [YourMDocClass] An instance of the MDoc class.
+    # @return [String] The name of the executed code block.
     def approve_and_execute_block(opts, mdoc)
+      # Collect required code blocks based on the provided options.
       required_blocks = mdoc.collect_recursively_required_code(opts[:block_name])
+      # Display required code blocks if requested or required approval.
       if opts[:output_script] || opts[:user_must_approve]
         display_required_code(opts,
                               required_blocks)
       end
 
       allow = true
+      # If user approval is required, prompt the user for approval.
       if opts[:user_must_approve]
         loop do
-          (sel = @prompt.select(opts[:prompt_approve_block],
-                                filter: true) do |menu|
-             menu.default 1
-             menu.choice opts[:prompt_yes], 1
-             menu.choice opts[:prompt_no], 2
-             menu.choice opts[:prompt_script_to_clipboard], 3
-             menu.choice opts[:prompt_save_script], 4
-           end)
+          # Present a selection menu for user approval.
+          sel = @prompt.select(opts[:prompt_approve_block],
+                               filter: true) do |menu|
+            menu.default 1
+            menu.choice opts[:prompt_yes], 1
+            menu.choice opts[:prompt_no], 2
+            menu.choice opts[:prompt_script_to_clipboard], 3
+            menu.choice opts[:prompt_save_script], 4
+          end
           allow = (sel == 1)
           if sel == 3
+            # Copy the code to the clipboard.
             text = required_blocks.flatten.join($INPUT_RECORD_SEPARATOR)
             Clipboard.copy(text)
             fout "Clipboard updated: #{required_blocks.count} blocks," /
@@ -226,6 +240,7 @@ module MarkdownExec
                  " #{text.length} characters"
           end
           if sel == 4
+            # Save the code to a file.
             write_command_file(opts.merge(save_executed_script: true),
                                required_blocks)
             fout "File saved: #{@options[:saved_filespec]}"
@@ -233,13 +248,16 @@ module MarkdownExec
           break if [1, 2].include? sel
         end
       end
-      (opts[:ir_approve] = allow)
 
-      selected = mdoc.get_block_by_name opts[:block_name]
+      opts[:ir_approve] = allow
 
+      # Get the selected code block by name.
+      selected = mdoc.get_block_by_name(opts[:block_name])
+
+      # If approved, write the code to a file, execute it, and provide output.
       if opts[:ir_approve]
-        write_command_file opts, required_blocks
-        command_execute opts, required_blocks.flatten.join("\n")
+        write_command_file(opts, required_blocks)
+        command_execute(opts, required_blocks.flatten.join("\n"))
         save_execution_output
         output_execution_summary
         output_execution_result
@@ -473,7 +491,8 @@ module MarkdownExec
                 fcb.title = fcb.body.join(' ').gsub(/  +/, ' ')[0..64]
               end
 
-              if block_given? && selected_messages.include?(:blocks) &&
+              if block_given? &&
+                 selected_messages.include?(:blocks) &&
                  Filter.fcb_select?(opts, fcb)
                 yield :blocks, fcb
               end
@@ -496,8 +515,10 @@ module MarkdownExec
             fcb.body = []
 
             rest = fcb_title_groups.fetch(:rest, '')
-            fcb.reqs = rest.scan(/\+[^\s]+/).map { |req| req[1..-1] }
-
+            fcb.reqs, fcb.wraps =
+              split_array(rest.scan(/\+[^\s]+/).map { |req| req[1..-1] }) do |name|
+              !name.match(Regexp.new(opts[:block_name_wrapper_match]))
+            end
             fcb.call = rest.match(Regexp.new(opts[:block_calls_scan]))&.to_a&.first
             fcb.stdin = if (tn = rest.match(/<(?<type>\$)?(?<name>[A-Za-z_-]\S+)/))
                           tn.named_captures.sym_keys
@@ -518,6 +539,27 @@ module MarkdownExec
       end
     end
 
+    def split_array(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
+
+    # # Example usage:
+    # array = [1, 2, 3, 4, 5]
+    # result = split_array(array) { |num| num.even? }
+    # puts "True List: #{result[0]}"   # Output: True List: [2, 4]
+    # puts "False List: #{result[1]}"  # Output: False List: [1, 3, 5]
+
     # return body, title if option.struct
     # return body if not struct
     #
@@ -984,8 +1026,16 @@ module MarkdownExec
       File.write(@options[:logged_stdout_filespec], ol.join)
     end
 
+    # Select and execute a code block from a Markdown document.
+    #
+    # This method allows the user to interactively select a code block from a
+    # Markdown document, obtain approval, and execute the chosen block of code.
+    #
+    # @param call_options [Hash] Initial options for the method.
+    # @param options_block [Block] Block of options to be merged with call_options.
+    # @return [Nil] Returns nil if no code block is selected or an error occurs.
     def select_approve_and_execute_block(call_options, &options_block)
-      opts = optsmerge call_options, options_block
+      opts = optsmerge(call_options, options_block)
       blocks_in_file = list_blocks_in_file(opts.merge(struct: true))
       mdoc = MDoc.new(blocks_in_file) do |nopts|
         opts.merge!(nopts)
@@ -995,7 +1045,7 @@ module MarkdownExec
       repeat_menu = true && !opts[:block_name].present?
       loop do
         unless opts[:block_name].present?
-          pt = (opts[:prompt_select_block]).to_s
+          pt = opts[:prompt_select_block].to_s
 
           bm = blocks_menu.map do |fcb|
             # next if fcb.fetch(:disabled, false)
@@ -1017,8 +1067,7 @@ module MarkdownExec
           end.compact
           return nil if bm.count.zero?
 
-          sel = prompt_with_quit pt, bm,
-                                 per_page: opts[:select_page_height]
+          sel = prompt_with_quit(pt, bm, per_page: opts[:select_page_height])
           return nil if sel.nil?
 
           ## store selected option
@@ -1028,7 +1077,7 @@ module MarkdownExec
           end.fetch(0, nil)
           opts[:block_name] = @options[:block_name] = label_block.fetch(:name, '')
         end
-        approve_and_execute_block opts, mdoc
+        approve_and_execute_block(opts, mdoc)
         break unless repeat_menu
 
         opts[:block_name] = ''

data/lib/mdoc.rb

@@ -16,15 +16,47 @@ module MarkdownExec
   class MDoc
     attr_reader :table
 
-    # convert block name to fcb_parse
+    # Initializes an instance of MDoc with the given table of markdown sections.
+    #
+    # @param table [Array<Hash>] An array of hashes representing markdown sections.
     #
     def initialize(table)
       @table = table
     end
 
+    # Retrieves code blocks that are required by a specified code block.
+    #
+    # @param name [String] The name of the code block to start the retrieval from.
+    # @return [Array<Hash>] An array of code blocks required by the specified code block.
+    #
+    def collect_recursively_required_blocks(name)
+      name_block = get_block_by_name(name)
+      raise "Named code block `#{name}` not found." if name_block.nil? || name_block.keys.empty?
+
+      all = [name_block.fetch(:name, '')] + recursively_required(name_block[:reqs])
+
+      # in order of appearance in document
+      # insert function blocks
+      @table.select { |fcb| all.include? fcb.fetch(:name, '') }
+            .map do |fcb|
+        if (call = fcb[:call])
+          [get_block_by_name("[#{call.match(/^%\((\S+) |\)/)[1]}]")
+            .merge({ cann: call })]
+        else
+          []
+        end + [fcb]
+      end.flatten(1)
+    end
+
+    # Collects recursively required code blocks and returns them as an array of strings.
+    #
+    # @param name [String] The name of the code block to start the collection from.
+    # @return [Array<String>] An array of strings containing the collected code blocks.
+    #
     def collect_recursively_required_code(name)
-      get_required_blocks(name)
-        .map do |fcb|
+      collect_wrapped_blocks(
+        collect_recursively_required_blocks(name)
+      ).map do |fcb|
         body = fcb[:body].join("\n")
 
         if fcb[:cann]
@@ -58,43 +90,37 @@ module MarkdownExec
       end.flatten(1)
     end
 
-    def get_block_by_name(name, default = {})
-      @table.select { |fcb| fcb.fetch(:name, '') == name }.fetch(0, default)
-    end
-
-    def get_required_blocks(name)
-      name_block = get_block_by_name(name)
-      raise "Named code block `#{name}` not found." if name_block.nil? || name_block.keys.empty?
-
-      all = [name_block.fetch(:name, '')] + recursively_required(name_block[:reqs])
-
-      # in order of appearance in document
-      # insert function blocks
-      @table.select { |fcb| all.include? fcb.fetch(:name, '') }
-            .map do |fcb|
-        if (call = fcb[:call])
-          [get_block_by_name("[#{call.match(/^%\((\S+) |\)/)[1]}]")
-            .merge({ cann: call })]
-        else
-          []
-        end + [fcb]
-      end.flatten(1)
-    end
-
-    # :reek:UtilityFunction
-    def hide_menu_block_per_options(opts, block)
-      (opts[:hide_blocks_by_name] &&
-              block[:name]&.match(Regexp.new(opts[:block_name_hidden_match])) &&
-              (block[:name]&.present? || block[:label]&.present?)
-      )
+    # Retrieves code blocks that are wrapped
+    # wraps are applied from left to right
+    # e.g. w1 w2 => w1-before w2-before w1 w2 w2-after w1-after
+    #
+    # @return [Array<Hash>] An array of code blocks required by the specified code blocks.
+    #
+    def collect_wrapped_blocks(blocks)
+      blocks.map do |block|
+        (block[:wraps] || []).map do |wrap|
+          wrap_before = wrap.sub('}', '-before}') ### hardcoded wrap name
+          @table.select { |fcb| [wrap_before, wrap].include? fcb[:name] }
+        end.flatten(1) +
+          [block] +
+          (block[:wraps] || []).reverse.map do |wrap|
+            wrap_after = wrap.sub('}', '-after}') ### hardcoded wrap name
+            @table.select { |fcb| fcb[:name] == wrap_after }
+          end.flatten(1)
+      end.flatten(1).compact
     end
 
+    # Retrieves code blocks based on the provided options.
+    #
+    # @param opts [Hash] The options used for filtering code blocks.
+    # @return [Array<Hash>] An array of code blocks that match the options.
+    #
     def fcbs_per_options(opts = {})
       options = opts.merge(block_name_hidden_match: nil)
       selrows = @table.select do |fcb_title_groups|
         Filter.fcb_select? options, fcb_title_groups
       end
-
+      # pp selrows; binding.pry
       ### hide rows correctly
 
       if opts[:hide_blocks_by_name]
@@ -107,6 +133,40 @@ module MarkdownExec
       end
     end
 
+    # Retrieves a code block by its name.
+    #
+    # @param name [String] The name of the code block to retrieve.
+    # @param default [Hash] The default value to return if the code block is not found.
+    # @return [Hash] The code block as a hash or the default value if not found.
+    #
+    def get_block_by_name(name, default = {})
+      @table.select { |fcb| fcb.fetch(:name, '') == name }.fetch(0, default)
+    end
+
+    # Checks if a code block should be hidden based on the given options.
+    #
+    # @param opts [Hash] The options used for hiding code blocks.
+    # @param block [Hash] The code block to check for hiding.
+    # @return [Boolean] True if the code block should be hidden; false otherwise.
+    #
+    # :reek:UtilityFunction
+    def hide_menu_block_per_options(opts, block)
+      (opts[:hide_blocks_by_name] &&
+              ((opts[:block_name_hidden_match]&.present? &&
+                block[:name]&.match(Regexp.new(opts[:block_name_hidden_match]))) ||
+               (opts[:block_name_include_match]&.present? &&
+                block[:name]&.match(Regexp.new(opts[:block_name_include_match]))) ||
+               (opts[:block_name_wrapper_match]&.present? &&
+                block[:name]&.match(Regexp.new(opts[:block_name_wrapper_match])))) &&
+              (block[:name]&.present? || block[:label]&.present?)
+      )
+    end
+
+    # Recursively fetches required code blocks for a given list of requirements.
+    #
+    # @param reqs [Array<String>] An array of requirements to start the recursion from.
+    # @return [Array<String>] An array of recursively required code block names.
+    #
     def recursively_required(reqs)
       return [] unless reqs
 
@@ -128,14 +188,11 @@ module MarkdownExec
 end
 
 if $PROGRAM_NAME == __FILE__
-  # require 'bundler/setup'
-  # Bundler.require(:default)
+  require 'bundler/setup'
+  Bundler.require(:default)
 
   require 'minitest/autorun'
 
-  require_relative 'tap'
-  include Tap
-
   module MarkdownExec
     class TestMDoc < Minitest::Test
       def setup
@@ -161,12 +218,14 @@ if $PROGRAM_NAME == __FILE__
         assert_equal({}, result_missing)
       end
 
-      def test_get_required_blocks
-        result = @doc.get_required_blocks('block3')
+      def test_collect_recursively_required_blocks
+        result = @doc.collect_recursively_required_blocks('block3')
         expected_result = [@table[0], @table[1], @table[2]]
         assert_equal expected_result, result
 
-        assert_raises(RuntimeError) { @doc.get_required_blocks('missing_block') }
+        assert_raises(RuntimeError) do
+          @doc.collect_recursively_required_blocks('missing_block')
+        end
       end
 
       def test_hide_menu_block_per_options
@@ -190,5 +249,58 @@ if $PROGRAM_NAME == __FILE__
         assert_equal [], result_no_reqs
       end
     end
+
+    class TestMDoc2 < Minitest::Test
+      # Mocking the @table object for testing
+      def setup
+        @table = [
+          { name: '{wrap1}' },
+          { name: '{wrap2-before}' },
+          { name: '{wrap2}' },
+          { name: '{wrap2-after}' },
+          { name: '{wrap3-before}' },
+          { name: '{wrap3}' },
+          { name: '{wrap3-after}' }
+        ]
+        @mdoc = MDoc.new(@table)
+      end
+
+      def test_collect_wrapped_blocks
+        # Test case 1: blocks with wraps
+        assert_equal(%w[{wrap1} a],
+                     @mdoc.collect_wrapped_blocks(
+                       [{ name: 'a',
+                          wraps: ['{wrap1}'] }]
+                     ).map do |block|
+                       block[:name]
+                     end)
+
+        assert_equal(%w[{wrap2-before} {wrap2} b {wrap2-after}],
+                     @mdoc.collect_wrapped_blocks(
+                       [{ name: 'b',
+                          wraps: ['{wrap2}'] }]
+                     ).map do |block|
+                       block[:name]
+                     end)
+
+        assert_equal(%w[{wrap2-before} {wrap2} {wrap3-before} {wrap3} c {wrap3-after} {wrap2-after}],
+                     @mdoc.collect_wrapped_blocks(
+                       [{ name: 'c',
+                          wraps: %w[{wrap2} {wrap3}] }]
+                     ).map { |block| block[:name] })
+
+        # Test case 2: blocks with no wraps
+        blocks = @mdoc.collect_wrapped_blocks([])
+        assert_empty blocks
+
+        # Test case 3: blocks with missing wraps
+        assert_equal(
+          %w[block4],
+          @mdoc.collect_wrapped_blocks([{ name: 'block4', wraps: ['wrap4'] }]).map do |block|
+            block[:name]
+          end
+        )
+      end
+    end
   end
 end

data/lib/menu.src.yml

@@ -266,15 +266,25 @@
   :env_var: MDE_SELECT_BY_SHELL_REGEX
   :opt_name: select_by_shell_regex
   :procname: val_as_str
-- :default: "^[\\(\\[].*[\\)\\]]$"
+- :default: "^-.+-$"
   :description: Pattern for blocks to hide from user-selection
   :env_var: MDE_BLOCK_NAME_HIDDEN_MATCH
   :opt_name: block_name_hidden_match
   :procname: val_as_str
+- :default: "^[\\(\\[].*[\\)\\]]$"
+  :description: Pattern for blocks to hide from user-selection
+  :env_var: MDE_BLOCK_NAME_INCLUDE_MATCH
+  :opt_name: block_name_include_match
+  :procname: val_as_str
 - :default: ":(?<title>\\S+)( |$)"
   :env_var: MDE_BLOCK_NAME_MATCH
   :opt_name: block_name_match
   :procname: val_as_str
+- :default: "^{.+}$"
+  :description: Pattern for block names to use as wrappers
+  :env_var: MDE_BLOCK_NAME_WRAPPER_MATCH
+  :opt_name: block_name_wrapper_match
+  :procname: val_as_str
 - :default: "%\\([^\\)]+\\)"
   :env_var: MDE_BLOCK_CALLS_SCAN
   :opt_name: block_calls_scan
@@ -357,7 +367,7 @@
   :env_var: MDE_MENU_INITIAL_DIVIDER
   :opt_name: menu_initial_divider
   :procname: val_as_str
-- :default: "[%{status}] %{name}"
+- :default: "%{name} [%{status}]"
   :description: format for menu tasks and demarcations
   :env_var: MDE_MENU_TASK_FORMAT
   :opt_name: menu_task_format

data/lib/menu.yml

@@ -1,4 +1,4 @@
-# MDE - Markdown Executor (1.3.7)
+# MDE - Markdown Executor (1.3.8)
 ---
 - :arg_name: NAME
   :compreply: false
@@ -267,15 +267,25 @@
   :env_var: MDE_SELECT_BY_SHELL_REGEX
   :opt_name: select_by_shell_regex
   :procname: val_as_str
-- :default: "^[\\(\\[].*[\\)\\]]$"
+- :default: "^-.+-$"
   :description: Pattern for blocks to hide from user-selection
   :env_var: MDE_BLOCK_NAME_HIDDEN_MATCH
   :opt_name: block_name_hidden_match
   :procname: val_as_str
+- :default: "^[\\(\\[].*[\\)\\]]$"
+  :description: Pattern for blocks to hide from user-selection
+  :env_var: MDE_BLOCK_NAME_INCLUDE_MATCH
+  :opt_name: block_name_include_match
+  :procname: val_as_str
 - :default: ":(?<title>\\S+)( |$)"
   :env_var: MDE_BLOCK_NAME_MATCH
   :opt_name: block_name_match
   :procname: val_as_str
+- :default: "^{.+}$"
+  :description: Pattern for block names to use as wrappers
+  :env_var: MDE_BLOCK_NAME_WRAPPER_MATCH
+  :opt_name: block_name_wrapper_match
+  :procname: val_as_str
 - :default: "%\\([^\\)]+\\)"
   :env_var: MDE_BLOCK_CALLS_SCAN
   :opt_name: block_calls_scan
@@ -358,7 +368,7 @@
   :env_var: MDE_MENU_INITIAL_DIVIDER
   :opt_name: menu_initial_divider
   :procname: val_as_str
-- :default: "[%{status}] %{name}"
+- :default: "%{name} [%{status}]"
   :description: format for menu tasks and demarcations
   :env_var: MDE_MENU_TASK_FORMAT
   :opt_name: menu_task_format

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: markdown_exec
 version: !ruby/object:Gem::Version
-  version: 1.3.7
+  version: 1.3.8
 platform: ruby
 authors:
 - Fareed Stevenson
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-10-16 00:00:00.000000000 Z
+date: 2023-10-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: clipboard