markdown_exec 1.8.4 → 1.8.6

data/lib/hash_delegator.rb

@@ -26,6 +26,7 @@ require_relative 'fout'
 require_relative 'hash'
 require_relative 'link_history'
 require_relative 'mdoc'
+require_relative 'regexp'
 require_relative 'string_util'
 
 class String
@@ -296,17 +297,18 @@ module MarkdownExec
         label_format_below: @delegate_object[:shell_code_label_format_below],
         block_source: block_source
       )
+      dependencies = (link_state&.inherited_dependencies || {}).merge(required[:dependencies] || {})
       required[:unmet_dependencies] =
         (required[:unmet_dependencies] || []) - (link_state&.inherited_block_names || [])
       if required[:unmet_dependencies].present?
         ### filter against link_state.inherited_block_names
 
-        warn format_and_highlight_dependencies(required[:dependencies],
+        warn format_and_highlight_dependencies(dependencies,
                                                highlight: required[:unmet_dependencies])
         runtime_exception(:runtime_exception_error_level,
                           'unmet_dependencies, flag: runtime_exception_error_level', required[:unmet_dependencies])
       elsif true
-        warn format_and_highlight_dependencies(required[:dependencies],
+        warn format_and_highlight_dependencies(dependencies,
                                                highlight: [@delegate_object[:block_name]])
       end
 
@@ -357,7 +359,7 @@ module MarkdownExec
       @fout.fout "Error ENOENT: #{err.inspect}"
     end
 
-    def command_or_user_selected_block(all_blocks, menu_blocks, default)
+    def load_cli_or_user_selected_block(all_blocks, menu_blocks, default)
       if @delegate_object[:block_name].present?
         block = all_blocks.find do |item|
           item[:oname] == @delegate_object[:block_name]
@@ -371,7 +373,7 @@ module MarkdownExec
 
       SelectedBlockMenuState.new(block, state)
     rescue StandardError
-      error_handler('command_or_user_selected_block')
+      error_handler('load_cli_or_user_selected_block')
     end
 
     # This method is responsible for handling the execution of generic blocks in a markdown document.
@@ -381,13 +383,13 @@ module MarkdownExec
     # @param mdoc [Object] The markdown document object containing code blocks.
     # @param selected [Hash] The selected item from the menu to be executed.
     # @return [LoadFileLinkState] An object indicating whether to load the next block or reuse the current one.
-    def compile_execute_bash_and_special_blocks_and_trigger_reuse(mdoc, selected,
-                                                                  link_state = nil, block_source:)
+    def compile_execute_and_trigger_reuse(mdoc, selected, link_state = nil, block_source:)
       required_lines = collect_required_code_lines(mdoc, selected, link_state,
                                                    block_source: block_source)
       output_or_approval = @delegate_object[:output_script] || @delegate_object[:user_must_approve]
       display_required_code(required_lines) if output_or_approval
       allow_execution = @delegate_object[:user_must_approve] ? prompt_for_user_approval(required_lines) : true
+
       execute_required_lines(required_lines) if allow_execution
 
       link_state.block_name = nil
@@ -599,8 +601,8 @@ module MarkdownExec
     # @param opts [Hash] Options hash containing configuration settings.
     # @param mdoc [YourMDocClass] An instance of the MDoc class.
     #
-    def execute_bash_and_special_blocks(selected, mdoc, link_state = LinkState.new,
-                                        block_source:)
+    def execute_shell_type(selected, mdoc, link_state = LinkState.new,
+                           block_source:)
       if selected.fetch(:shell, '') == BlockType::LINK
         push_link_history_and_trigger_load(selected.fetch(:body, ''), mdoc, selected,
                                            link_state)
@@ -609,11 +611,14 @@ module MarkdownExec
         pop_link_history_and_trigger_load
 
       elsif selected[:shell] == BlockType::OPTS
-        update_options_and_trigger_reuse(selected, @menu_base_options, link_state)
+        options_state = read_show_options_and_trigger_reuse(selected, link_state)
+        @menu_base_options.merge!(options_state.options)
+        @delegate_object.merge!(options_state.options)
+        options_state.load_file_link_state
 
       else
-        compile_execute_bash_and_special_blocks_and_trigger_reuse(mdoc, selected, link_state,
-                                                                  block_source: block_source)
+        compile_execute_and_trigger_reuse(mdoc, selected, link_state,
+                                          block_source: block_source)
       end
     end
 
@@ -805,7 +810,7 @@ module MarkdownExec
 
     def link_history_push_and_next(
       curr_block_name:, curr_document_filename:,
-      inherited_block_names:, inherited_lines:,
+      inherited_block_names:, inherited_dependencies:, inherited_lines:,
       next_block_name:, next_document_filename:,
       next_load_file:
     )
@@ -814,6 +819,7 @@ module MarkdownExec
           block_name: curr_block_name,
           document_filename: curr_document_filename,
           inherited_block_names: inherited_block_names,
+          inherited_dependencies: inherited_dependencies,
           inherited_lines: inherited_lines
         )
       )
@@ -823,6 +829,7 @@ module MarkdownExec
           block_name: next_block_name,
           document_filename: next_document_filename,
           inherited_block_names: inherited_block_names,
+          inherited_dependencies: inherited_dependencies,
           inherited_lines: inherited_lines
         )
       )
@@ -841,7 +848,10 @@ module MarkdownExec
       block = block_find(all_blocks, :oname, block_name)
       return unless block
 
-      update_options_and_trigger_reuse(block, @delegate_object)
+      options_state = read_show_options_and_trigger_reuse(block)
+      @menu_base_options.merge!(options_state.options)
+      @delegate_object.merge!(options_state.options)
+
       @most_recent_loaded_filename = @delegate_object[:filename]
       true
     end
@@ -911,10 +921,12 @@ module MarkdownExec
       end
     end
 
-    def pop_cli_argument!
-      return false unless @delegate_object[:input_cli_rest].present?
+    def shift_cli_argument!
+      return false unless @menu_base_options[:input_cli_rest].present?
 
-      @cli_block_name = @delegate_object[:input_cli_rest].pop
+      @cli_block_name = @menu_base_options[:input_cli_rest].shift
+      # @delegate_object[:input_cli_rest].shift
+      # p [__LINE__, @cli_block_name, @menu_base_options[:input_cli_rest]]
       true
     end
 
@@ -978,6 +990,25 @@ module MarkdownExec
       body.any? ? YAML.load(body.join("\n")) : {}
     end
 
+    def pop_add_current_code_to_head_and_trigger_load(_link_state, block_names, code_lines,
+                                                      dependencies)
+      pop = @link_history.pop # updatable
+      next_link_state = LinkState.new(
+        block_name: pop.block_name,
+        document_filename: pop.document_filename,
+        inherited_block_names:
+         (pop.inherited_block_names + block_names).sort.uniq,
+        inherited_dependencies:
+         dependencies.merge(pop.inherited_dependencies || {}), ### merge, not replace, key data
+        inherited_lines:
+         code_merge(pop.inherited_lines, code_lines)
+      )
+      @link_history.push(next_link_state)
+
+      next_link_state.block_name = nil
+      LoadFileLinkState.new(LoadFile::Load, next_link_state)
+    end
+
     # This method handles the back-link operation in the Markdown execution context.
     # It updates the history state and prepares to load the next block.
     #
@@ -986,10 +1017,11 @@ module MarkdownExec
       pop = @link_history.pop
       peek = @link_history.peek
       LoadFileLinkState.new(LoadFile::Load, LinkState.new(
-        document_filename: pop.document_filename,
-        inherited_block_names: peek.inherited_block_names,
-        inherited_lines: peek.inherited_lines
-      ))
+                                              document_filename: pop.document_filename,
+                                              inherited_block_names: peek.inherited_block_names,
+                                              inherited_dependencies: peek.inherited_dependencies,
+                                              inherited_lines: peek.inherited_lines
+                                            ))
     end
 
     def post_execution_process
@@ -1135,21 +1167,52 @@ module MarkdownExec
         )
         code_lines = code_info[:code]
         block_names = code_info[:block_names]
+        dependencies = code_info[:dependencies]
       else
         block_names = []
         code_lines = []
+        dependencies = {}
       end
-
       next_document_filename = link_block_data['file'] || @delegate_object[:filename]
-      link_history_push_and_next(
-        curr_block_name: selected[:oname],
-        curr_document_filename: @delegate_object[:filename],
-        inherited_block_names: ((link_state&.inherited_block_names || []) + block_names).sort.uniq,
-        inherited_lines: code_merge(link_state&.inherited_lines, code_lines),
-        next_block_name: link_block_data['block'] || '',
-        next_document_filename: next_document_filename,
-        next_load_file: next_document_filename == @delegate_object[:filename] ? LoadFile::Reuse : LoadFile::Load
-      )
+
+      # if an eval link block, evaluate code_lines and return its standard output
+      #
+      if link_block_data.fetch('eval', false)
+        all_code = code_merge(link_state&.inherited_lines, code_lines)
+        output = `#{all_code.join("\n")}`.split("\n")
+        label_format_above = @delegate_object[:shell_code_label_format_above]
+        label_format_below = @delegate_object[:shell_code_label_format_below]
+        block_source = { document_filename: link_state&.document_filename }
+
+        code_lines = [label_format_above && format(label_format_above,
+                                                   block_source.merge({ block_name: selected[:oname] }))] +
+                     output.map do |line|
+                       re = Regexp.new(link_block_data.fetch('pattern', '(?<line>.*)'))
+                       if re =~ line
+                         re.gsub_format(line, link_block_data.fetch('format', '%{line}'))
+                       end
+                     end.compact +
+                     [label_format_below && format(label_format_below,
+                                                   block_source.merge({ block_name: selected[:oname] }))]
+
+      end
+
+      if link_block_data['return']
+        pop_add_current_code_to_head_and_trigger_load(link_state, block_names, code_lines,
+                                                      dependencies)
+
+      else
+        link_history_push_and_next(
+          curr_block_name: selected[:oname],
+          curr_document_filename: @delegate_object[:filename],
+          inherited_block_names: ((link_state&.inherited_block_names || []) + block_names).sort.uniq,
+          inherited_dependencies: (link_state&.inherited_dependencies || {}).merge(dependencies || {}), ### merge, not replace, key data
+          inherited_lines: code_merge(link_state&.inherited_lines, code_lines),
+          next_block_name: link_block_data['block'] || '',
+          next_document_filename: next_document_filename,
+          next_load_file: next_document_filename == @delegate_object[:filename] ? LoadFile::Reuse : LoadFile::Load
+        )
+      end
     end
 
     # Reads required code blocks from a temporary file specified by an environment variable.
@@ -1210,86 +1273,208 @@ module MarkdownExec
     # Markdown document, obtain approval, and execute the chosen block of code.
     #
     # @return [Nil] Returns nil if no code block is selected or an error occurs.
-    def select_execute_bash_and_special_blocks(_execute: true)
+    def document_menu_loop
       @menu_base_options = @delegate_object
+      link_state, block_name_from_cli, now_using_cli = initialize_selection_states
+      menu_default_dname = nil
+
+      loop do
+        # @bsp 'loop',block_name_from_cli,@cli_block_name
+        block_name_from_cli, now_using_cli, blocks_in_file, menu_blocks, mdoc = \
+          set_delobj_menu_loop_vars(block_name_from_cli, now_using_cli, link_state)
+
+        # cli or user selection
+        #
+        block_state = load_cli_or_user_selected_block(blocks_in_file, menu_blocks,
+                                                      menu_default_dname)
+        if block_state.state == MenuState::EXIT
+          # @bsp 'MenuState::EXIT -> break'
+          break
+        end
+
+        dump_and_warn_block_state(block_state.block)
+        link_state, menu_default_dname = exec_bash_next_state(block_state.block, mdoc,
+                                                              link_state)
+        if prompt_user_exit(block_name_from_cli, block_state.block)
+          # @bsp 'prompt_user_exit -> break'
+          break
+        end
+
+        link_state.block_name, block_name_from_cli, cli_break = \
+          next_state_from_cli(now_using_cli, block_state)
+
+        if cli_break
+          # @bsp 'read_block_name_from_cli + next_link_state -> break'
+          break
+        end
+      end
+    rescue StandardError
+      error_handler('document_menu_loop',
+                    { abort: true })
+    end
+
+    def next_state_from_cli(now_using_cli, block_state)
+      was_using_cli = now_using_cli
+      block_name_from_cli, = read_block_name_from_cli(now_using_cli)
+      block_name, block_name_from_cli, cli_break = \
+        next_link_state(block_name_from_cli, was_using_cli, block_state)
+
+      [block_name, block_name_from_cli, cli_break]
+    end
+
+    def exec_bash_next_state(block_state_block, mdoc, link_state)
+      lfls = execute_shell_type(
+        block_state_block,
+        mdoc,
+        link_state,
+        block_source: { document_filename: @delegate_object[:filename] }
+      )
+
+      # if the same menu is being displayed, collect the display name of the selected menu item for use as the default item
+      [lfls.link_state,
+       lfls.load_file == LoadFile::Load ? nil : block_state_block[:dname]]
+    end
+
+    def set_delobj_menu_loop_vars(block_name_from_cli, now_using_cli, link_state)
+      block_name_from_cli, now_using_cli = \
+        manage_cli_selection_state(block_name_from_cli, now_using_cli, link_state)
+      set_delob_filename_block_name(link_state, block_name_from_cli)
+
+      # update @delegate_object and @menu_base_options in auto_load
+      #
+      blocks_in_file, menu_blocks, mdoc = mdoc_menu_and_blocks_from_nested_files
+      dump_delobj(blocks_in_file, menu_blocks, link_state)
+
+      [block_name_from_cli, now_using_cli, blocks_in_file, menu_blocks, mdoc]
+    end
+
+    # user prompt to exit if the menu will be displayed again
+    #
+    def prompt_user_exit(block_name_from_cli, block_state_block)
+      !block_name_from_cli &&
+        block_state_block[:shell] == BlockType::BASH &&
+        @delegate_object[:pause_after_script_execution] &&
+        prompt_select_continue == MenuState::EXIT
+    end
+
+    def manage_cli_selection_state(block_name_from_cli, now_using_cli, link_state)
+      if block_name_from_cli && @cli_block_name == '.'
+        # @bsp 'pause cli control, allow user to select block'
+        block_name_from_cli = false
+        now_using_cli = false
+        @menu_base_options[:block_name] = \
+          @delegate_object[:block_name] = \
+            link_state.block_name = \
+              @cli_block_name = nil
+      end
+
+      @delegate_object = @menu_base_options.dup
+      @menu_user_clicked_back_link = false
+      [block_name_from_cli, now_using_cli]
+    end
+
+    def next_link_state(block_name_from_cli, was_using_cli, block_state)
+      # @bsp 'next_link_state',block_name_from_cli, was_using_cli, block_state
+      # Set block_name based on block_name_from_cli
+      block_name = block_name_from_cli ? @cli_block_name : nil
+
+      # Determine the state of breaker based on was_using_cli and the block type
+      breaker = !block_name_from_cli && was_using_cli && block_state.block[:shell] == BlockType::BASH
+
+      # Reset block_name_from_cli if the conditions are not met
+      block_name_from_cli ||= false
+
+      [block_name, block_name_from_cli, breaker]
+    end
+
+    # Initialize the selection states for the execution loop.
+    def initialize_selection_states
       link_state = LinkState.new(
         block_name: @delegate_object[:block_name],
         document_filename: @delegate_object[:filename]
       )
+      block_name_from_cli, now_using_cli = handle_cli_block_name(link_state)
+      [link_state, block_name_from_cli, now_using_cli]
+    end
+
+    # Update the state related to CLI block name.
+    #
+    # This method updates the flags indicating whether a CLI block name is being used
+    # and if it was being used previously.
+    #
+    # @param block_name_from_cli [Boolean] Indicates if the block name is from CLI.
+    # @return [Array] Returns the updated state of block name from CLI and its usage.
+    def read_block_name_from_cli(block_name_from_cli)
+      # was_using_cli = block_name_from_cli
+      block_name_from_cli = shift_cli_argument!
+      now_using_cli = block_name_from_cli
+
+      [block_name_from_cli, now_using_cli]
+    end
+
+    # Update the block name in the link state and delegate object.
+    #
+    # This method updates the block name based on whether it was specified
+    # through the CLI or derived from the link state.
+    #
+    # @param link_state [LinkState] The current link state object.
+    # @param block_name_from_cli [Boolean] Indicates if the block name is from CLI.
+    def set_delob_filename_block_name(link_state, block_name_from_cli)
+      @delegate_object[:filename] = link_state.document_filename
+      link_state.block_name = @delegate_object[:block_name] =
+        block_name_from_cli ? @cli_block_name : link_state.block_name
+    end
+
+    # Handle CLI block name and determine the current CLI usage state.
+    #
+    # This method processes the CLI block name from the link state and sets
+    # the initial state for CLI usage.
+    #
+    # @param link_state [LinkState] The current link state object.
+    # @return [Array] Returns the state of block name from CLI and current usage of CLI.
+    def handle_cli_block_name(link_state)
       block_name_from_cli = link_state.block_name.present?
       @cli_block_name = link_state.block_name
-      load_file = nil
-      menu_default_dname = nil
+      now_using_cli = block_name_from_cli
 
-      loop do
-        loop do
-          @delegate_object = @menu_base_options.dup
-          @menu_user_clicked_back_link = false
-          @delegate_object[:filename] = link_state.document_filename
-          link_state.block_name = @delegate_object[:block_name] =
-            block_name_from_cli ? @cli_block_name : link_state.block_name
-
-          blocks_in_file, menu_blocks, mdoc = mdoc_menu_and_blocks_from_nested_files
-
-          if @delegate_object[:dump_blocks_in_file]
-            warn format_and_highlight_dependencies(
-              compact_and_index_hash(blocks_in_file),
-              label: 'blocks_in_file'
-            )
-          end
-          if @delegate_object[:dump_menu_blocks]
-            warn format_and_highlight_dependencies(
-              compact_and_index_hash(menu_blocks),
-              label: 'menu_blocks'
-            )
-          end
-
-          block_state = command_or_user_selected_block(blocks_in_file,
-                                                       menu_blocks, menu_default_dname)
-          return if block_state.state == MenuState::EXIT
+      [block_name_from_cli, now_using_cli]
+    end
 
-          if block_state.block.nil?
-            warn_format('select_execute_bash_and_special_blocks', "Block not found -- #{@delegate_object[:block_name]}",
-                        { abort: true })
-            # error_handler("Block not found -- #{opts[:block_name]}", { abort: true })
-          end
+    # Outputs warnings based on the delegate object's configuration
+    #
+    # @param delegate_object [Hash] The delegate object containing configuration flags.
+    # @param blocks_in_file [Hash] Hash of blocks present in the file.
+    # @param menu_blocks [Hash] Hash of menu blocks.
+    # @param link_state [LinkState] Current state of the link.
+    def dump_delobj(blocks_in_file, menu_blocks, link_state)
+      if @delegate_object[:dump_delegate_object]
+        warn format_and_highlight_hash(@delegate_object, label: '@delegate_object')
+      end
 
-          if @delegate_object[:dump_selected_block]
-            warn block_state.block.to_yaml.sub(/^(?:---\n)?/, "Block:\n")
-          end
+      if @delegate_object[:dump_blocks_in_file]
+        warn format_and_highlight_dependencies(compact_and_index_hash(blocks_in_file),
+                                               label: 'blocks_in_file')
+      end
 
-          load_file_link_state = execute_bash_and_special_blocks(
-            block_state.block,
-            mdoc,
-            link_state,
-            block_source: { document_filename: @delegate_object[:filename] }
-          )
-          load_file = load_file_link_state.load_file
-          link_state = load_file_link_state.link_state
-          # if the same menu is being displayed, collect the display name of the selected menu item for use as the default item
-          menu_default_dname = load_file == LoadFile::Load ? nil : block_state.block[:dname]
+      if @delegate_object[:dump_menu_blocks]
+        warn format_and_highlight_dependencies(compact_and_index_hash(menu_blocks),
+                                               label: 'menu_blocks')
+      end
 
-          # user prompt to exit if the menu will be displayed again
-          #
-          if !block_name_from_cli &&
-             block_state.block[:shell] == BlockType::BASH &&
-             @delegate_object[:pause_after_script_execution] &&
-             prompt_select_continue == MenuState::EXIT
-            return
-          end
+      return unless @delegate_object[:dump_inherited_lines]
 
-          # exit current document/menu if loading next document or single block_name was specified
-          #
-          break if block_state.state == MenuState::CONTINUE && load_file == LoadFile::Load
-          break if block_name_from_cli
-        end
-        break if load_file == LoadFile::Reuse
+      warn format_and_highlight_lines(link_state.inherited_lines, label: 'inherited_lines')
+    end
 
-        block_name_from_cli = pop_cli_argument!
+    def dump_and_warn_block_state(block_state_block)
+      if block_state_block.nil?
+        Exceptions.warn_format("Block not found -- name: #{@delegate_object[:block_name]}",
+                               { abort: true })
       end
-    rescue StandardError
-      error_handler('select_execute_bash_and_special_blocks',
-                    { abort: true })
+
+      return unless @delegate_object[:dump_selected_block]
+
+      warn block_state_block.to_yaml.sub(/^(?:---\n)?/, "Block:\n")
     end
 
     # Presents a TTY prompt to select an option or exit, returns metadata including option and selected
@@ -1406,12 +1591,6 @@ module MarkdownExec
       )
     end
 
-    def update_delegate_and_target(key, value, tgt2)
-      sym_key = key.to_sym
-      @delegate_object[sym_key] = value
-      tgt2[sym_key] = value if tgt2
-    end
-
     # Updates the hierarchy of document headings based on the given line.
     # Utilizes regular expressions to identify heading levels.
     # @param line [String] The line of text to check for headings.
@@ -1487,6 +1666,10 @@ module MarkdownExec
         # add line if it is depth 0 or option allows it
         #
         yield_line_if_selected(line, selected_messages, &block)
+
+      else
+        # @bsp 'line is not recognized for block state'
+
       end
     end
 
@@ -1509,14 +1692,21 @@ module MarkdownExec
     # @param selected [Hash] Selected item from the menu containing a YAML body.
     # @param tgt2 [Hash, nil] An optional target hash to update with YAML data.
     # @return [LoadFileLinkState] An instance indicating the next action for loading files.
-    def update_options_and_trigger_reuse(selected, tgt2 = nil, link_state = LinkState.new)
+    def read_show_options_and_trigger_reuse(selected, link_state = LinkState.new)
+      obj = {}
       data = YAML.load(selected[:body].join("\n"))
       (data || []).each do |key, value|
-        update_delegate_and_target(key, value, tgt2)
+        sym_key = key.to_sym
+        obj[sym_key] = value
+
         print_formatted_option(key, value) if @delegate_object[:menu_opts_set_format].present?
       end
+
       link_state.block_name = nil
-      LoadFileLinkState.new(LoadFile::Reuse, link_state)
+      OpenStruct.new(options: obj,
+                     load_file_link_state: LoadFileLinkState.new(
+                       LoadFile::Reuse, link_state
+                     ))
     end
 
     def wait_for_stream_processing
@@ -1716,6 +1906,7 @@ if $PROGRAM_NAME == __FILE__
         expected_result = LoadFileLinkState.new(LoadFile::Load,
                                                 LinkState.new(block_name: 'sample_block',
                                                               document_filename: 'sample_file',
+                                                              inherited_dependencies: {},
                                                               inherited_lines: []))
         assert_equal expected_result,
                      @hd.push_link_history_and_trigger_load(body, nil, FCB.new(block_name: 'sample_block',
@@ -1904,7 +2095,7 @@ if $PROGRAM_NAME == __FILE__
           @hd.instance_variable_set(:@delegate_object,
                                     { block_name: 'block1' })
 
-          result = @hd.command_or_user_selected_block(all_blocks, [], nil)
+          result = @hd.load_cli_or_user_selected_block(all_blocks, [], nil)
 
           assert_equal all_blocks.first, result.block
           assert_nil result.state
@@ -1915,7 +2106,7 @@ if $PROGRAM_NAME == __FILE__
                                                    :some_state)
           @hd.stubs(:wait_for_user_selected_block).returns(block_state)
 
-          result = @hd.command_or_user_selected_block([], [], nil)
+          result = @hd.load_cli_or_user_selected_block([], [], nil)
 
           assert_equal block_state.block, result.block
           assert_equal :some_state, result.state
@@ -2207,7 +2398,7 @@ if $PROGRAM_NAME == __FILE__
           @selected_item = mock('FCB')
         end
 
-        def test_compile_execute_bash_and_special_blocks_and_trigger_reuse_without_user_approval
+        def test_compile_execute_and_trigger_reuse_without_user_approval
           # Mock the delegate object configuration
           @hd.instance_variable_set(:@delegate_object,
                                     { output_script: false,
@@ -2217,7 +2408,7 @@ if $PROGRAM_NAME == __FILE__
           # Expectations and assertions go here
         end
 
-        def test_compile_execute_bash_and_special_blocks_and_trigger_reuse_with_user_approval
+        def test_compile_execute_and_trigger_reuse_with_user_approval
           # Mock the delegate object configuration
           @hd.instance_variable_set(:@delegate_object,
                                     { output_script: false,
@@ -2227,7 +2418,7 @@ if $PROGRAM_NAME == __FILE__
           # Expectations and assertions go here
         end
 
-        def test_compile_execute_bash_and_special_blocks_and_trigger_reuse_with_output_script
+        def test_compile_execute_and_trigger_reuse_with_output_script
           # Mock the delegate object configuration
           @hd.instance_variable_set(:@delegate_object,
                                     { output_script: true,
@@ -2238,40 +2429,6 @@ if $PROGRAM_NAME == __FILE__
         end
       end
 
-      class TestHashDelegatorHandleOptsBlock < Minitest::Test
-        def setup
-          @hd = HashDelegator.new
-          @hd.instance_variable_set(:@delegate_object,
-                                    { menu_opts_set_format: 'Option: %<key>s, Value: %<value>s',
-                                      menu_opts_set_color: :blue })
-          @hd.stubs(:string_send_color)
-          @hd.stubs(:print)
-        end
-
-        def test_update_options_and_trigger_reuse
-          selected = { body: ['option1: value1'] }
-          tgt2 = {}
-
-          result = @hd.update_options_and_trigger_reuse(selected, tgt2)
-
-          assert_instance_of LoadFileLinkState, result
-          assert_equal 'value1',
-                       @hd.instance_variable_get(:@delegate_object)[:option1]
-          assert_equal 'value1', tgt2[:option1]
-        end
-
-        def test_update_options_and_trigger_reuse_without_format
-          selected = { body: ['option2: value2'] }
-          @hd.instance_variable_set(:@delegate_object, {})
-
-          result = @hd.update_options_and_trigger_reuse(selected)
-
-          assert_instance_of LoadFileLinkState, result
-          assert_equal 'value2',
-                       @hd.instance_variable_get(:@delegate_object)[:option2]
-        end
-      end
-
       # require 'stringio'
 
       class TestHashDelegatorHandleStream < Minitest::Test
@@ -2339,39 +2496,6 @@ if $PROGRAM_NAME == __FILE__
         end
       end
 
-      class TestHashDelegatorLoadAutoBlocks < Minitest::Test
-        def setup
-          @hd = HashDelegator.new
-          @hd.stubs(:block_find).returns({})
-          @hd.stubs(:update_options_and_trigger_reuse)
-        end
-
-        def test_load_auto_blocks_with_new_filename
-          @hd.instance_variable_set(:@delegate_object, {
-                                      document_load_opts_block_name: 'load_block',
-                                      filename: 'new_file'
-                                    })
-          assert @hd.load_auto_blocks([])
-        end
-
-        def test_load_auto_blocks_with_same_filename
-          @hd.instance_variable_set(:@delegate_object, {
-                                      document_load_opts_block_name: 'load_block',
-                                      filename: 'new_file'
-                                    })
-          @hd.instance_variable_set(:@most_recent_loaded_filename, 'new_file')
-          assert_nil @hd.load_auto_blocks([])
-        end
-
-        def test_load_auto_blocks_without_block_name
-          @hd.instance_variable_set(:@delegate_object, {
-                                      document_load_opts_block_name: nil,
-                                      filename: 'new_file'
-                                    })
-          assert_nil @hd.load_auto_blocks([])
-        end
-      end
-
       class TestHashDelegatorMenuChromeColoredOption < Minitest::Test
         def setup
           @hd = HashDelegator.new
@@ -2566,7 +2690,6 @@ if $PROGRAM_NAME == __FILE__
       end
     end
 
-    ####
     class TestHashDelegatorYieldToBlock < Minitest::Test
       def setup
         @hd = HashDelegator.new