markdown_exec 1.8.6 → 1.8.8

data/lib/hash_delegator.rb

@@ -1,6 +1,8 @@
-# encoding=utf-8
+#!/usr/bin/env bundle exec ruby
 # frozen_string_literal: true
 
+# encoding=utf-8
+
 require 'English'
 require 'clipboard'
 require 'fileutils'
@@ -37,6 +39,273 @@ class String
   end
 end
 
+module HashDelegatorSelf
+  # def add_back_option(menu_blocks)
+  #   append_chrome_block(menu_blocks, MenuState::BACK)
+  # end
+
+  # Applies an ANSI color method to a string using a specified color key.
+  # The method retrieves the color method from the provided hash. If the color key
+  # is not present in the hash, it uses a default color method.
+  # @param string [String] The string to be colored.
+  # @param color_methods [Hash] A hash where keys are color names (String/Symbol) and values are color methods.
+  # @param color_key [String, Symbol] The key representing the desired color method in the color_methods hash.
+  # @param default_method [String] (optional) Default color method to use if color_key is not found in color_methods. Defaults to 'plain'.
+  # @return [String] The colored string.
+  def apply_color_from_hash(string, color_methods, color_key, default_method: 'plain')
+    color_method = color_methods.fetch(color_key, default_method).to_sym
+    string.to_s.send(color_method)
+  end
+
+  # # Enhanced `apply_color_from_hash` method to support dynamic color transformations
+  # # @param string [String] The string to be colored.
+  # # @param color_transformations [Hash] A hash mapping color names to lambdas that apply color transformations.
+  # # @param color_key [String, Symbol] The key representing the desired color transformation in the color_transformations hash.
+  # # @param default_transformation [Proc] Default color transformation to use if color_key is not found in color_transformations.
+  # # @return [String] The colored string.
+  # def apply_color_from_hash(string, color_transformations, color_key, default_transformation: ->(str) { str })
+  #   transformation = color_transformations.fetch(color_key.to_sym, default_transformation)
+  #   transformation.call(string)
+  # end
+  # color_transformations = {
+  #   red: ->(str) { "\e[31m#{str}\e[0m" },  # ANSI color code for red
+  #   green: ->(str) { "\e[32m#{str}\e[0m" },  # ANSI color code for green
+  #   # Add more color transformations as needed
+  # }
+  # string = "Hello, World!"
+  # colored_string = apply_color_from_hash(string, color_transformations, :red)
+  # puts colored_string  # This will print the string in red
+
+  # Searches for the first element in a collection where the specified key matches a given value.
+  # This method is particularly useful for finding a specific hash-like object within an enumerable collection.
+  # If no match is found, it returns a specified default value.
+  #
+  # @param blocks [Enumerable] The collection of hash-like objects to search.
+  # @param key [Object] The key to search for in each element of the collection.
+  # @param value [Object] The value to match against each element's corresponding key value.
+  # @param default [Object, nil] The default value to return if no match is found (optional).
+  # @return [Object, nil] The first matching element or the default value if no match is found.
+  def block_find(blocks, key, value, default = nil)
+    blocks.find { |item| item[key] == value } || default
+  end
+
+  def code_merge(*bodies)
+    merge_lists(*bodies)
+  end
+
+  def count_matches_in_lines(lines, regex)
+    lines.count { |line| line.to_s.match(regex) }
+  end
+
+  def create_directory_for_file(file_path)
+    FileUtils.mkdir_p(File.dirname(file_path))
+  end
+
+  # Creates a file at the specified path, writes the given content to it,
+  # and sets file permissions if required. Handles any errors encountered during the process.
+  #
+  # @param file_path [String] The path where the file will be created.
+  # @param content [String] The content to write into the file.
+  # @param chmod_value [Integer] The file permission value to set; skips if zero.
+  def create_file_and_write_string_with_permissions(file_path, content,
+                                                    chmod_value)
+    create_directory_for_file(file_path)
+    File.write(file_path, content)
+    set_file_permissions(file_path, chmod_value) unless chmod_value.zero?
+  rescue StandardError
+    error_handler('create_file_and_write_string_with_permissions')
+  end
+
+  # def create_temp_file
+  #   Dir::Tmpname.create(self.class.to_s) { |path| path }
+  # end
+
+  # Updates the title of an FCB object from its body content if the title is nil or empty.
+  def default_block_title_from_body(fcb)
+    return unless fcb.title.nil? || fcb.title.empty?
+
+    fcb.derive_title_from_body
+  end
+
+  # delete the current line if it is empty and the previous is also empty
+  def delete_consecutive_blank_lines!(blocks_menu)
+    blocks_menu.process_and_conditionally_delete! do |prev_item, current_item, _next_item|
+      prev_item&.fetch(:chrome, nil) && !prev_item&.fetch(:oname).present? &&
+        current_item&.fetch(:chrome, nil) && !current_item&.fetch(:oname).present?
+    end
+  end
+
+  # # Deletes a temporary file specified by an environment variable.
+  # # Checks if the file exists before attempting to delete it and clears the environment variable afterward.
+  # # Any errors encountered during deletion are handled gracefully.
+  # def delete_required_temp_file(temp_blocks_file_path)
+  #   return if temp_blocks_file_path.nil? || temp_blocks_file_path.empty?
+
+  #   HashDelegator.remove_file_without_standard_errors(temp_blocks_file_path)
+  # end
+
+  def error_handler(name = '', opts = {}, error: $!)
+    Exceptions.error_handler(
+      "HashDelegator.#{name} -- #{error}",
+      opts
+    )
+  end
+
+  # # DebugHelper.d ["HDmm method_name: #{method_name}", "#{first_n_caller_items 1}"]
+  # def first_n_caller_items(n)
+  #   call_stack = caller
+  #   base_path = File.realpath('.')
+
+  #   # Modify the call stack to remove the base path and keep only the first n items
+  #   call_stack.take(n + 1)[1..].map do |line|
+  #     " . #{line.sub(/^#{Regexp.escape(base_path)}\//, '')}"
+  #   end.join("\n")
+  # end
+
+  # Formats and returns the execution streams (like stdin, stdout, stderr) for a given key.
+  # It concatenates the array of strings found under the specified key in the run_state's files.
+  #
+  # @param key [Symbol] The key corresponding to the desired execution stream.
+  # @return [String] A concatenated string of the execution stream's contents.
+  def format_execution_streams(key, files = {})
+    (files || {}).fetch(key, []).join
+  end
+
+  # Indents all lines in a given string with a specified indentation string.
+  # @param body [String] A multi-line string to be indented.
+  # @param indent [String] The string used for indentation (default is an empty string).
+  # @return [String] A single string with each line indented as specified.
+  def indent_all_lines(body, indent = nil)
+    return body unless indent&.non_empty?
+
+    body.lines.map { |line| indent + line.chomp }.join("\n")
+  end
+
+  def initialize_fcb_names(fcb)
+    fcb.oname = fcb.dname = fcb.title || ''
+  end
+
+  def merge_lists(*args)
+    # Filters out nil values, flattens the arrays, and ensures an empty list is returned if no valid lists are provided
+    merged = args.compact.flatten
+    merged.empty? ? [] : merged
+  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
+    # &bsp 'block_name:', block_name
+
+    # Determine the state of breaker based on was_using_cli and the block type
+    breaker = !block_name && !block_name_from_cli && was_using_cli && block_state.block[:shell] == BlockType::BASH
+    # &bsp 'breaker:', breaker
+
+    # Reset block_name_from_cli if the conditions are not met
+    block_name_from_cli ||= false
+    # &bsp 'block_name_from_cli:', block_name_from_cli
+
+    [block_name, block_name_from_cli, breaker]
+  end
+
+  def parse_yaml_data_from_body(body)
+    body.any? ? YAML.load(body.join("\n")) : {}
+  end
+
+  # Reads required code blocks from a temporary file specified by an environment variable.
+  # @return [Array<String>] Lines read from the temporary file, or an empty array if file is not found or path is empty.
+  def read_required_blocks_from_temp_file(temp_blocks_file_path)
+    return [] if temp_blocks_file_path.to_s.empty?
+
+    if File.exist?(temp_blocks_file_path)
+      File.readlines(
+        temp_blocks_file_path, chomp: true
+      )
+    else
+      []
+    end
+  end
+
+  def remove_file_without_standard_errors(path)
+    FileUtils.rm_f(path)
+  end
+
+  # Evaluates the given string as Ruby code and rescues any StandardErrors.
+  # If an error occurs, it calls the error_handler method with 'safeval'.
+  # @param str [String] The string to be evaluated.
+  # @return [Object] The result of evaluating the string.
+  def safeval(str)
+    eval(str)
+  rescue StandardError # catches NameError, StandardError
+    error_handler('safeval')
+  end
+
+  def set_file_permissions(file_path, chmod_value)
+    File.chmod(chmod_value, file_path)
+  end
+
+  # Creates a TTY prompt with custom settings. Specifically, it disables the default 'cross' symbol and
+  # defines a lambda function to handle interrupts.
+  # @return [TTY::Prompt] A new TTY::Prompt instance with specified configurations.
+  def tty_prompt_without_disabled_symbol
+    TTY::Prompt.new(
+      interrupt: lambda {
+        puts
+        raise TTY::Reader::InputInterrupt
+      },
+      symbols: { cross: ' ' }
+    )
+  end
+
+  # Updates the attributes of the given fcb object and conditionally yields to a block.
+  # It initializes fcb names and sets the default block title from fcb's body.
+  # If the fcb has a body and meets certain conditions, it yields to the given block.
+  #
+  # @param fcb [Object] The fcb object whose attributes are to be updated.
+  # @param selected_messages [Array<Symbol>] A list of message types to determine if yielding is applicable.
+  # @param block [Block] An optional block to yield to if conditions are met.
+  def update_menu_attrib_yield_selected(fcb, selected_messages, configuration = {}, &block)
+    initialize_fcb_names(fcb)
+    return unless fcb.body
+
+    default_block_title_from_body(fcb)
+    MarkdownExec::Filter.yield_to_block_if_applicable(fcb, selected_messages, configuration,
+                                                      &block)
+  end
+
+  # Writes the provided code blocks to a file.
+  # @param code_blocks [String] Code blocks to write into the file.
+  def write_code_to_file(content, path)
+    File.write(path, content)
+  end
+
+  def write_execution_output_to_file(files, filespec)
+    FileUtils.mkdir_p File.dirname(filespec)
+
+    File.write(
+      filespec,
+      ["-STDOUT-\n",
+       format_execution_streams(ExecutionStreams::StdOut, files),
+       "-STDERR-\n",
+       format_execution_streams(ExecutionStreams::StdErr, files),
+       "-STDIN-\n",
+       format_execution_streams(ExecutionStreams::StdIn, files),
+       "\n"].join
+    )
+  end
+
+  # Yields a line as a new block if the selected message type includes :line.
+  # @param [String] line The line to be processed.
+  # @param [Array<Symbol>] selected_messages A list of message types to check.
+  # @param [Proc] block The block to be called with the line data.
+  def yield_line_if_selected(line, selected_messages, &block)
+    return unless block && selected_messages.include?(:line)
+
+    block.call(:line, MarkdownExec::FCB.new(body: [line]))
+  end
+end
+### require_relative 'hash_delegator_self'
+
 # This module provides methods for compacting and converting data structures.
 module CompactionHelpers
   # Converts an array of key-value pairs into a hash, applying compaction to the values.
@@ -106,11 +375,12 @@ module MarkdownExec
   class HashDelegator
     attr_accessor :most_recent_loaded_filename, :pass_args, :run_state
 
+    extend HashDelegatorSelf
     include CompactionHelpers
 
     def initialize(delegate_object = {})
       @delegate_object = delegate_object
-      @prompt = tty_prompt_without_disabled_symbol
+      @prompt = HashDelegator.tty_prompt_without_disabled_symbol
 
       @most_recent_loaded_filename = nil
       @pass_args = []
@@ -138,11 +408,20 @@ module MarkdownExec
     # along with initial and final dividers, based on the delegate object's configuration.
     #
     # @param menu_blocks [Array] The array of menu block elements to be modified.
-    def add_menu_chrome_blocks!(menu_blocks)
+    def add_menu_chrome_blocks!(menu_blocks, link_state)
       return unless @delegate_object[:menu_link_format].present?
 
+      if @delegate_object[:menu_with_inherited_lines]
+        add_inherited_lines(menu_blocks,
+                            link_state)
+      end
+
+      # back before exit
       add_back_option(menu_blocks) if should_add_back_option?
+
+      # exit after other options
       add_exit_option(menu_blocks) if @delegate_object[:menu_with_exit]
+
       add_dividers(menu_blocks)
     end
 
@@ -152,13 +431,17 @@ module MarkdownExec
       append_chrome_block(menu_blocks, MenuState::BACK)
     end
 
+    def add_dividers(menu_blocks)
+      append_divider(menu_blocks, :initial)
+      append_divider(menu_blocks, :final)
+    end
+
     def add_exit_option(menu_blocks)
       append_chrome_block(menu_blocks, MenuState::EXIT)
     end
 
-    def add_dividers(menu_blocks)
-      append_divider(menu_blocks, :initial)
-      append_divider(menu_blocks, :final)
+    def add_inherited_lines(menu_blocks, link_state)
+      append_inherited_lines(menu_blocks, link_state)
     end
 
     public
@@ -179,7 +462,7 @@ module MarkdownExec
       end
 
       formatted_name = format(@delegate_object[:menu_link_format],
-                              safeval(option_name))
+                              HashDelegator.safeval(option_name))
       chrome_block = FCB.new(
         chrome: true,
         dname: HashDelegator.new(@delegate_object).string_send_color(
@@ -195,6 +478,39 @@ module MarkdownExec
       end
     end
 
+    # Appends a formatted divider to the specified position in a menu block array.
+    # The method checks for the presence of formatting options before appending.
+    #
+    # @param menu_blocks [Array] The array of menu block elements.
+    # @param position [Symbol] The position to insert the divider (:initial or :final).
+    def append_inherited_lines(menu_blocks, link_state, position: top)
+      return unless link_state.inherited_lines.present?
+
+      insert_at_top = @delegate_object[:menu_inherited_lines_at_top]
+      chrome_blocks = link_state.inherited_lines.map do |line|
+        formatted = format(@delegate_object[:menu_inherited_lines_format],
+                           { line: line })
+        FCB.new(
+          chrome: true,
+          disabled: '',
+          dname: HashDelegator.new(@delegate_object).string_send_color(
+            formatted, :menu_inherited_lines_color
+          ),
+          oname: formatted
+        )
+      end
+
+      if insert_at_top
+        # Prepend an array of elements to the beginning
+        menu_blocks.unshift(*chrome_blocks)
+      else
+        # Append an array of elements to the end
+        menu_blocks.concat(chrome_blocks)
+      end
+    rescue StandardError
+      HashDelegator.error_handler('append_inherited_lines')
+    end
+
     # Appends a formatted divider to the specified position in a menu block array.
     # The method checks for the presence of formatting options before appending.
     #
@@ -224,19 +540,6 @@ module MarkdownExec
 
     # private
 
-    # Searches for the first element in a collection where the specified key matches a given value.
-    # This method is particularly useful for finding a specific hash-like object within an enumerable collection.
-    # If no match is found, it returns a specified default value.
-    #
-    # @param blocks [Enumerable] The collection of hash-like objects to search.
-    # @param key [Object] The key to search for in each element of the collection.
-    # @param value [Object] The value to match against each element's corresponding key value.
-    # @param default [Object, nil] The default value to return if no match is found (optional).
-    # @return [Object, nil] The first matching element or the default value if no match is found.
-    def block_find(blocks, key, value, default = nil)
-      blocks.find { |item| item[key] == value } || default
-    end
-
     # Iterates through nested files to collect various types of blocks, including dividers, tasks, and others.
     # The method categorizes blocks based on their type and processes them accordingly.
     #
@@ -246,13 +549,30 @@ module MarkdownExec
       iter_blocks_from_nested_files do |btype, fcb|
         process_block_based_on_type(blocks, btype, fcb)
       end
+      # &bc  'blocks.count:', blocks.count
       blocks
     rescue StandardError
-      error_handler('blocks_from_nested_files')
+      HashDelegator.error_handler('blocks_from_nested_files')
     end
 
     # private
 
+    def calc_logged_stdout_filename
+      return unless @delegate_object[:saved_stdout_folder]
+
+      @delegate_object[:logged_stdout_filename] =
+        SavedAsset.stdout_name(blockname: @delegate_object[:block_name],
+                               filename: File.basename(@delegate_object[:filename],
+                                                       '.*'),
+                               prefix: @delegate_object[:logged_stdout_filename_prefix],
+                               time: Time.now.utc)
+
+      @logged_stdout_filespec =
+        @delegate_object[:logged_stdout_filespec] =
+          File.join @delegate_object[:saved_stdout_folder],
+                    @delegate_object[:logged_stdout_filename]
+    end
+
     def cfile
       @cfile ||= CachedNestedFileReader.new(
         import_pattern: @delegate_object.fetch(:import_pattern) #, "^ *@import +(?<name>.+?) *$")
@@ -273,15 +593,6 @@ module MarkdownExec
       true
     end
 
-    def code_join(*bodies)
-      bc = bodies&.compact
-      bc.count.positive? ? bc.join("\n") : nil
-    end
-
-    def code_merge(*bodies)
-      merge_lists(*bodies)
-    end
-
     # Collects required code lines based on the selected block and the delegate object's configuration.
     # If the block type is VARS, it also sets environment variables based on the block's content.
     #
@@ -292,7 +603,7 @@ module MarkdownExec
       set_environment_variables_for_block(selected) if selected[:shell] == BlockType::VARS
 
       required = mdoc.collect_recursively_required_code(
-        @delegate_object[:block_name],
+        selected[:nickname] || selected[:oname],
         label_format_above: @delegate_object[:shell_code_label_format_above],
         label_format_below: @delegate_object[:shell_code_label_format_below],
         block_source: block_source
@@ -306,13 +617,14 @@ module MarkdownExec
         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])
+                          'unmet_dependencies, flag: runtime_exception_error_level',
+                          required[:unmet_dependencies])
       elsif true
         warn format_and_highlight_dependencies(dependencies,
                                                highlight: [@delegate_object[:block_name]])
       end
 
-      code_merge link_state&.inherited_lines, required[:code]
+      HashDelegator.code_merge(link_state&.inherited_lines, required[:code])
     end
 
     def command_execute(command, args: [])
@@ -320,26 +632,54 @@ module MarkdownExec
       @run_state.options = @delegate_object
       @run_state.started_at = Time.now.utc
 
-      Open3.popen3(@delegate_object[:shell],
-                   '-c', command,
-                   @delegate_object[:filename],
-                   *args) do |stdin, stdout, stderr, exec_thr|
-        handle_stream(stdout, ExecutionStreams::StdOut) do |line|
-          yield nil, line, nil, exec_thr if block_given?
-        end
-        handle_stream(stderr, ExecutionStreams::StdErr) do |line|
-          yield nil, nil, line, exec_thr if block_given?
-        end
+      if @delegate_object[:execute_in_own_window] &&
+         @delegate_object[:execute_command_format].present? &&
+         @run_state.saved_filespec.present?
+        @run_state.in_own_window = true
+        system(
+          format(
+            @delegate_object[:execute_command_format],
+            {
+              batch_index: @run_state.batch_index,
+              batch_random: @run_state.batch_random,
+              block_name: @delegate_object[:block_name],
+              document_filename: File.basename(@delegate_object[:filename]),
+              document_filespec: @delegate_object[:filename],
+              home: Dir.pwd,
+              output_filename: File.basename(@delegate_object[:logged_stdout_filespec]),
+              output_filespec: @delegate_object[:logged_stdout_filespec],
+              script_filename: @run_state.saved_filespec,
+              script_filespec: File.join(Dir.pwd, @run_state.saved_filespec),
+              started_at: @run_state.started_at.strftime(
+                @delegate_object[:execute_command_title_time_format]
+              )
+            }
+          )
+        )
 
-        in_thr = handle_stream($stdin, ExecutionStreams::StdIn) do |line|
-          stdin.puts(line)
-          yield line, nil, nil, exec_thr if block_given?
-        end
+      else
+        @run_state.in_own_window = false
+        Open3.popen3(@delegate_object[:shell],
+                     '-c', command,
+                     @delegate_object[:filename],
+                     *args) do |stdin, stdout, stderr, exec_thr|
+          handle_stream(stdout, ExecutionStreams::StdOut) do |line|
+            yield nil, line, nil, exec_thr if block_given?
+          end
+          handle_stream(stderr, ExecutionStreams::StdErr) do |line|
+            yield nil, nil, line, exec_thr if block_given?
+          end
+
+          in_thr = handle_stream($stdin, ExecutionStreams::StdIn) do |line|
+            stdin.puts(line)
+            yield line, nil, nil, exec_thr if block_given?
+          end
 
-        wait_for_stream_processing
-        exec_thr.join
-        sleep 0.1
-        in_thr.kill if in_thr&.alive?
+          wait_for_stream_processing
+          exec_thr.join
+          sleep 0.1
+          in_thr.kill if in_thr&.alive?
+        end
       end
 
       @run_state.completed_at = Time.now.utc
@@ -363,17 +703,17 @@ module MarkdownExec
       if @delegate_object[:block_name].present?
         block = all_blocks.find do |item|
           item[:oname] == @delegate_object[:block_name]
-        end
+        end&.merge(block_name_from_ui: false)
       else
         block_state = wait_for_user_selected_block(all_blocks, menu_blocks,
                                                    default)
-        block = block_state.block
+        block = block_state.block&.merge(block_name_from_ui: true)
         state = block_state.state
       end
 
       SelectedBlockMenuState.new(block, state)
     rescue StandardError
-      error_handler('load_cli_or_user_selected_block')
+      HashDelegator.error_handler('load_cli_or_user_selected_block')
     end
 
     # This method is responsible for handling the execution of generic blocks in a markdown document.
@@ -388,9 +728,13 @@ module MarkdownExec
                                                    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
+      allow_execution = if @delegate_object[:user_must_approve]
+                          prompt_for_user_approval(required_lines, selected)
+                        else
+                          true
+                        end
 
-      execute_required_lines(required_lines) if allow_execution
+      execute_required_lines(required_lines, selected) if allow_execution
 
       link_state.block_name = nil
       LoadFileLinkState.new(LoadFile::Reuse, link_state)
@@ -411,18 +755,11 @@ module MarkdownExec
     # @return [Integer] The count of fenced code blocks in the file.
     def count_blocks_in_filename
       regex = Regexp.new(@delegate_object[:fenced_start_and_end_regex])
-      lines = cfile.readlines(@delegate_object[:filename])
-      count_matches_in_lines(lines, regex) / 2
-    end
-
-    # private
-
-    def count_matches_in_lines(lines, regex)
-      lines.count { |line| line.to_s.match(regex) }
+      lines = cfile.readlines(@delegate_object[:filename],
+                              import_paths: @delegate_object[:import_paths]&.split(':'))
+      HashDelegator.count_matches_in_lines(lines, regex) / 2
     end
 
-    # private
-
     ##
     # Creates and adds a formatted block to the blocks array based on the provided match and format options.
     # @param blocks [Array] The array of blocks to add the new block to.
@@ -449,13 +786,14 @@ module MarkdownExec
     # @param use_chrome [Boolean] Indicates if the chrome styling should be applied.
     def create_and_add_chrome_blocks(blocks, fcb)
       match_criteria = [
-        { match: :menu_task_match, format: :menu_task_format,
-          color: :menu_task_color },
-        { match: :menu_divider_match, format: :menu_divider_format,
-          color: :menu_divider_color },
-        { match: :menu_note_match, format: :menu_note_format,
-          color: :menu_note_color }
+        { color: :menu_heading1_color, format: :menu_heading1_format, match: :heading1_match },
+        { color: :menu_heading2_color, format: :menu_heading2_format, match: :heading2_match },
+        { color: :menu_heading3_color, format: :menu_heading3_format, match: :heading3_match },
+        { color: :menu_divider_color,  format: :menu_divider_format,  match: :menu_divider_match },
+        { color: :menu_note_color,     format: :menu_note_format,     match: :menu_note_match },
+        { color: :menu_task_color,     format: :menu_task_format,     match: :menu_task_match }
       ]
+      # rubocop:enable Style/UnlessElse
       match_criteria.each do |criteria|
         unless @delegate_object[criteria[:match]].present? &&
                (mbody = fcb.body[0].match @delegate_object[criteria[:match]])
@@ -468,31 +806,10 @@ module MarkdownExec
       end
     end
 
-    # Creates a file at the specified path, writes the given content to it,
-    # and sets file permissions if required. Handles any errors encountered during the process.
-    #
-    # @param file_path [String] The path where the file will be created.
-    # @param content [String] The content to write into the file.
-    # @param chmod_value [Integer] The file permission value to set; skips if zero.
-    def create_file_and_write_string_with_permissions(file_path, content,
-                                                      chmod_value)
-      create_directory_for_file(file_path)
-      File.write(file_path, content)
-      set_file_permissions(file_path, chmod_value) unless chmod_value.zero?
-    rescue StandardError
-      error_handler('create_file_and_write_string_with_permissions')
-    end
-
-    # private
-
-    def create_directory_for_file(file_path)
-      FileUtils.mkdir_p(File.dirname(file_path))
-    end
-
     def create_divider(position)
       divider_key = position == :initial ? :menu_initial_divider : :menu_final_divider
       oname = format(@delegate_object[:menu_divider_format],
-                     safeval(@delegate_object[divider_key]))
+                     HashDelegator.safeval(@delegate_object[divider_key]))
 
       FCB.new(
         chrome: true,
@@ -502,36 +819,27 @@ module MarkdownExec
       )
     end
 
-    # private
-
-    def create_temp_file
-      Dir::Tmpname.create(self.class.to_s) { |path| path }
-    end
-
-    # Updates the title of an FCB object from its body content if the title is nil or empty.
-    def default_block_title_from_body(fcb)
-      return unless fcb.title.nil? || fcb.title.empty?
+    # Prompts user if named block is the same as the prior execution.
+    #
+    # @return [Boolean] Execute the named block.
+    def debounce_allows
+      return true unless @delegate_object[:debounce_execution]
 
-      fcb.derive_title_from_body
-    end
+      # filter block if selected in menu
+      return true if @run_state.block_name_from_cli
 
-    # delete the current line if it is empty and the previous is also empty
-    def delete_consecutive_blank_lines!(blocks_menu)
-      blocks_menu.process_and_conditionally_delete! do |prev_item, current_item, _next_item|
-        prev_item&.fetch(:chrome, nil) && !prev_item&.fetch(:oname).present? &&
-          current_item&.fetch(:chrome, nil) && !current_item&.fetch(:oname).present?
+      # return false if @prior_execution_block == @delegate_object[:block_name]
+      if @prior_execution_block == @delegate_object[:block_name]
+        return @allowed_execution_block == @prior_execution_block || prompt_approve_repeat
       end
-    end
 
-    # Deletes a temporary file specified by an environment variable.
-    # Checks if the file exists before attempting to delete it and clears the environment variable afterward.
-    # Any errors encountered during deletion are handled gracefully.
-    def delete_required_temp_file(temp_blocks_file_path)
-      return if temp_blocks_file_path.nil? || temp_blocks_file_path.empty?
+      @prior_execution_block = @delegate_object[:block_name]
+      @allowed_execution_block = nil
+      true
+    end
 
-      safely_remove_file(temp_blocks_file_path)
-    rescue StandardError
-      error_handler('delete_required_temp_file')
+    def debounce_reset
+      @prior_execution_block = nil
     end
 
     # Determines the state of a selected block in the menu based on the selected option.
@@ -570,14 +878,13 @@ module MarkdownExec
       @delegate_object[:menu_divider_format].present? && @delegate_object[divider_key].present?
     end
 
-    def error_handler(name = '', opts = {})
-      Exceptions.error_handler(
-        "HashDelegator.#{name} -- #{$!}",
-        opts
-      )
-    end
+    def do_save_execution_output
+      return unless @delegate_object[:save_execution_output]
+      return if @run_state.in_own_window
 
-    # public
+      HashDelegator.write_execution_output_to_file(@run_state.files,
+                                                   @delegate_object[:logged_stdout_filespec])
+    end
 
     # Executes a block of code that has been approved for execution.
     # It sets the script block name, writes command files if required, and handles the execution
@@ -585,9 +892,9 @@ module MarkdownExec
     #
     # @param required_lines [Array<String>] The lines of code to be executed.
     # @param selected [FCB] The selected functional code block object.
-    def execute_required_lines(required_lines = [])
-      # set_script_block_name(selected)
-      save_executed_script_if_specified(required_lines)
+    def execute_required_lines(required_lines = [], selected = FCB.new)
+      write_command_file(required_lines, selected) if @delegate_object[:save_executed_script]
+      calc_logged_stdout_filename
       format_and_execute_command(required_lines)
       post_execution_process
     end
@@ -604,21 +911,26 @@ module MarkdownExec
     def execute_shell_type(selected, mdoc, link_state = LinkState.new,
                            block_source:)
       if selected.fetch(:shell, '') == BlockType::LINK
+        debounce_reset
         push_link_history_and_trigger_load(selected.fetch(:body, ''), mdoc, selected,
                                            link_state)
 
       elsif @menu_user_clicked_back_link
+        debounce_reset
         pop_link_history_and_trigger_load
 
       elsif selected[:shell] == BlockType::OPTS
+        debounce_reset
         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
+      elsif debounce_allows
         compile_execute_and_trigger_reuse(mdoc, selected, link_state,
                                           block_source: block_source)
+      else
+        LoadFileLinkState.new(LoadFile::Reuse, link_state)
       end
     end
 
@@ -636,17 +948,6 @@ module MarkdownExec
       string_send_color(data_string, color_sym)
     end
 
-    # DebugHelper.d ["HDmm method_name: #{method_name}", "#{first_n_caller_items 1}"]
-    def first_n_caller_items(n)
-      call_stack = caller
-      base_path = File.realpath('.')
-
-      # Modify the call stack to remove the base path and keep only the first n items
-      call_stack.take(n + 1)[1..].map do |line|
-        " . #{line.sub(/^#{Regexp.escape(base_path)}\//, '')}"
-      end.join("\n")
-    end
-
     def format_and_execute_command(lines)
       formatted_command = lines.flatten.join("\n")
       @fout.fout fetch_color(data_sym: :script_execution_head,
@@ -672,16 +973,6 @@ module MarkdownExec
       string_send_color(formatted_string, color_sym)
     end
 
-    # Formats and returns the execution streams (like stdin, stdout, stderr) for a given key.
-    # It concatenates the array of strings found under the specified key in the run_state's files.
-    #
-    # @param key [Symbol] The key corresponding to the desired execution stream.
-    # @return [String] A concatenated string of the execution stream's contents.
-    def format_execution_streams(key)
-      files = @run_state.files || {}
-      files.fetch(key, []).join
-    end
-
     # Processes a block to generate its summary, modifying its attributes based on various matching criteria.
     # It handles special formatting for bash blocks, extracting and setting properties like call, stdin, stdout, and dname.
     #
@@ -701,17 +992,36 @@ module MarkdownExec
                                                       @delegate_object[:block_stdout_scan])
 
       shell_color_option = SHELL_COLOR_OPTIONS[fcb[:shell]]
-      fcb.title = fcb.oname = bm && bm[1] ? bm[:title] : titlexcall
-      fcb.dname = apply_shell_color_option(fcb.oname, shell_color_option)
 
+      if @delegate_object[:block_name_nick_match].present? && fcb.oname =~ Regexp.new(@delegate_object[:block_name_nick_match])
+        fcb.nickname = $~[0]
+        fcb.title = fcb.oname = format_multiline_body_as_title(fcb.body)
+      else
+        fcb.title = fcb.oname = bm && bm[1] ? bm[:title] : titlexcall
+      end
+
+      fcb.dname = HashDelegator.indent_all_lines(
+        apply_shell_color_option(fcb.oname, shell_color_option),
+        fcb.fetch(:indent, nil)
+      )
       fcb
     end
 
+    # Formats multiline body content as a title string.
+    # indents all but first line with two spaces so it displays correctly in menu
+    # @param body_lines [Array<String>] The lines of body content.
+    # @return [String] Formatted title.
+    def format_multiline_body_as_title(body_lines)
+      body_lines.map.with_index do |line, index|
+        index.zero? ? line : "  #{line}"
+      end.join("\n") + "\n"
+    end
+
     # Updates the delegate object's state based on the provided block state.
     # It sets the block name and determines if the user clicked the back link in the menu.
     #
     # @param block_state [Object] An object representing the state of a block in the menu.
-    def handle_block_state(block_state)
+    def handle_back_or_continue(block_state)
       return if block_state.nil?
       unless [MenuState::BACK,
               MenuState::CONTINUE].include?(block_state.state)
@@ -744,16 +1054,6 @@ module MarkdownExec
       end
     end
 
-    # Indents all lines in a given string with a specified indentation string.
-    # @param body [String] A multi-line string to be indented.
-    # @param indent [String] The string used for indentation (default is an empty string).
-    # @return [String] A single string with each line indented as specified.
-    def indent_all_lines(body, indent = nil)
-      return body unless indent&.non_empty?
-
-      body.lines.map { |line| indent + line.chomp }.join("\n")
-    end
-
     # Initializes variables for regex and other states
     def initial_state
       {
@@ -769,28 +1069,6 @@ module MarkdownExec
       }
     end
 
-    def initialize_and_save_execution_output
-      return unless @delegate_object[:save_execution_output]
-
-      @delegate_object[:logged_stdout_filename] =
-        SavedAsset.stdout_name(blockname: @delegate_object[:block_name],
-                               filename: File.basename(@delegate_object[:filename],
-                                                       '.*'),
-                               prefix: @delegate_object[:logged_stdout_filename_prefix],
-                               time: Time.now.utc)
-
-      @logged_stdout_filespec =
-        @delegate_object[:logged_stdout_filespec] =
-          File.join @delegate_object[:saved_stdout_folder],
-                    @delegate_object[:logged_stdout_filename]
-      @logged_stdout_filespec = @delegate_object[:logged_stdout_filespec]
-      write_execution_output_to_file
-    end
-
-    def initialize_fcb_names(fcb)
-      fcb.oname = fcb.dname = fcb.title || ''
-    end
-
     # Iterates through blocks in a file, applying the provided block to each line.
     # The iteration only occurs if the file exists.
     # @yield [Symbol] :filter Yields to obtain selected messages for processing.
@@ -799,8 +1077,8 @@ module MarkdownExec
 
       state = initial_state
       selected_messages = yield :filter
-
-      cfile.readlines(@delegate_object[:filename]).each do |nested_line|
+      cfile.readlines(@delegate_object[:filename],
+                      import_paths: @delegate_object[:import_paths]&.split(':')).each do |nested_line|
         if nested_line
           update_line_and_block_state(nested_line, state, selected_messages,
                                       &block)
@@ -808,6 +1086,65 @@ module MarkdownExec
       end
     end
 
+    def link_block_data_eval(link_state, code_lines, selected, link_block_data)
+      all_code = HashDelegator.code_merge(link_state&.inherited_lines, code_lines)
+
+      if link_block_data.fetch(LinkDataKeys::Exec, false)
+        @run_state.files = Hash.new([])
+        output_lines = []
+
+        Open3.popen3(
+          @delegate_object[:shell],
+          '-c', all_code.join("\n")
+        ) do |stdin, stdout, stderr, _exec_thr|
+          handle_stream(stdout, ExecutionStreams::StdOut) do |line|
+            output_lines.push(line)
+          end
+          handle_stream(stderr, ExecutionStreams::StdErr) do |line|
+            output_lines.push(line)
+          end
+
+          in_thr = handle_stream($stdin, ExecutionStreams::StdIn) do |line|
+            stdin.puts(line)
+          end
+
+          wait_for_stream_processing
+          sleep 0.1
+          in_thr.kill if in_thr&.alive?
+        end
+
+        ## select output_lines that look like assignment or match other specs
+        #
+        output_lines = process_string_array(
+          output_lines,
+          begin_pattern: @delegate_object.fetch(:output_assignment_begin, nil),
+          end_pattern: @delegate_object.fetch(:output_assignment_end, nil),
+          scan1: @delegate_object.fetch(:output_assignment_match, nil),
+          format1: @delegate_object.fetch(:output_assignment_format, nil)
+        )
+
+      else
+        output_lines = `#{all_code.join("\n")}`.split("\n")
+      end
+
+      unless output_lines
+        HashDelegator.error_handler('all_code eval output_lines is nil', { abort: true })
+      end
+
+      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 }
+
+      [label_format_above && format(label_format_above,
+                                    block_source.merge({ block_name: selected[:oname] }))] +
+        output_lines.map do |line|
+          re = Regexp.new(link_block_data.fetch('pattern', '(?<line>.*)'))
+          re.gsub_format(line, link_block_data.fetch('format', '%{line}')) if re =~ line
+        end.compact +
+        [label_format_below && format(label_format_below,
+                                      block_source.merge({ block_name: selected[:oname] }))]
+    end
+
     def link_history_push_and_next(
       curr_block_name:, curr_document_filename:,
       inherited_block_names:, inherited_dependencies:, inherited_lines:,
@@ -845,7 +1182,7 @@ module MarkdownExec
         return
       end
 
-      block = block_find(all_blocks, :oname, block_name)
+      block = HashDelegator.block_find(all_blocks, :oname, block_name)
       return unless block
 
       options_state = read_show_options_and_trigger_reuse(block)
@@ -866,7 +1203,7 @@ module MarkdownExec
 
     ## Handles the file loading and returns the blocks in the file and MDoc instance
     #
-    def mdoc_menu_and_blocks_from_nested_files
+    def mdoc_menu_and_blocks_from_nested_files(link_state)
       all_blocks, mdoc = mdoc_and_blocks_from_nested_files
 
       # recreate menu with new options
@@ -874,8 +1211,9 @@ module MarkdownExec
       all_blocks, mdoc = mdoc_and_blocks_from_nested_files if load_auto_blocks(all_blocks)
 
       menu_blocks = mdoc.fcbs_per_options(@delegate_object)
-      add_menu_chrome_blocks!(menu_blocks)
-      delete_consecutive_blank_lines!(menu_blocks) if true ### compress empty lines
+      add_menu_chrome_blocks!(menu_blocks, link_state)
+      ### compress empty lines
+      HashDelegator.delete_consecutive_blank_lines!(menu_blocks) if true
       [all_blocks, menu_blocks, mdoc]
     end
 
@@ -894,7 +1232,7 @@ module MarkdownExec
     # @param option_symbol [Symbol] The symbol key for the menu option in the delegate object.
     # @return [String] The formatted or original value of the menu option.
     def menu_chrome_formatted_option(option_symbol = :menu_option_back_name)
-      option_value = safeval(@delegate_object.fetch(option_symbol, ''))
+      option_value = HashDelegator.safeval(@delegate_object.fetch(option_symbol, ''))
 
       if @delegate_object[:menu_chrome_format]
         format(@delegate_object[:menu_chrome_format], option_value)
@@ -903,12 +1241,6 @@ module MarkdownExec
       end
     end
 
-    def merge_lists(*args)
-      # Filters out nil values, flattens the arrays, and ensures an empty list is returned if no valid lists are provided
-      merged = args.compact.flatten
-      merged.empty? ? [] : merged
-    end
-
     # If a method is missing, treat it as a key for the @delegate_object.
     def method_missing(method_name, *args, &block)
       if @delegate_object.respond_to?(method_name)
@@ -921,17 +1253,13 @@ module MarkdownExec
       end
     end
 
-    def shift_cli_argument!
-      return false unless @menu_base_options[:input_cli_rest].present?
+    def shift_cli_argument
+      return true unless @menu_base_options[:input_cli_rest].present?
 
       @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
+      false
     end
 
-    # private
-
     def output_color_formatted(data_sym, color_sym)
       formatted_string = string_send_color(@delegate_object[data_sym],
                                            color_sym)
@@ -984,29 +1312,38 @@ module MarkdownExec
       ), level: level
     end
 
-    # private
-
-    def parse_yaml_data_from_body(body)
-      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)
+    def pop_add_current_code_to_head_and_trigger_load(link_state, block_names, code_lines,
+                                                      dependencies, selected)
       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)
+      if pop.document_filename
+        next_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:
+           HashDelegator.code_merge(pop.inherited_lines, code_lines)
+        )
+        @link_history.push(next_state)
 
-      next_link_state.block_name = nil
-      LoadFileLinkState.new(LoadFile::Load, next_link_state)
+        next_state.block_name = nil
+        LoadFileLinkState.new(LoadFile::Load, next_state)
+      else
+        # no history exists; must have been called independently => retain script
+        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: HashDelegator.code_merge(link_state&.inherited_lines, code_lines),
+          next_block_name: '', # not link_block_data['block'] || ''
+          next_document_filename: @delegate_object[:filename], # not next_document_filename
+          next_load_file: LoadFile::Reuse # not next_document_filename == @delegate_object[:filename] ? LoadFile::Reuse : LoadFile::Load
+        )
+        # LoadFileLinkState.new(LoadFile::Reuse, link_state)
+      end
     end
 
     # This method handles the back-link operation in the Markdown execution context.
@@ -1025,7 +1362,7 @@ module MarkdownExec
     end
 
     def post_execution_process
-      initialize_and_save_execution_output
+      do_save_execution_output
       output_execution_summary
       output_execution_result
     end
@@ -1041,7 +1378,7 @@ module MarkdownExec
                                              %i[block_name_include_match block_name_wrapper_match])
 
         fcb.merge!(
-          name: indent_all_lines(fcb.dname, fcb.fetch(:indent, nil)),
+          name: fcb.dname,
           label: BlockLabel.make(
             body: fcb[:body],
             filename: @delegate_object[:filename],
@@ -1071,11 +1408,63 @@ module MarkdownExec
       when :filter
         %i[blocks line]
       when :line
-        unless @delegate_object[:no_chrome]
-          create_and_add_chrome_blocks(blocks,
-                                       fcb)
+        create_and_add_chrome_blocks(blocks, fcb) unless @delegate_object[:no_chrome]
+      end
+    end
+
+    def process_string_array(arr, begin_pattern: nil, end_pattern: nil, scan1: nil,
+                             format1: nil)
+      in_block = !begin_pattern.present?
+      collected_lines = []
+
+      arr.each do |line|
+        if in_block
+          if end_pattern.present? && line.match?(end_pattern)
+            in_block = false
+          elsif scan1.present?
+            if format1.present?
+              caps = extract_named_captures_from_option(line, scan1)
+              if caps
+                formatted = format(format1, caps)
+                collected_lines << formatted
+              end
+            else
+              caps = line.match(scan1)
+              if caps
+                formatted = caps[0]
+                collected_lines << formatted
+              end
+            end
+          else
+            collected_lines << line
+          end
+        elsif begin_pattern.present? && line.match?(begin_pattern)
+          in_block = true
         end
       end
+
+      collected_lines
+    end
+
+    def prompt_approve_repeat
+      sel = @prompt.select(
+        string_send_color(@delegate_object[:prompt_debounce],
+                          :prompt_color_after_script_execution),
+        default: @delegate_object[:prompt_no],
+        filter: true,
+        quiet: true
+      ) do |menu|
+        menu.choice @delegate_object[:prompt_yes]
+        menu.choice @delegate_object[:prompt_no]
+        menu.choice @delegate_object[:prompt_uninterrupted]
+      end
+      return false if sel == @delegate_object[:prompt_no]
+      return true if sel == @delegate_object[:prompt_yes]
+
+      @allowed_execution_block = @prior_execution_block
+      true
+    rescue TTY::Reader::InputInterrupt
+      exit 1
     end
 
     ##
@@ -1093,7 +1482,7 @@ module MarkdownExec
     #
     # @return [Boolean] Returns true if the user approves (selects 'Yes'), false otherwise.
     ##
-    def prompt_for_user_approval(required_lines)
+    def prompt_for_user_approval(required_lines, selected)
       # Present a selection menu for user approval.
       sel = @prompt.select(
         string_send_color(@delegate_object[:prompt_approve_block],
@@ -1113,7 +1502,7 @@ module MarkdownExec
       if sel == MenuOptions::SCRIPT_TO_CLIPBOARD
         copy_to_clipboard(required_lines)
       elsif sel == MenuOptions::SAVE_SCRIPT
-        save_to_file(required_lines)
+        save_to_file(required_lines, selected)
       end
 
       sel == MenuOptions::YES
@@ -1148,12 +1537,13 @@ module MarkdownExec
     # @return [LoadFileLinkState] Object indicating the next action for file loading.
     def push_link_history_and_trigger_load(link_block_body, mdoc, selected,
                                            link_state = LinkState.new)
-      link_block_data = parse_yaml_data_from_body(link_block_body)
+      link_block_data = HashDelegator.parse_yaml_data_from_body(link_block_body)
 
       # load key and values from link block into current environment
       #
       (link_block_data['vars'] || []).each do |(key, value)|
         ENV[key] = value.to_s
+        ### add to inherited_lines
       end
 
       ## collect blocks specified by block
@@ -1175,31 +1565,22 @@ module MarkdownExec
       end
       next_document_filename = link_block_data['file'] || @delegate_object[:filename]
 
-      # if an eval link block, evaluate code_lines and return its standard output
+      ## append blocks loaded per LinkDataKeys::Load
       #
-      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] }))]
-
+      if (load_filespec = link_block_data.fetch(LinkDataKeys::Load, '')).present?
+        code_lines += File.readlines(load_filespec, chomp: true)
       end
 
-      if link_block_data['return']
+      # if an eval link block, evaluate code_lines and return its standard output
+      #
+      if link_block_data.fetch(LinkDataKeys::Eval,
+                               false) || link_block_data.fetch(LinkDataKeys::Exec, false)
+        code_lines = link_block_data_eval(link_state, code_lines, selected, link_block_data)
+      end
+
+      if link_block_data[LinkDataKeys::Return]
         pop_add_current_code_to_head_and_trigger_load(link_state, block_names, code_lines,
-                                                      dependencies)
+                                                      dependencies, selected)
 
       else
         link_history_push_and_next(
@@ -1207,7 +1588,7 @@ module MarkdownExec
           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),
+          inherited_lines: HashDelegator.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
@@ -1215,20 +1596,6 @@ module MarkdownExec
       end
     end
 
-    # Reads required code blocks from a temporary file specified by an environment variable.
-    # @return [Array<String>] Lines read from the temporary file, or an empty array if file is not found or path is empty.
-    def read_required_blocks_from_temp_file(temp_blocks_file_path)
-      return [] if temp_blocks_file_path.to_s.empty?
-
-      if File.exist?(temp_blocks_file_path)
-        File.readlines(
-          temp_blocks_file_path, chomp: true
-        )
-      else
-        []
-      end
-    end
-
     def runtime_exception(exception_sym, name, items)
       if @delegate_object[exception_sym] != 0
         data = { name: name, detail: items.join(', ') }
@@ -1248,22 +1615,8 @@ module MarkdownExec
       exit @delegate_object[exception_sym]
     end
 
-    def safely_remove_file(path)
-      FileUtils.rm_f(path)
-    end
-
-    # Evaluates the given string as Ruby code and rescues any StandardErrors.
-    # If an error occurs, it calls the error_handler method with 'safeval'.
-    # @param str [String] The string to be evaluated.
-    # @return [Object] The result of evaluating the string.
-    def safeval(str)
-      eval(str)
-    rescue StandardError
-      error_handler('safeval')
-    end
-
-    def save_to_file(required_lines)
-      write_command_file(required_lines)
+    def save_to_file(required_lines, selected)
+      write_command_file(required_lines, selected)
       @fout.fout "File saved: #{@run_state.saved_filespec}"
     end
 
@@ -1275,51 +1628,57 @@ module MarkdownExec
     # @return [Nil] Returns nil if no code block is selected or an error occurs.
     def document_menu_loop
       @menu_base_options = @delegate_object
-      link_state, block_name_from_cli, now_using_cli = initialize_selection_states
+      link_state = LinkState.new(
+        block_name: @delegate_object[:block_name],
+        document_filename: @delegate_object[:filename]
+      )
+      @run_state.block_name_from_cli = link_state.block_name.present?
+      @cli_block_name = link_state.block_name
+      now_using_cli = @run_state.block_name_from_cli
       menu_default_dname = nil
 
+      @run_state.batch_random = Random.new.rand
+      @run_state.batch_index = 0
+
       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)
+        @run_state.batch_index += 1
+        @run_state.in_own_window = false
+
+        # &bsp 'loop', block_name_from_cli, @cli_block_name
+        @run_state.block_name_from_cli, now_using_cli, blocks_in_file, menu_blocks, mdoc = \
+          set_delobj_menu_loop_vars(@run_state.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'
+        # &bsp '@run_state.block_name_from_cli:',@run_state.block_name_from_cli
+        if !block_state
+          HashDelegator.error_handler('block_state missing', { abort: true })
+        elsif block_state.state == MenuState::EXIT
+          # &bsp 'load_cli_or_user_selected_block -> 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'
+        if prompt_user_exit(@run_state.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)
+        link_state.block_name, @run_state.block_name_from_cli, cli_break = \
+          HashDelegator.next_link_state(!shift_cli_argument, now_using_cli, block_state)
 
-        if cli_break
-          # @bsp 'read_block_name_from_cli + next_link_state -> break'
+        if !block_state.block[:block_name_from_ui] && cli_break
+          # &bsp '!block_name_from_ui + cli_break -> 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]
+      HashDelegator.error_handler('document_menu_loop',
+                                  { abort: true })
     end
 
     def exec_bash_next_state(block_state_block, mdoc, link_state)
@@ -1342,7 +1701,7 @@ module MarkdownExec
 
       # update @delegate_object and @menu_base_options in auto_load
       #
-      blocks_in_file, menu_blocks, mdoc = mdoc_menu_and_blocks_from_nested_files
+      blocks_in_file, menu_blocks, mdoc = mdoc_menu_and_blocks_from_nested_files(link_state)
       dump_delobj(blocks_in_file, menu_blocks, link_state)
 
       [block_name_from_cli, now_using_cli, blocks_in_file, menu_blocks, mdoc]
@@ -1358,8 +1717,8 @@ module MarkdownExec
     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'
+      if block_name_from_cli && @cli_block_name == @menu_base_options[:menu_persist_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] = \
@@ -1373,45 +1732,6 @@ module MarkdownExec
       [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
@@ -1425,21 +1745,6 @@ module MarkdownExec
         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
-      now_using_cli = block_name_from_cli
-
-      [block_name_from_cli, now_using_cli]
-    end
-
     # Outputs warnings based on the delegate object's configuration
     #
     # @param delegate_object [Hash] The delegate object containing configuration flags.
@@ -1482,11 +1787,16 @@ module MarkdownExec
       selection = @prompt.select(prompt_text,
                                  names,
                                  opts.merge(filter: true))
+
       item = if names.first.instance_of?(String)
                { dname: selection }
              else
                names.find { |item| item[:dname] == selection }
              end
+      unless item
+        HashDelegator.error_handler('select_option_with_metadata', error: 'menu item not found')
+        exit 1
+      end
 
       item.merge(
         if selection == menu_chrome_colored_option(:menu_option_back_name)
@@ -1500,11 +1810,11 @@ module MarkdownExec
     rescue TTY::Reader::InputInterrupt
       exit 1
     rescue StandardError
-      error_handler('select_option_with_metadata')
+      HashDelegator.error_handler('select_option_with_metadata')
     end
 
     def set_environment_variables_for_block(selected)
-      YAML.load(selected[:body].join("\n")).each do |key, value|
+      YAML.load(selected[:body].join("\n"))&.each do |key, value|
         ENV[key] = value.to_s
         next unless @delegate_object[:menu_vars_set_format].present?
 
@@ -1514,22 +1824,8 @@ module MarkdownExec
       end
     end
 
-    def set_environment_variables_per_array(vars)
-      vars ||= []
-      vars.each { |key, value| ENV[key] = value.to_s }
-    end
-
-    def set_file_permissions(file_path, chmod_value)
-      File.chmod(chmod_value, file_path)
-    end
-
-    def set_script_block_name(selected)
-      @run_state.script_block_name = selected[:oname]
-    end
-
     def should_add_back_option?
       @delegate_object[:menu_with_back] && @link_history.prior_state_exist?
-      # @delegate_object[:menu_with_back] && link_history_prior_state_exist?
     end
 
     # Initializes a new fenced code block (FCB) object based on the provided line and heading information.
@@ -1547,13 +1843,22 @@ module MarkdownExec
         !name.match(Regexp.new(@delegate_object[:block_name_wrapper_match]))
       end
 
+      dname = oname = title = ''
+      nickname = nil
+      if @delegate_object[:block_name_nick_match].present? && oname =~ Regexp.new(@delegate_object[:block_name_nick_match])
+        nickname = $~[0]
+      else
+        dname = oname = title = fcb_title_groups.fetch(:name, '')
+      end
+
       MarkdownExec::FCB.new(
         body: [],
         call: rest.match(Regexp.new(@delegate_object[:block_calls_scan]))&.to_a&.first,
-        dname: fcb_title_groups.fetch(:name, ''),
+        dname: dname,
         headings: headings,
         indent: fcb_title_groups.fetch(:indent, ''),
-        oname: fcb_title_groups.fetch(:name, ''),
+        nickname: nickname,
+        oname: oname,
         reqs: reqs,
         shell: fcb_title_groups.fetch(:shell, ''),
         stdin: if (tn = rest.match(/<(?<type>\$)?(?<name>[A-Za-z_-]\S+)/))
@@ -1562,7 +1867,7 @@ module MarkdownExec
         stdout: if (tn = rest.match(/>(?<type>\$)?(?<name>[A-Za-z_\-.\w]+)/))
                   tn.named_captures.sym_keys
                 end,
-        title: fcb_title_groups.fetch(:name, ''),
+        title: title,
         wraps: wraps
       )
     end
@@ -1573,44 +1878,8 @@ module MarkdownExec
     # @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 @delegate_object.
     # @return [String] The string with the applied color method.
-    def string_send_color(string, color_sym, default: 'plain')
-      color_method = @delegate_object.fetch(color_sym, default).to_sym
-      string.to_s.send(color_method)
-    end
-
-    # Creates a TTY prompt with custom settings. Specifically, it disables the default 'cross' symbol and
-    # defines a lambda function to handle interrupts.
-    # @return [TTY::Prompt] A new TTY::Prompt instance with specified configurations.
-    def tty_prompt_without_disabled_symbol
-      TTY::Prompt.new(
-        interrupt: lambda {
-          puts
-          raise TTY::Reader::InputInterrupt
-        },
-        symbols: { cross: ' ' }
-      )
-    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.
-    # @param headings [Array<String>] Current headings hierarchy.
-    # @return [Array<String>] Updated headings hierarchy.
-    def update_document_headings(line, headings)
-      heading3_match = Regexp.new(@delegate_object[:heading3_match])
-      heading2_match = Regexp.new(@delegate_object[:heading2_match])
-      heading1_match = Regexp.new(@delegate_object[:heading1_match])
-
-      case line
-      when heading3_match
-        [headings[0], headings[1], $~[:name]]
-      when heading2_match
-        [headings[0], $~[:name]]
-      when heading1_match
-        [$~[:name]]
-      else
-        headings
-      end
+    def string_send_color(string, color_sym)
+      HashDelegator.apply_color_from_hash(string, @delegate_object, color_sym)
     end
 
     ##
@@ -1635,16 +1904,12 @@ module MarkdownExec
     def update_line_and_block_state(nested_line, state, selected_messages,
                                     &block)
       line = nested_line.to_s
-      if @delegate_object[:menu_blocks_with_headings]
-        state[:headings] = update_document_headings(line, state[:headings])
-      end
-
       if line.match(@delegate_object[:fenced_start_and_end_regex])
         if state[:in_fenced_block]
           ## end of code block
           #
-          update_menu_attrib_yield_selected(state[:fcb], selected_messages,
-                                            &block)
+          HashDelegator.update_menu_attrib_yield_selected(state[:fcb], selected_messages, @delegate_object,
+                                                          &block)
           state[:in_fenced_block] = false
         else
           ## start of code block
@@ -1665,29 +1930,14 @@ module MarkdownExec
       elsif nested_line[:depth].zero? || @delegate_object[:menu_include_imported_notes]
         # add line if it is depth 0 or option allows it
         #
-        yield_line_if_selected(line, selected_messages, &block)
+        HashDelegator.yield_line_if_selected(line, selected_messages, &block)
 
       else
-        # @bsp 'line is not recognized for block state'
+        # &bsp 'line is not recognized for block state'
 
       end
     end
 
-    # Updates the attributes of the given fcb object and conditionally yields to a block.
-    # It initializes fcb names and sets the default block title from fcb's body.
-    # If the fcb has a body and meets certain conditions, it yields to the given block.
-    #
-    # @param fcb [Object] The fcb object whose attributes are to be updated.
-    # @param selected_messages [Array<Symbol>] A list of message types to determine if yielding is applicable.
-    # @param block [Block] An optional block to yield to if conditions are met.
-    def update_menu_attrib_yield_selected(fcb, selected_messages, &block)
-      initialize_fcb_names(fcb)
-      return unless fcb.body
-
-      default_block_title_from_body(fcb)
-      yield_to_block_if_applicable(fcb, selected_messages, &block)
-    end
-
     # Processes YAML data from the selected menu item, updating delegate objects and optionally printing formatted output.
     # @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.
@@ -1717,10 +1967,10 @@ module MarkdownExec
 
     def wait_for_user_selected_block(all_blocks, menu_blocks, default)
       block_state = wait_for_user_selection(all_blocks, menu_blocks, default)
-      handle_block_state(block_state)
+      handle_back_or_continue(block_state)
       block_state
     rescue StandardError
-      error_handler('wait_for_user_selected_block')
+      HashDelegator.error_handler('wait_for_user_selected_block')
     end
 
     def wait_for_user_selection(_all_blocks, menu_blocks, default)
@@ -1746,15 +1996,17 @@ module MarkdownExec
     end
 
     # Handles the core logic for generating the command file's metadata and content.
-    def write_command_file(required_lines)
+    def write_command_file(required_lines, selected)
       return unless @delegate_object[:save_executed_script]
 
       time_now = Time.now.utc
       @run_state.saved_script_filename =
-        SavedAsset.script_name(blockname: @delegate_object[:block_name],
-                               filename: @delegate_object[:filename],
-                               prefix: @delegate_object[:saved_script_filename_prefix],
-                               time: time_now)
+        SavedAsset.script_name(
+          blockname: selected[:nickname] || selected[:oname],
+          filename: @delegate_object[:filename],
+          prefix: @delegate_object[:saved_script_filename_prefix],
+          time: time_now
+        )
       @run_state.saved_filespec =
         File.join(@delegate_object[:saved_script_folder],
                   @run_state.saved_script_filename)
@@ -1771,32 +2023,13 @@ module MarkdownExec
                 "# time: #{time_now}\n" \
                 "#{required_lines.flatten.join("\n")}\n"
 
-      create_file_and_write_string_with_permissions(
+      HashDelegator.create_file_and_write_string_with_permissions(
         @run_state.saved_filespec,
         content,
         @delegate_object[:saved_script_chmod]
       )
     rescue StandardError
-      error_handler('write_command_file')
-    end
-
-    def save_executed_script_if_specified(lines)
-      write_command_file(lines) if @delegate_object[:save_executed_script]
-    end
-
-    def write_execution_output_to_file
-      FileUtils.mkdir_p File.dirname(@delegate_object[:logged_stdout_filespec])
-
-      File.write(
-        @delegate_object[:logged_stdout_filespec],
-        ["-STDOUT-\n",
-         format_execution_streams(ExecutionStreams::StdOut),
-         "-STDERR-\n",
-         format_execution_streams(ExecutionStreams::StdErr),
-         "-STDIN-\n",
-         format_execution_streams(ExecutionStreams::StdIn),
-         "\n"].join
-      )
+      HashDelegator.error_handler('write_command_file')
     end
 
     # Writes required code blocks to a temporary file and sets an environment variable with its path.
@@ -1814,912 +2047,858 @@ module MarkdownExec
              []
            end
 
-      code_blocks = (read_required_blocks_from_temp_file(import_filename) +
+      code_blocks = (HashDelegator.read_required_blocks_from_temp_file(import_filename) +
                      c1).join("\n")
 
-      write_code_to_file(code_blocks, temp_file_path)
+      HashDelegator.write_code_to_file(code_blocks, temp_file_path)
     end
+  end
+end
+
+return if $PROGRAM_NAME != __FILE__
+
+require 'bundler/setup'
+Bundler.require(:default)
+
+require 'minitest/autorun'
+require 'mocha/minitest'
 
-    # Writes the provided code blocks to a file.
-    # @param code_blocks [String] Code blocks to write into the file.
-    def write_code_to_file(content, path)
-      File.write(path, content)
+module MarkdownExec
+  class TestHashDelegator < Minitest::Test
+    def setup
+      @hd = HashDelegator.new
+      @mdoc = mock('MarkdownDocument')
+    end
+
+    def test_calling_execute_required_lines_calls_command_execute_with_argument_args_value
+      pigeon = 'E'
+      obj = {
+        output_execution_label_format: '',
+        output_execution_label_name_color: 'plain',
+        output_execution_label_value_color: 'plain'
+      }
+
+      c = MarkdownExec::HashDelegator.new(obj)
+      c.pass_args = pigeon
+
+      # Expect that method opts_command_execute is called with argument args having value pigeon
+      c.expects(:command_execute).with(
+        '',
+        args: pigeon
+      )
+
+      # Call method opts_execute_required_lines
+      c.execute_required_lines
     end
 
-    # Yields a line as a new block if the selected message type includes :line.
-    # @param [String] line The line to be processed.
-    # @param [Array<Symbol>] selected_messages A list of message types to check.
-    # @param [Proc] block The block to be called with the line data.
-    def yield_line_if_selected(line, selected_messages, &block)
-      return unless block && selected_messages.include?(:line)
+    # Test case for empty body
+    def test_push_link_history_and_trigger_load_with_empty_body
+      assert_equal LoadFile::Reuse,
+                   @hd.push_link_history_and_trigger_load([], nil, FCB.new).load_file
+    end
 
-      block.call(:line, FCB.new(body: [line]))
+    # Test case for non-empty body without 'file' key
+    def test_push_link_history_and_trigger_load_without_file_key
+      body = ["vars:\n  KEY: VALUE"]
+      assert_equal LoadFile::Reuse,
+                   @hd.push_link_history_and_trigger_load(body, nil, FCB.new).load_file
     end
 
-    # Yields to the provided block with specified parameters if certain conditions are met.
-    # The method checks if a block is given, if the selected_messages include :blocks,
-    # and if the fcb_select? method from MarkdownExec::Filter returns true for the given fcb.
-    #
-    # @param fcb [Object] The object to be evaluated and potentially passed to the block.
-    # @param selected_messages [Array<Symbol>] A collection of message types, one of which must be :blocks.
-    # @param block [Block] A block to be called if conditions are met.
-    def yield_to_block_if_applicable(fcb, selected_messages, &block)
-      if block_given? && selected_messages.include?(:blocks) &&
-         MarkdownExec::Filter.fcb_select?(@delegate_object, fcb)
-        block.call :blocks, fcb
-      end
+    # Test case for non-empty body with 'file' key
+    def test_push_link_history_and_trigger_load_with_file_key
+      body = ["file: sample_file\nblock: sample_block\nvars:\n  KEY: VALUE"]
+      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',
+                                                                             filename: 'sample_file'))
     end
-  end
-end
 
-if $PROGRAM_NAME == __FILE__
-  require 'bundler/setup'
-  Bundler.require(:default)
+    def test_indent_all_lines_with_indent
+      body = "Line 1\nLine 2"
+      indent = '  ' # Two spaces
+      expected_result = "  Line 1\n  Line 2"
+      assert_equal expected_result, HashDelegator.indent_all_lines(body, indent)
+    end
 
-  require 'minitest/autorun'
-  require 'mocha/minitest'
+    def test_indent_all_lines_without_indent
+      body = "Line 1\nLine 2"
+      indent = nil
 
-  module MarkdownExec
-    class TestHashDelegator < Minitest::Test
-      def setup
-        @hd = HashDelegator.new
-        @mdoc = mock('MarkdownDocument')
-      end
+      assert_equal body, HashDelegator.indent_all_lines(body, indent)
+    end
 
-      def test_calling_execute_required_lines_calls_command_execute_with_argument_args_value
-        pigeon = 'E'
-        obj = {
-          output_execution_label_format: '',
-          output_execution_label_name_color: 'plain',
-          output_execution_label_value_color: 'plain'
-        }
+    def test_indent_all_lines_with_empty_indent
+      body = "Line 1\nLine 2"
+      indent = ''
 
-        c = MarkdownExec::HashDelegator.new(obj)
-        c.pass_args = pigeon
+      assert_equal body, HashDelegator.indent_all_lines(body, indent)
+    end
 
-        # Expect that method opts_command_execute is called with argument args having value pigeon
-        c.expects(:command_execute).with(
-          '',
-          args: pigeon
-        )
+    def test_safeval_successful_evaluation
+      assert_equal 4, HashDelegator.safeval('2 + 2')
+    end
 
-        # Call method opts_execute_required_lines
-        c.execute_required_lines([])
-      end
+    def test_safeval_rescue_from_error
+      HashDelegator.stubs(:error_handler).with('safeval')
+      assert_nil HashDelegator.safeval('invalid code')
+    end
 
-      # Test case for empty body
-      def test_push_link_history_and_trigger_load_with_empty_body
-        assert_equal LoadFile::Reuse,
-                     @hd.push_link_history_and_trigger_load([], nil, FCB.new).load_file
-      end
+    def test_set_fcb_title
+      # sample input and output data for testing default_block_title_from_body method
+      input_output_data = [
+        {
+          input: MarkdownExec::FCB.new(title: nil,
+                                       body: ["puts 'Hello, world!'"]),
+          output: "puts 'Hello, world!'"
+        },
+        {
+          input: MarkdownExec::FCB.new(title: '',
+                                       body: ['def add(x, y)',
+                                              '  x + y', 'end']),
+          output: "def add(x, y)\n    x + y\n  end\n"
+        },
+        {
+          input: MarkdownExec::FCB.new(title: 'foo', body: %w[bar baz]),
+          output: 'foo' # expect the title to remain unchanged
+        }
+      ]
 
-      # Test case for non-empty body without 'file' key
-      def test_push_link_history_and_trigger_load_without_file_key
-        body = ["vars:\n  KEY: VALUE"]
-        assert_equal LoadFile::Reuse,
-                     @hd.push_link_history_and_trigger_load(body, nil, FCB.new).load_file
+      # iterate over the input and output data and
+      # assert that the method sets the title as expected
+      input_output_data.each do |data|
+        input = data[:input]
+        output = data[:output]
+        HashDelegator.default_block_title_from_body(input)
+        assert_equal output, input.title
       end
+    end
 
-      # Test case for non-empty body with 'file' key
-      def test_push_link_history_and_trigger_load_with_file_key
-        body = ["file: sample_file\nblock: sample_block\nvars:\n  KEY: VALUE"]
-        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',
-                                                                               filename: 'sample_file'))
+    class TestHashDelegatorAppendDivider < Minitest::Test
+      def setup
+        @hd = HashDelegator.new
+        @hd.instance_variable_set(:@delegate_object, {
+                                    menu_divider_format: 'Format',
+                                    menu_initial_divider: 'Initial Divider',
+                                    menu_final_divider: 'Final Divider',
+                                    menu_divider_color: :color
+                                  })
+        @hd.stubs(:string_send_color).returns('Formatted Divider')
+        HashDelegator.stubs(:safeval).returns('Safe Value')
       end
 
-      def test_indent_all_lines_with_indent
-        body = "Line 1\nLine 2"
-        indent = '  ' # Two spaces
-        expected_result = "  Line 1\n  Line 2"
-        assert_equal expected_result, @hd.indent_all_lines(body, indent)
+      def test_append_divider_initial
+        menu_blocks = []
+        @hd.append_divider(menu_blocks, :initial)
+
+        assert_equal 1, menu_blocks.size
+        assert_equal 'Formatted Divider', menu_blocks.first.dname
       end
 
-      def test_indent_all_lines_without_indent
-        body = "Line 1\nLine 2"
-        indent = nil
+      def test_append_divider_final
+        menu_blocks = []
+        @hd.append_divider(menu_blocks, :final)
 
-        assert_equal body, @hd.indent_all_lines(body, indent)
+        assert_equal 1, menu_blocks.size
+        assert_equal 'Formatted Divider', menu_blocks.last.dname
       end
 
-      def test_indent_all_lines_with_empty_indent
-        body = "Line 1\nLine 2"
-        indent = ''
+      def test_append_divider_without_format
+        @hd.instance_variable_set(:@delegate_object, {})
+        menu_blocks = []
+        @hd.append_divider(menu_blocks, :initial)
 
-        assert_equal body, @hd.indent_all_lines(body, indent)
+        assert_empty menu_blocks
       end
+    end
 
-      def test_safeval_successful_evaluation
-        assert_equal 4, @hd.safeval('2 + 2')
+    class TestHashDelegatorBlockFind < Minitest::Test
+      def setup
+        @hd = HashDelegator.new
       end
 
-      def test_safeval_rescue_from_error
-        @hd.stubs(:error_handler).with('safeval')
-        assert_nil @hd.safeval('invalid code')
+      def test_block_find_with_match
+        blocks = [{ key: 'value1' }, { key: 'value2' }]
+        result = HashDelegator.block_find(blocks, :key, 'value1')
+        assert_equal({ key: 'value1' }, result)
       end
 
-      def test_set_fcb_title
-        # sample input and output data for testing default_block_title_from_body method
-        input_output_data = [
-          {
-            input: MarkdownExec::FCB.new(title: nil,
-                                         body: ["puts 'Hello, world!'"]),
-            output: "puts 'Hello, world!'"
-          },
-          {
-            input: MarkdownExec::FCB.new(title: '',
-                                         body: ['def add(x, y)',
-                                                '  x + y', 'end']),
-            output: "def add(x, y)\n    x + y\n  end\n"
-          },
-          {
-            input: MarkdownExec::FCB.new(title: 'foo', body: %w[bar baz]),
-            output: 'foo' # expect the title to remain unchanged
-          }
-        ]
-
-        # iterate over the input and output data and
-        # assert that the method sets the title as expected
-        input_output_data.each do |data|
-          input = data[:input]
-          output = data[:output]
-          @hd.default_block_title_from_body(input)
-          assert_equal output, input.title
-        end
+      def test_block_find_without_match
+        blocks = [{ key: 'value1' }, { key: 'value2' }]
+        result = HashDelegator.block_find(blocks, :key, 'value3')
+        assert_nil result
       end
 
-      class TestHashDelegatorAppendDivider < Minitest::Test
-        def setup
-          @hd = HashDelegator.new
-          @hd.instance_variable_set(:@delegate_object, {
-                                      menu_divider_format: 'Format',
-                                      menu_initial_divider: 'Initial Divider',
-                                      menu_final_divider: 'Final Divider',
-                                      menu_divider_color: :color
-                                    })
-          @hd.stubs(:string_send_color).returns('Formatted Divider')
-          @hd.stubs(:safeval).returns('Safe Value')
-        end
-
-        def test_append_divider_initial
-          menu_blocks = []
-          @hd.append_divider(menu_blocks, :initial)
-
-          assert_equal 1, menu_blocks.size
-          assert_equal 'Formatted Divider', menu_blocks.first.dname
-        end
-
-        def test_append_divider_final
-          menu_blocks = []
-          @hd.append_divider(menu_blocks, :final)
-
-          assert_equal 1, menu_blocks.size
-          assert_equal 'Formatted Divider', menu_blocks.last.dname
-        end
-
-        def test_append_divider_without_format
-          @hd.instance_variable_set(:@delegate_object, {})
-          menu_blocks = []
-          @hd.append_divider(menu_blocks, :initial)
-
-          assert_empty menu_blocks
-        end
+      def test_block_find_with_default
+        blocks = [{ key: 'value1' }, { key: 'value2' }]
+        result = HashDelegator.block_find(blocks, :key, 'value3', 'default')
+        assert_equal 'default', result
       end
+    end
 
-      class TestHashDelegatorBlockFind < Minitest::Test
-        def setup
-          @hd = HashDelegator.new
-        end
-
-        def test_block_find_with_match
-          blocks = [{ key: 'value1' }, { key: 'value2' }]
-          result = @hd.block_find(blocks, :key, 'value1')
-          assert_equal({ key: 'value1' }, result)
-        end
-
-        def test_block_find_without_match
-          blocks = [{ key: 'value1' }, { key: 'value2' }]
-          result = @hd.block_find(blocks, :key, 'value3')
-          assert_nil result
-        end
-
-        def test_block_find_with_default
-          blocks = [{ key: 'value1' }, { key: 'value2' }]
-          result = @hd.block_find(blocks, :key, 'value3', 'default')
-          assert_equal 'default', result
-        end
+    class TestHashDelegatorBlocksFromNestedFiles < Minitest::Test
+      def setup
+        @hd = HashDelegator.new
+        @hd.stubs(:iter_blocks_from_nested_files).yields(:blocks, FCB.new)
+        @hd.stubs(:get_block_summary).returns(FCB.new)
+        @hd.stubs(:create_and_add_chrome_blocks)
+        @hd.instance_variable_set(:@delegate_object, {})
+        HashDelegator.stubs(:error_handler)
       end
 
-      class TestHashDelegatorBlocksFromNestedFiles < Minitest::Test
-        def setup
-          @hd = HashDelegator.new
-          @hd.stubs(:iter_blocks_from_nested_files).yields(:blocks, FCB.new)
-          @hd.stubs(:get_block_summary).returns(FCB.new)
-          @hd.stubs(:create_and_add_chrome_blocks)
-          @hd.instance_variable_set(:@delegate_object, {})
-          @hd.stubs(:error_handler)
-        end
-
-        def test_blocks_from_nested_files
-          result = @hd.blocks_from_nested_files
-
-          assert_kind_of Array, result
-          assert_kind_of FCB, result.first
-        end
-
-        def test_blocks_from_nested_files_with_no_chrome
-          @hd.instance_variable_set(:@delegate_object, { no_chrome: true })
-          @hd.expects(:create_and_add_chrome_blocks).never
+      def test_blocks_from_nested_files
+        result = @hd.blocks_from_nested_files
 
-          result = @hd.blocks_from_nested_files
-
-          assert_kind_of Array, result
-        end
+        assert_kind_of Array, result
+        assert_kind_of FCB, result.first
       end
 
-      class TestHashDelegatorCollectRequiredCodeLines < Minitest::Test
-        def setup
-          @hd = HashDelegator.new
-          @hd.instance_variable_set(:@delegate_object, {})
-          @mdoc = mock('YourMDocClass')
-          @selected = { shell: BlockType::VARS, body: ['key: value'] }
-          @hd.stubs(:read_required_blocks_from_temp_file).returns([])
-          @hd.stubs(:string_send_color)
-          @hd.stubs(:print)
-        end
+      def test_blocks_from_nested_files_with_no_chrome
+        @hd.instance_variable_set(:@delegate_object, { no_chrome: true })
+        @hd.expects(:create_and_add_chrome_blocks).never
 
-        def test_collect_required_code_lines_with_vars
-          YAML.stubs(:load).returns({ 'key' => 'value' })
-          @mdoc.stubs(:collect_recursively_required_code).returns({ code: ['code line'] })
-          result = @hd.collect_required_code_lines(@mdoc, @selected, block_source: {})
+        result = @hd.blocks_from_nested_files
 
-          assert_equal ['code line'], result
-        end
+        assert_kind_of Array, result
       end
+    end
 
-      class TestHashDelegatorCommandOrUserSelectedBlock < Minitest::Test
-        def setup
-          @hd = HashDelegator.new
-          @hd.instance_variable_set(:@delegate_object, {})
-          @hd.stubs(:error_handler)
-          @hd.stubs(:wait_for_user_selected_block)
-        end
-
-        def test_command_selected_block
-          all_blocks = [{ oname: 'block1' }, { oname: 'block2' }]
-          @hd.instance_variable_set(:@delegate_object,
-                                    { block_name: 'block1' })
-
-          result = @hd.load_cli_or_user_selected_block(all_blocks, [], nil)
-
-          assert_equal all_blocks.first, result.block
-          assert_nil result.state
-        end
-
-        def test_user_selected_block
-          block_state = SelectedBlockMenuState.new({ oname: 'block2' },
-                                                   :some_state)
-          @hd.stubs(:wait_for_user_selected_block).returns(block_state)
+    class TestHashDelegatorCollectRequiredCodeLines < Minitest::Test
+      def setup
+        @hd = HashDelegator.new
+        @hd.instance_variable_set(:@delegate_object, {})
+        @mdoc = mock('YourMDocClass')
+        @selected = { shell: BlockType::VARS, body: ['key: value'] }
+        HashDelegator.stubs(:read_required_blocks_from_temp_file).returns([])
+        @hd.stubs(:string_send_color)
+        @hd.stubs(:print)
+      end
 
-          result = @hd.load_cli_or_user_selected_block([], [], nil)
+      def test_collect_required_code_lines_with_vars
+        YAML.stubs(:load).returns({ 'key' => 'value' })
+        @mdoc.stubs(:collect_recursively_required_code).returns({ code: ['code line'] })
+        result = @hd.collect_required_code_lines(@mdoc, @selected, block_source: {})
 
-          assert_equal block_state.block, result.block
-          assert_equal :some_state, result.state
-        end
+        assert_equal ['code line'], result
       end
+    end
 
-      class TestHashDelegatorCountBlockInFilename < Minitest::Test
-        def setup
-          @hd = HashDelegator.new
-          @hd.instance_variable_set(:@delegate_object,
-                                    { fenced_start_and_end_regex: '^```',
-                                      filename: '/path/to/file' })
-          @hd.stubs(:cfile).returns(mock('cfile'))
-        end
+    class TestHashDelegatorCommandOrUserSelectedBlock < Minitest::Test
+      def setup
+        @hd = HashDelegator.new
+        @hd.instance_variable_set(:@delegate_object, {})
+        HashDelegator.stubs(:error_handler)
+        @hd.stubs(:wait_for_user_selected_block)
+      end
 
-        def test_count_blocks_in_filename
-          file_content = ["```ruby\n", "puts 'Hello'\n", "```\n",
-                          "```python\n", "print('Hello')\n", "```\n"]
-          @hd.cfile.stubs(:readlines).with('/path/to/file').returns(file_content)
+      def test_command_selected_block
+        all_blocks = [{ oname: 'block1' }, { oname: 'block2' }]
+        @hd.instance_variable_set(:@delegate_object,
+                                  { block_name: 'block1' })
 
-          count = @hd.count_blocks_in_filename
+        result = @hd.load_cli_or_user_selected_block(all_blocks, [], nil)
 
-          assert_equal 2, count
-        end
+        assert_equal all_blocks.first.merge(block_name_from_ui: false), result.block
+        assert_nil result.state
+      end
 
-        def test_count_blocks_in_filename_with_no_matches
-          file_content = ["puts 'Hello'\n", "print('Hello')\n"]
-          @hd.cfile.stubs(:readlines).with('/path/to/file').returns(file_content)
+      def test_user_selected_block
+        block_state = SelectedBlockMenuState.new({ oname: 'block2' },
+                                                 :some_state)
+        @hd.stubs(:wait_for_user_selected_block).returns(block_state)
 
-          count = @hd.count_blocks_in_filename
+        result = @hd.load_cli_or_user_selected_block([], [], nil)
 
-          assert_equal 0, count
-        end
+        assert_equal block_state.block.merge(block_name_from_ui: true), result.block
+        assert_equal :some_state, result.state
       end
+    end
 
-      class TestHashDelegatorCreateAndWriteFile < Minitest::Test
-        def setup
-          @hd = HashDelegator.new
-          @hd.stubs(:error_handler)
-          FileUtils.stubs(:mkdir_p)
-          File.stubs(:write)
-          File.stubs(:chmod)
-        end
-
-        def test_create_file_and_write_string_with_permissions
-          file_path = '/path/to/file'
-          content = 'sample content'
-          chmod_value = 0o644
-
-          FileUtils.expects(:mkdir_p).with('/path/to').once
-          File.expects(:write).with(file_path, content).once
-          File.expects(:chmod).with(chmod_value, file_path).once
+    class TestHashDelegatorCountBlockInFilename < Minitest::Test
+      def setup
+        @hd = HashDelegator.new
+        @hd.instance_variable_set(:@delegate_object,
+                                  { fenced_start_and_end_regex: '^```',
+                                    filename: '/path/to/file' })
+        @hd.stubs(:cfile).returns(mock('cfile'))
+      end
 
-          @hd.create_file_and_write_string_with_permissions(file_path, content,
-                                                            chmod_value)
+      def test_count_blocks_in_filename
+        file_content = ["```ruby\n", "puts 'Hello'\n", "```\n",
+                        "```python\n", "print('Hello')\n", "```\n"]
+        @hd.cfile.stubs(:readlines).with('/path/to/file',
+                                         import_paths: nil).returns(file_content)
 
-          assert true # Placeholder for actual test assertions
-        end
+        count = @hd.count_blocks_in_filename
 
-        def test_create_and_write_file_without_chmod
-          file_path = '/path/to/file'
-          content = 'sample content'
-          chmod_value = 0
+        assert_equal 2, count
+      end
 
-          FileUtils.expects(:mkdir_p).with('/path/to').once
-          File.expects(:write).with(file_path, content).once
-          File.expects(:chmod).never
+      def test_count_blocks_in_filename_with_no_matches
+        file_content = ["puts 'Hello'\n", "print('Hello')\n"]
+        @hd.cfile.stubs(:readlines).with('/path/to/file',
+                                         import_paths: nil).returns(file_content)
 
-          @hd.create_file_and_write_string_with_permissions(file_path, content,
-                                                            chmod_value)
+        count = @hd.count_blocks_in_filename
 
-          assert true # Placeholder for actual test assertions
-        end
+        assert_equal 0, count
       end
+    end
 
-      class TestHashDelegatorDetermineBlockState < Minitest::Test
-        def setup
-          @hd = HashDelegator.new
-          @hd.stubs(:menu_chrome_formatted_option).returns('Formatted Option')
-        end
+    class TestHashDelegatorCreateAndWriteFile < Minitest::Test
+      def setup
+        @hd = HashDelegator.new
+        HashDelegator.stubs(:error_handler)
+        FileUtils.stubs(:mkdir_p)
+        File.stubs(:write)
+        File.stubs(:chmod)
+      end
 
-        def test_determine_block_state_exit
-          selected_option = { oname: 'Formatted Option' }
-          @hd.stubs(:menu_chrome_formatted_option).with(:menu_option_exit_name).returns('Formatted Option')
+      def test_create_file_and_write_string_with_permissions
+        file_path = '/path/to/file'
+        content = 'sample content'
+        chmod_value = 0o644
 
-          result = @hd.determine_block_state(selected_option)
+        FileUtils.expects(:mkdir_p).with('/path/to').once
+        File.expects(:write).with(file_path, content).once
+        File.expects(:chmod).with(chmod_value, file_path).once
 
-          assert_equal MenuState::EXIT, result.state
-          assert_nil result.block
-        end
+        HashDelegator.create_file_and_write_string_with_permissions(file_path, content,
+                                                                    chmod_value)
 
-        def test_determine_block_state_back
-          selected_option = { oname: 'Formatted Back Option' }
-          @hd.stubs(:menu_chrome_formatted_option).with(:menu_option_back_name).returns('Formatted Back Option')
-          result = @hd.determine_block_state(selected_option)
+        assert true # Placeholder for actual test assertions
+      end
 
-          assert_equal MenuState::BACK, result.state
-          assert_equal selected_option, result.block
-        end
+      def test_create_and_write_file_without_chmod
+        file_path = '/path/to/file'
+        content = 'sample content'
+        chmod_value = 0
 
-        def test_determine_block_state_continue
-          selected_option = { oname: 'Other Option' }
+        FileUtils.expects(:mkdir_p).with('/path/to').once
+        File.expects(:write).with(file_path, content).once
+        File.expects(:chmod).never
 
-          result = @hd.determine_block_state(selected_option)
+        HashDelegator.create_file_and_write_string_with_permissions(file_path, content,
+                                                                    chmod_value)
 
-          assert_equal MenuState::CONTINUE, result.state
-          assert_equal selected_option, result.block
-        end
+        assert true # Placeholder for actual test assertions
       end
+    end
 
-      class TestHashDelegatorDisplayRequiredCode < Minitest::Test
-        def setup
-          @hd = HashDelegator.new
-          @hd.instance_variable_set(:@fout, mock('fout'))
-          @hd.instance_variable_set(:@delegate_object, {})
-          @hd.stubs(:string_send_color)
-        end
+    class TestHashDelegatorDetermineBlockState < Minitest::Test
+      def setup
+        @hd = HashDelegator.new
+        @hd.stubs(:menu_chrome_formatted_option).returns('Formatted Option')
+      end
 
-        def test_display_required_code
-          required_lines = %w[line1 line2]
-          @hd.instance_variable_get(:@delegate_object).stubs(:[]).with(:script_preview_head).returns('Header')
-          @hd.instance_variable_get(:@delegate_object).stubs(:[]).with(:script_preview_tail).returns('Footer')
-          @hd.instance_variable_get(:@fout).expects(:fout).times(4)
+      def test_determine_block_state_exit
+        selected_option = { oname: 'Formatted Option' }
+        @hd.stubs(:menu_chrome_formatted_option).with(:menu_option_exit_name).returns('Formatted Option')
 
-          @hd.display_required_code(required_lines)
+        result = @hd.determine_block_state(selected_option)
 
-          # Verifying that fout is called for each line and for header & footer
-          assert true # Placeholder for actual test assertions
-        end
+        assert_equal MenuState::EXIT, result.state
+        assert_nil result.block
       end
 
-      class TestHashDelegatorFetchColor < Minitest::Test
-        def setup
-          @hd = HashDelegator.new
-          @hd.instance_variable_set(:@delegate_object, {})
-        end
+      def test_determine_block_state_back
+        selected_option = { oname: 'Formatted Back Option' }
+        @hd.stubs(:menu_chrome_formatted_option).with(:menu_option_back_name).returns('Formatted Back Option')
+        result = @hd.determine_block_state(selected_option)
 
-        def test_fetch_color_with_valid_data
-          @hd.instance_variable_get(:@delegate_object).stubs(:fetch).with(
-            :execution_report_preview_head, ''
-          ).returns('Data String')
-          @hd.stubs(:string_send_color).with('Data String',
-                                             :execution_report_preview_frame_color).returns('Colored Data String')
-
-          result = @hd.fetch_color
+        assert_equal MenuState::BACK, result.state
+        assert_equal selected_option, result.block
+      end
 
-          assert_equal 'Colored Data String', result
-        end
+      def test_determine_block_state_continue
+        selected_option = { oname: 'Other Option' }
 
-        def test_fetch_color_with_missing_data
-          @hd.instance_variable_get(:@delegate_object).stubs(:fetch).with(
-            :execution_report_preview_head, ''
-          ).returns('')
-          @hd.stubs(:string_send_color).with('',
-                                             :execution_report_preview_frame_color).returns('Default Colored String')
+        result = @hd.determine_block_state(selected_option)
 
-          result = @hd.fetch_color
+        assert_equal MenuState::CONTINUE, result.state
+        assert_equal selected_option, result.block
+      end
+    end
 
-          assert_equal 'Default Colored String', result
-        end
+    class TestHashDelegatorDisplayRequiredCode < Minitest::Test
+      def setup
+        @hd = HashDelegator.new
+        @hd.instance_variable_set(:@fout, mock('fout'))
+        @hd.instance_variable_set(:@delegate_object, {})
+        @hd.stubs(:string_send_color)
       end
 
-      class TestHashDelegatorFormatReferencesSendColor < Minitest::Test
-        def setup
-          @hd = HashDelegator.new
-          @hd.instance_variable_set(:@delegate_object, {})
-        end
+      def test_display_required_code
+        required_lines = %w[line1 line2]
+        @hd.instance_variable_get(:@delegate_object).stubs(:[]).with(:script_preview_head).returns('Header')
+        @hd.instance_variable_get(:@delegate_object).stubs(:[]).with(:script_preview_tail).returns('Footer')
+        @hd.instance_variable_get(:@fout).expects(:fout).times(4)
 
-        def test_format_references_send_color_with_valid_data
-          @hd.instance_variable_get(:@delegate_object).stubs(:fetch).with(
-            :output_execution_label_format, ''
-          ).returns('Formatted: %{key}')
-          @hd.stubs(:string_send_color).returns('Colored String')
+        @hd.display_required_code(required_lines)
 
-          result = @hd.format_references_send_color(context: { key: 'value' },
-                                                    color_sym: :execution_report_preview_frame_color)
+        # Verifying that fout is called for each line and for header & footer
+        assert true # Placeholder for actual test assertions
+      end
+    end
 
-          assert_equal 'Colored String', result
-        end
+    class TestHashDelegatorFetchColor < Minitest::Test
+      def setup
+        @hd = HashDelegator.new
+        @hd.instance_variable_set(:@delegate_object, {})
+      end
 
-        def test_format_references_send_color_with_missing_format
-          @hd.instance_variable_get(:@delegate_object).stubs(:fetch).with(
-            :output_execution_label_format, ''
-          ).returns('')
-          @hd.stubs(:string_send_color).returns('Default Colored String')
+      def test_fetch_color_with_valid_data
+        @hd.instance_variable_get(:@delegate_object).stubs(:fetch).with(
+          :execution_report_preview_head, ''
+        ).returns('Data String')
+        @hd.stubs(:string_send_color).with('Data String',
+                                           :execution_report_preview_frame_color).returns('Colored Data String')
 
-          result = @hd.format_references_send_color(context: { key: 'value' },
-                                                    color_sym: :execution_report_preview_frame_color)
+        result = @hd.fetch_color
 
-          assert_equal 'Default Colored String', result
-        end
+        assert_equal 'Colored Data String', result
       end
 
-      class TestHashDelegatorFormatExecutionStreams < Minitest::Test
-        def setup
-          @hd = HashDelegator.new
-          @hd.instance_variable_set(:@run_state, mock('run_state'))
-        end
+      def test_fetch_color_with_missing_data
+        @hd.instance_variable_get(:@delegate_object).stubs(:fetch).with(
+          :execution_report_preview_head, ''
+        ).returns('')
+        @hd.stubs(:string_send_color).with('',
+                                           :execution_report_preview_frame_color).returns('Default Colored String')
 
-        def test_format_execution_streams_with_valid_key
-          @hd.instance_variable_get(:@run_state).stubs(:files).returns({ stdout: %w[
-                                                                         output1 output2
-                                                                       ] })
+        result = @hd.fetch_color
 
-          result = @hd.format_execution_streams(:stdout)
+        assert_equal 'Default Colored String', result
+      end
+    end
 
-          assert_equal 'output1output2', result
-        end
+    class TestHashDelegatorFormatReferencesSendColor < Minitest::Test
+      def setup
+        @hd = HashDelegator.new
+        @hd.instance_variable_set(:@delegate_object, {})
+      end
 
-        def test_format_execution_streams_with_empty_key
-          @hd.instance_variable_get(:@run_state).stubs(:files).returns({})
+      def test_format_references_send_color_with_valid_data
+        @hd.instance_variable_get(:@delegate_object).stubs(:fetch).with(
+          :output_execution_label_format, ''
+        ).returns('Formatted: %{key}')
+        @hd.stubs(:string_send_color).returns('Colored String')
 
-          result = @hd.format_execution_streams(:stderr)
+        result = @hd.format_references_send_color(context: { key: 'value' },
+                                                  color_sym: :execution_report_preview_frame_color)
 
-          assert_equal '', result
-        end
+        assert_equal 'Colored String', result
+      end
 
-        def test_format_execution_streams_with_nil_files
-          @hd.instance_variable_get(:@run_state).stubs(:files).returns(nil)
+      def test_format_references_send_color_with_missing_format
+        @hd.instance_variable_get(:@delegate_object).stubs(:fetch).with(
+          :output_execution_label_format, ''
+        ).returns('')
+        @hd.stubs(:string_send_color).returns('Default Colored String')
 
-          result = @hd.format_execution_streams(:stdin)
+        result = @hd.format_references_send_color(context: { key: 'value' },
+                                                  color_sym: :execution_report_preview_frame_color)
 
-          assert_equal '', result
-        end
+        assert_equal 'Default Colored String', result
       end
+    end
 
-      class TestHashDelegatorHandleBackLink < Minitest::Test
-        def setup
-          @hd = HashDelegator.new
-          @hd.stubs(:history_state_pop)
-        end
-
-        def test_pop_link_history_and_trigger_load
-          # Verifying that history_state_pop is called
-          # @hd.expects(:history_state_pop).once
+    class TestHashDelegatorFormatExecutionStreams < Minitest::Test
+      def setup
+        @hd = HashDelegator.new
+        @hd.instance_variable_set(:@run_state, mock('run_state'))
+      end
 
-          result = @hd.pop_link_history_and_trigger_load
+      def test_format_execution_streams_with_valid_key
+        result = HashDelegator.format_execution_streams(:stdout,
+                                                        { stdout: %w[output1 output2] })
 
-          # Asserting the result is an instance of LoadFileLinkState
-          assert_instance_of LoadFileLinkState, result
-          assert_equal LoadFile::Load, result.load_file
-          assert_nil result.link_state.block_name
-        end
+        assert_equal 'output1output2', result
       end
 
-      class TestHashDelegatorHandleBlockState < Minitest::Test
-        def setup
-          @hd = HashDelegator.new
-          @mock_block_state = mock('block_state')
-        end
+      def test_format_execution_streams_with_empty_key
+        @hd.instance_variable_get(:@run_state).stubs(:files).returns({})
 
-        def test_handle_block_state_with_back
-          @mock_block_state.stubs(:state).returns(MenuState::BACK)
-          @mock_block_state.stubs(:block).returns({ oname: 'sample_block' })
+        result = HashDelegator.format_execution_streams(:stderr)
 
-          @hd.handle_block_state(@mock_block_state)
+        assert_equal '', result
+      end
 
-          assert_equal 'sample_block',
-                       @hd.instance_variable_get(:@delegate_object)[:block_name]
-          assert @hd.instance_variable_get(:@menu_user_clicked_back_link)
-        end
+      def test_format_execution_streams_with_nil_files
+        @hd.instance_variable_get(:@run_state).stubs(:files).returns(nil)
 
-        def test_handle_block_state_with_continue
-          @mock_block_state.stubs(:state).returns(MenuState::CONTINUE)
-          @mock_block_state.stubs(:block).returns({ oname: 'another_block' })
+        result = HashDelegator.format_execution_streams(:stdin)
 
-          @hd.handle_block_state(@mock_block_state)
+        assert_equal '', result
+      end
+    end
 
-          assert_equal 'another_block',
-                       @hd.instance_variable_get(:@delegate_object)[:block_name]
-          refute @hd.instance_variable_get(:@menu_user_clicked_back_link)
-        end
+    class TestHashDelegatorHandleBackLink < Minitest::Test
+      def setup
+        @hd = HashDelegator.new
+        @hd.stubs(:history_state_pop)
+      end
 
-        def test_handle_block_state_with_other
-          @mock_block_state.stubs(:state).returns(nil) # MenuState::OTHER
-          @mock_block_state.stubs(:block).returns({ oname: 'other_block' })
+      def test_pop_link_history_and_trigger_load
+        # Verifying that history_state_pop is called
+        # @hd.expects(:history_state_pop).once
 
-          @hd.handle_block_state(@mock_block_state)
+        result = @hd.pop_link_history_and_trigger_load
 
-          assert_nil @hd.instance_variable_get(:@delegate_object)[:block_name]
-          assert_nil @hd.instance_variable_get(:@menu_user_clicked_back_link)
-        end
+        # Asserting the result is an instance of LoadFileLinkState
+        assert_instance_of LoadFileLinkState, result
+        assert_equal LoadFile::Load, result.load_file
+        assert_nil result.link_state.block_name
       end
+    end
 
-      class TestHashDelegatorHandleGenericBlock < Minitest::Test
-        def setup
-          @hd = HashDelegator.new
-          @mock_document = mock('MarkdownDocument')
-          @selected_item = mock('FCB')
-        end
+    class TestHashDelegatorHandleBlockState < Minitest::Test
+      def setup
+        @hd = HashDelegator.new
+        @mock_block_state = mock('block_state')
+      end
 
-        def test_compile_execute_and_trigger_reuse_without_user_approval
-          # Mock the delegate object configuration
-          @hd.instance_variable_set(:@delegate_object,
-                                    { output_script: false,
-                                      user_must_approve: false })
+      def test_handle_back_or_continue_with_back
+        @mock_block_state.stubs(:state).returns(MenuState::BACK)
+        @mock_block_state.stubs(:block).returns({ oname: 'sample_block' })
 
-          # Test the method without user approval
-          # Expectations and assertions go here
-        end
+        @hd.handle_back_or_continue(@mock_block_state)
 
-        def test_compile_execute_and_trigger_reuse_with_user_approval
-          # Mock the delegate object configuration
-          @hd.instance_variable_set(:@delegate_object,
-                                    { output_script: false,
-                                      user_must_approve: true })
+        assert_equal 'sample_block',
+                     @hd.instance_variable_get(:@delegate_object)[:block_name]
+        assert @hd.instance_variable_get(:@menu_user_clicked_back_link)
+      end
 
-          # Test the method with user approval
-          # Expectations and assertions go here
-        end
+      def test_handle_back_or_continue_with_continue
+        @mock_block_state.stubs(:state).returns(MenuState::CONTINUE)
+        @mock_block_state.stubs(:block).returns({ oname: 'another_block' })
 
-        def test_compile_execute_and_trigger_reuse_with_output_script
-          # Mock the delegate object configuration
-          @hd.instance_variable_set(:@delegate_object,
-                                    { output_script: true,
-                                      user_must_approve: false })
+        @hd.handle_back_or_continue(@mock_block_state)
 
-          # Test the method with output script option
-          # Expectations and assertions go here
-        end
+        assert_equal 'another_block',
+                     @hd.instance_variable_get(:@delegate_object)[:block_name]
+        refute @hd.instance_variable_get(:@menu_user_clicked_back_link)
       end
 
-      # require 'stringio'
+      def test_handle_back_or_continue_with_other
+        @mock_block_state.stubs(:state).returns(nil) # MenuState::OTHER
+        @mock_block_state.stubs(:block).returns({ oname: 'other_block' })
 
-      class TestHashDelegatorHandleStream < Minitest::Test
-        def setup
-          @hd = HashDelegator.new
-          @hd.instance_variable_set(:@run_state,
-                                    OpenStruct.new(files: { stdout: [] }))
-          @hd.instance_variable_set(:@delegate_object,
-                                    { output_stdout: true })
-        end
+        @hd.handle_back_or_continue(@mock_block_state)
 
-        def test_handle_stream
-          stream = StringIO.new("line 1\nline 2\n")
-          file_type = :stdout
+        assert_nil @hd.instance_variable_get(:@delegate_object)[:block_name]
+        assert_nil @hd.instance_variable_get(:@menu_user_clicked_back_link)
+      end
+    end
 
-          Thread.new { @hd.handle_stream(stream, file_type) }
+    class TestHashDelegatorHandleGenericBlock < Minitest::Test
+      def setup
+        @hd = HashDelegator.new
+        @mock_document = mock('MarkdownDocument')
+        @selected_item = mock('FCB')
+      end
 
-          @hd.wait_for_stream_processing
+      def test_compile_execute_and_trigger_reuse_without_user_approval
+        # Mock the delegate object configuration
+        @hd.instance_variable_set(:@delegate_object,
+                                  { output_script: false,
+                                    user_must_approve: false })
 
-          assert_equal ['line 1', 'line 2'],
-                       @hd.instance_variable_get(:@run_state).files[:stdout]
-        end
+        # Test the method without user approval
+        # Expectations and assertions go here
+      end
 
-        def test_handle_stream_with_io_error
-          stream = StringIO.new("line 1\nline 2\n")
-          file_type = :stdout
-          stream.stubs(:each_line).raises(IOError)
+      def test_compile_execute_and_trigger_reuse_with_user_approval
+        # Mock the delegate object configuration
+        @hd.instance_variable_set(:@delegate_object,
+                                  { output_script: false,
+                                    user_must_approve: true })
 
-          Thread.new { @hd.handle_stream(stream, file_type) }
+        # Test the method with user approval
+        # Expectations and assertions go here
+      end
 
-          @hd.wait_for_stream_processing
+      def test_compile_execute_and_trigger_reuse_with_output_script
+        # Mock the delegate object configuration
+        @hd.instance_variable_set(:@delegate_object,
+                                  { output_script: true,
+                                    user_must_approve: false })
 
-          assert_equal [],
-                       @hd.instance_variable_get(:@run_state).files[:stdout]
-        end
+        # Test the method with output script option
+        # Expectations and assertions go here
       end
+    end
 
-      class TestHashDelegatorIterBlocksFromNestedFiles < Minitest::Test
-        def setup
-          @hd = HashDelegator.new
-          @hd.instance_variable_set(:@delegate_object,
-                                    { filename: 'test.md' })
-          @hd.stubs(:check_file_existence).with('test.md').returns(true)
-          @hd.stubs(:initial_state).returns({})
-          @hd.stubs(:cfile).returns(Minitest::Mock.new)
-          @hd.stubs(:update_line_and_block_state)
-        end
+    # require 'stringio'
 
-        def test_iter_blocks_from_nested_files
-          @hd.cfile.expect(:readlines, ['line 1', 'line 2'], ['test.md'])
-          selected_messages = ['filtered message']
+    class TestHashDelegatorHandleStream < Minitest::Test
+      def setup
+        @hd = HashDelegator.new
+        @hd.instance_variable_set(:@run_state,
+                                  OpenStruct.new(files: { stdout: [] }))
+        @hd.instance_variable_set(:@delegate_object,
+                                  { output_stdout: true })
+      end
 
-          result = @hd.iter_blocks_from_nested_files { selected_messages }
-          assert_equal ['line 1', 'line 2'], result
+      def test_handle_stream
+        stream = StringIO.new("line 1\nline 2\n")
+        file_type = :stdout
 
-          @hd.cfile.verify
-        end
+        Thread.new { @hd.handle_stream(stream, file_type) }
 
-        def test_iter_blocks_from_nested_files_with_no_file
-          @hd.stubs(:check_file_existence).with('test.md').returns(false)
+        @hd.wait_for_stream_processing
 
-          assert_nil(@hd.iter_blocks_from_nested_files do
-                       ['filtered message']
-                     end)
-        end
+        assert_equal ['line 1', 'line 2'],
+                     @hd.instance_variable_get(:@run_state).files[:stdout]
       end
 
-      class TestHashDelegatorMenuChromeColoredOption < Minitest::Test
-        def setup
-          @hd = HashDelegator.new
-          @hd.instance_variable_set(:@delegate_object, {
-                                      menu_option_back_name: 'Back',
-                                      menu_chrome_color: :red,
-                                      menu_chrome_format: '-- %s --'
-                                    })
-          @hd.stubs(:menu_chrome_formatted_option).with(:menu_option_back_name).returns('-- Back --')
-          @hd.stubs(:string_send_color).with('-- Back --',
-                                             :menu_chrome_color).returns('-- Back --'.red)
-        end
+      def test_handle_stream_with_io_error
+        stream = StringIO.new("line 1\nline 2\n")
+        file_type = :stdout
+        stream.stubs(:each_line).raises(IOError)
 
-        def test_menu_chrome_colored_option_with_color
-          assert_equal '-- Back --'.red,
-                       @hd.menu_chrome_colored_option(:menu_option_back_name)
-        end
+        Thread.new { @hd.handle_stream(stream, file_type) }
 
-        def test_menu_chrome_colored_option_without_color
-          @hd.instance_variable_set(:@delegate_object,
-                                    { menu_option_back_name: 'Back' })
-          assert_equal '-- Back --',
-                       @hd.menu_chrome_colored_option(:menu_option_back_name)
-        end
-      end
-
-      class TestHashDelegatorMenuChromeFormattedOptionWithoutFormat < Minitest::Test
-        def setup
-          @hd = HashDelegator.new
-          @hd.instance_variable_set(:@delegate_object, {
-                                      menu_option_back_name: "'Back'",
-                                      menu_chrome_format: '-- %s --'
-                                    })
-          @hd.stubs(:safeval).with("'Back'").returns('Back')
-        end
-
-        def test_menu_chrome_formatted_option_with_format
-          assert_equal '-- Back --',
-                       @hd.menu_chrome_formatted_option(:menu_option_back_name)
-        end
+        @hd.wait_for_stream_processing
 
-        def test_menu_chrome_formatted_option_without_format
-          @hd.instance_variable_set(:@delegate_object,
-                                    { menu_option_back_name: "'Back'" })
-          assert_equal 'Back',
-                       @hd.menu_chrome_formatted_option(:menu_option_back_name)
-        end
+        assert_equal [],
+                     @hd.instance_variable_get(:@run_state).files[:stdout]
       end
+    end
 
-      class TestHashDelegatorStartFencedBlock < Minitest::Test
-        def setup
-          @hd = HashDelegator.new({
-                                    block_name_wrapper_match: 'WRAPPER_REGEX',
-                                    block_calls_scan: 'CALLS_REGEX'
-                                  })
-        end
+    class TestHashDelegatorIterBlocksFromNestedFiles < Minitest::Test
+      def setup
+        @hd = HashDelegator.new
+        @hd.instance_variable_set(:@delegate_object,
+                                  { filename: 'test.md' })
+        @hd.stubs(:check_file_existence).with('test.md').returns(true)
+        @hd.stubs(:initial_state).returns({})
+        @hd.stubs(:cfile).returns(Minitest::Mock.new)
+        @hd.stubs(:update_line_and_block_state)
+      end
 
-        def test_start_fenced_block
-          line = '```fenced'
-          headings = ['Heading 1']
-          regex = /```(?<name>\w+)(?<rest>.*)/
+      def test_iter_blocks_from_nested_files
+        @hd.cfile.expect(:readlines, ['line 1', 'line 2'], ['test.md'], import_paths: nil)
+        selected_messages = ['filtered message']
 
-          fcb = @hd.start_fenced_block(line, headings, regex)
+        result = @hd.iter_blocks_from_nested_files { selected_messages }
+        assert_equal ['line 1', 'line 2'], result
 
-          assert_instance_of MarkdownExec::FCB, fcb
-          assert_equal headings, fcb.headings
-          assert_equal 'fenced', fcb.dname
-        end
+        @hd.cfile.verify
       end
 
-      class TestHashDelegatorStringSendColor < Minitest::Test
-        def setup
-          @hd = HashDelegator.new
-          @hd.instance_variable_set(:@delegate_object,
-                                    { red: 'red', green: 'green' })
-        end
+      def test_iter_blocks_from_nested_files_with_no_file
+        @hd.stubs(:check_file_existence).with('test.md').returns(false)
 
-        def test_string_send_color
-          assert_equal 'Hello'.red, @hd.string_send_color('Hello', :red)
-          assert_equal 'World'.green,
-                       @hd.string_send_color('World', :green)
-          assert_equal 'Default'.plain,
-                       @hd.string_send_color('Default', :blue)
-        end
+        assert_nil(@hd.iter_blocks_from_nested_files do
+                     ['filtered message']
+                   end)
       end
+    end
 
-      def test_yield_line_if_selected_with_line
-        block_called = false
-        @hd.yield_line_if_selected('Test line', [:line]) do |type, content|
-          block_called = true
-          assert_equal :line, type
-          assert_equal 'Test line', content.body[0]
-        end
-        assert block_called
+    class TestHashDelegatorMenuChromeColoredOption < Minitest::Test
+      def setup
+        @hd = HashDelegator.new
+        @hd.instance_variable_set(:@delegate_object, {
+                                    menu_option_back_name: 'Back',
+                                    menu_chrome_color: :red,
+                                    menu_chrome_format: '-- %s --'
+                                  })
+        @hd.stubs(:menu_chrome_formatted_option).with(:menu_option_back_name).returns('-- Back --')
+        @hd.stubs(:string_send_color).with('-- Back --',
+                                           :menu_chrome_color).returns('-- Back --'.red)
       end
 
-      def test_yield_line_if_selected_without_line
-        block_called = false
-        @hd.yield_line_if_selected('Test line', [:other]) do |_|
-          block_called = true
-        end
-        refute block_called
+      def test_menu_chrome_colored_option_with_color
+        assert_equal '-- Back --'.red,
+                     @hd.menu_chrome_colored_option(:menu_option_back_name)
       end
 
-      def test_yield_line_if_selected_without_block
-        result = @hd.yield_line_if_selected('Test line', [:line])
-        assert_nil result
+      def test_menu_chrome_colored_option_without_color
+        @hd.instance_variable_set(:@delegate_object,
+                                  { menu_option_back_name: 'Back' })
+        assert_equal '-- Back --',
+                     @hd.menu_chrome_colored_option(:menu_option_back_name)
       end
     end
 
-    class TestHashDelegator < Minitest::Test
+    class TestHashDelegatorMenuChromeFormattedOptionWithoutFormat < Minitest::Test
       def setup
         @hd = HashDelegator.new
         @hd.instance_variable_set(:@delegate_object, {
-                                    heading1_match: '^# (?<name>.+)$',
-                                    heading2_match: '^## (?<name>.+)$',
-                                    heading3_match: '^### (?<name>.+)$'
+                                    menu_option_back_name: "'Back'",
+                                    menu_chrome_format: '-- %s --'
                                   })
+        HashDelegator.stubs(:safeval).with("'Back'").returns('Back')
       end
 
-      def test_update_document_headings
-        assert_equal(['Heading 1'],
-                     @hd.update_document_headings('# Heading 1', []))
-        assert_equal(['Heading 1', 'Heading 2'],
-                     @hd.update_document_headings('## Heading 2',
-                                                  ['Heading 1']))
-        assert_equal(['Heading 1', 'Heading 2', 'Heading 3'],
-                     @hd.update_document_headings('### Heading 3',
-                                                  ['Heading 1', 'Heading 2']))
-        assert_equal([], @hd.update_document_headings('Regular text', []))
+      def test_menu_chrome_formatted_option_with_format
+        assert_equal '-- Back --',
+                     @hd.menu_chrome_formatted_option(:menu_option_back_name)
+      end
+
+      def test_menu_chrome_formatted_option_without_format
+        @hd.instance_variable_set(:@delegate_object,
+                                  { menu_option_back_name: "'Back'" })
+        assert_equal 'Back',
+                     @hd.menu_chrome_formatted_option(:menu_option_back_name)
       end
     end
 
-    class TestHashDelegatorUpdateMenuAttribYieldSelectedWithBody < Minitest::Test
+    class TestHashDelegatorStartFencedBlock < Minitest::Test
       def setup
-        @hd = HashDelegator.new
-        @fcb = mock('Fcb')
-        @fcb.stubs(:body).returns(true)
-        @hd.stubs(:initialize_fcb_names)
-        @hd.stubs(:default_block_title_from_body)
-        @hd.stubs(:yield_to_block_if_applicable)
+        @hd = HashDelegator.new({
+                                  block_name_wrapper_match: 'WRAPPER_REGEX',
+                                  block_calls_scan: 'CALLS_REGEX'
+                                })
       end
 
-      def test_update_menu_attrib_yield_selected_with_body
-        @hd.expects(:initialize_fcb_names).with(@fcb)
-        @hd.expects(:default_block_title_from_body).with(@fcb)
-        @hd.expects(:yield_to_block_if_applicable).with(@fcb, [:some_message])
+      def test_start_fenced_block
+        line = '```fenced'
+        headings = ['Heading 1']
+        regex = /```(?<name>\w+)(?<rest>.*)/
 
-        @hd.update_menu_attrib_yield_selected(@fcb, [:some_message])
-      end
+        fcb = @hd.start_fenced_block(line, headings, regex)
 
-      def test_update_menu_attrib_yield_selected_without_body
-        @fcb.stubs(:body).returns(nil)
-        @hd.expects(:initialize_fcb_names).with(@fcb)
-        @hd.update_menu_attrib_yield_selected(@fcb, [:some_message])
+        assert_instance_of MarkdownExec::FCB, fcb
+        assert_equal headings, fcb.headings
+        assert_equal 'fenced', fcb.dname
       end
     end
 
-    class TestHashDelegatorWaitForUserSelectedBlock < Minitest::Test
+    class TestHashDelegatorStringSendColor < Minitest::Test
       def setup
         @hd = HashDelegator.new
-        @hd.stubs(:error_handler)
+        @hd.instance_variable_set(:@delegate_object,
+                                  { red: 'red', green: 'green' })
       end
 
-      def test_wait_for_user_selected_block_with_back_state
-        mock_block_state = Struct.new(:state, :block).new(MenuState::BACK,
-                                                          { oname: 'back_block' })
-        @hd.stubs(:wait_for_user_selection).returns(mock_block_state)
+      def test_string_send_color
+        assert_equal 'Hello'.red, @hd.string_send_color('Hello', :red)
+        assert_equal 'World'.green,
+                     @hd.string_send_color('World', :green)
+        assert_equal 'Default'.plain,
+                     @hd.string_send_color('Default', :blue)
+      end
+    end
 
-        result = @hd.wait_for_user_selected_block([], ['Block 1', 'Block 2'],
-                                                  nil)
+    def test_yield_line_if_selected_with_line
+      block_called = false
+      HashDelegator.yield_line_if_selected('Test line', [:line]) do |type, content|
+        block_called = true
+        assert_equal :line, type
+        assert_equal 'Test line', content.body[0]
+      end
+      assert block_called
+    end
 
-        assert_equal 'back_block',
-                     @hd.instance_variable_get(:@delegate_object)[:block_name]
-        assert @hd.instance_variable_get(:@menu_user_clicked_back_link)
-        assert_equal mock_block_state, result
+    def test_yield_line_if_selected_without_line
+      block_called = false
+      HashDelegator.yield_line_if_selected('Test line', [:other]) do |_|
+        block_called = true
       end
+      refute block_called
+    end
 
-      def test_wait_for_user_selected_block_with_continue_state
-        mock_block_state = Struct.new(:state, :block).new(
-          MenuState::CONTINUE, { oname: 'continue_block' }
-        )
-        @hd.stubs(:wait_for_user_selection).returns(mock_block_state)
+    def test_yield_line_if_selected_without_block
+      result = HashDelegator.yield_line_if_selected('Test line', [:line])
+      assert_nil result
+    end
+  end
 
-        result = @hd.wait_for_user_selected_block([], ['Block 1', 'Block 2'],
-                                                  nil)
+  class TestHashDelegatorUpdateMenuAttribYieldSelectedWithBody < Minitest::Test
+    def setup
+      @hd = HashDelegator.new
+      @fcb = mock('Fcb')
+      @fcb.stubs(:body).returns(true)
+      HashDelegator.stubs(:initialize_fcb_names)
+      HashDelegator.stubs(:default_block_title_from_body)
+      Filter.stubs(:yield_to_block_if_applicable)
+    end
 
-        assert_equal 'continue_block',
-                     @hd.instance_variable_get(:@delegate_object)[:block_name]
-        refute @hd.instance_variable_get(:@menu_user_clicked_back_link)
-        assert_equal mock_block_state, result
-      end
+    def test_update_menu_attrib_yield_selected_with_body
+      HashDelegator.expects(:initialize_fcb_names).with(@fcb)
+      HashDelegator.expects(:default_block_title_from_body).with(@fcb)
+      Filter.expects(:yield_to_block_if_applicable).with(@fcb, [:some_message], {})
+
+      HashDelegator.update_menu_attrib_yield_selected(@fcb, [:some_message])
     end
 
-    class TestHashDelegatorYieldToBlock < Minitest::Test
-      def setup
-        @hd = HashDelegator.new
-        @fcb = mock('Fcb')
-        MarkdownExec::Filter.stubs(:fcb_select?).returns(true)
-      end
+    def test_update_menu_attrib_yield_selected_without_body
+      @fcb.stubs(:body).returns(nil)
+      HashDelegator.expects(:initialize_fcb_names).with(@fcb)
+      HashDelegator.update_menu_attrib_yield_selected(@fcb, [:some_message])
+    end
+  end
 
-      def test_yield_to_block_if_applicable_with_correct_conditions
-        block_called = false
-        @hd.yield_to_block_if_applicable(@fcb, [:blocks]) do |type, fcb|
-          block_called = true
-          assert_equal :blocks, type
-          assert_equal @fcb, fcb
-        end
-        assert block_called
-      end
+  class TestHashDelegatorWaitForUserSelectedBlock < Minitest::Test
+    def setup
+      @hd = HashDelegator.new
+      HashDelegator.stubs(:error_handler)
+    end
 
-      def test_yield_to_block_if_applicable_without_block
-        result = @hd.yield_to_block_if_applicable(@fcb, [:blocks])
-        assert_nil result
+    def test_wait_for_user_selected_block_with_back_state
+      mock_block_state = Struct.new(:state, :block).new(MenuState::BACK,
+                                                        { oname: 'back_block' })
+      @hd.stubs(:wait_for_user_selection).returns(mock_block_state)
+
+      result = @hd.wait_for_user_selected_block([], ['Block 1', 'Block 2'],
+                                                nil)
+
+      assert_equal 'back_block',
+                   @hd.instance_variable_get(:@delegate_object)[:block_name]
+      assert @hd.instance_variable_get(:@menu_user_clicked_back_link)
+      assert_equal mock_block_state, result
+    end
+
+    def test_wait_for_user_selected_block_with_continue_state
+      mock_block_state = Struct.new(:state, :block).new(
+        MenuState::CONTINUE, { oname: 'continue_block' }
+      )
+      @hd.stubs(:wait_for_user_selection).returns(mock_block_state)
+
+      result = @hd.wait_for_user_selected_block([], ['Block 1', 'Block 2'],
+                                                nil)
+
+      assert_equal 'continue_block',
+                   @hd.instance_variable_get(:@delegate_object)[:block_name]
+      refute @hd.instance_variable_get(:@menu_user_clicked_back_link)
+      assert_equal mock_block_state, result
+    end
+  end
+
+  class TestHashDelegatorYieldToBlock < Minitest::Test
+    def setup
+      @hd = HashDelegator.new
+      @fcb = mock('Fcb')
+      MarkdownExec::Filter.stubs(:fcb_select?).returns(true)
+    end
+
+    def test_yield_to_block_if_applicable_with_correct_conditions
+      block_called = false
+      Filter.yield_to_block_if_applicable(@fcb, [:blocks]) do |type, fcb|
+        block_called = true
+        assert_equal :blocks, type
+        assert_equal @fcb, fcb
       end
+      assert block_called
+    end
 
-      def test_yield_to_block_if_applicable_with_incorrect_conditions
-        block_called = false
-        MarkdownExec::Filter.stubs(:fcb_select?).returns(false)
-        @hd.yield_to_block_if_applicable(@fcb, [:non_blocks]) do |_|
-          block_called = true
-        end
-        refute block_called
+    def test_yield_to_block_if_applicable_without_block
+      result = Filter.yield_to_block_if_applicable(@fcb, [:blocks])
+      assert_nil result
+    end
+
+    def test_yield_to_block_if_applicable_with_incorrect_conditions
+      block_called = false
+      MarkdownExec::Filter.stubs(:fcb_select?).returns(false)
+      Filter.yield_to_block_if_applicable(@fcb, [:non_blocks]) do |_|
+        block_called = true
       end
+      refute block_called
     end
-  end # module MarkdownExec
-end
+  end
+end # module MarkdownExec