markdown_exec 2.8.3 → 2.8.5

data/lib/hash_delegator.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env bundle exec ruby
+#!/usr/bin/env -S bundle exec ruby
 # frozen_string_literal: true
 
 # encoding=utf-8
@@ -45,14 +45,6 @@ require_relative 'text_analyzer'
 $pd = false unless defined?($pd)
 $table_cell_truncate = true
 
-class String
-  # Checks if the string is not empty.
-  # @return [Boolean] Returns true if the string is not empty, false otherwise.
-  def non_empty?
-    !empty?
-  end
-end
-
 module HashDelegatorSelf
   # 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
@@ -166,7 +158,7 @@ module HashDelegatorSelf
   #  (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?
+    return body unless indent&.present?
 
     body.lines.map { |line| indent + line.chomp }.join("\n")
   end
@@ -862,12 +854,15 @@ module MarkdownExec
 
       count = 0
       blocks = []
+      results = {}
       iter_blocks_from_nested_files do |btype, fcb|
         count += 1
         case btype
         when :blocks
+          result = SuccessResult.instance
           if @delegate_object[:bash]
-            fcb.for_menu!(
+            # prepare block for menu, may fail and call HashDelegator.error_handler
+            result = fcb.for_menu!(
               block_calls_scan: @delegate_object[:block_calls_scan],
               block_name_match: @delegate_object[:block_name_match],
               block_name_nick_match: @delegate_object[:block_name_nick_match],
@@ -878,10 +873,11 @@ module MarkdownExec
             ) do |oname, color|
               apply_block_type_color_option(oname, color)
             end
+            results[fcb.id] = result if result.failure?
           else
             expand_references!(fcb, link_state)
           end
-          blocks << fcb
+          blocks << fcb unless result.failure?
         when :filter # types accepted
           %i[blocks line]
         when :line
@@ -896,9 +892,9 @@ module MarkdownExec
           end
         end
       end
-      # !!t blocks.count
-      blocks
+      OpenStruct.new(blocks: blocks, results: results)
     rescue StandardError
+      # ww $@, $!,
       HashDelegator.error_handler('blocks_from_nested_files')
     end
 
@@ -914,7 +910,8 @@ module MarkdownExec
       initial_code_required: false, key_format:
     )
       evaluate_shell_expressions(
-        (link_state&.inherited_lines_block || ''), commands,
+        (link_state&.inherited_lines_block || ''),
+        commands,
         initial_code_required: initial_code_required,
         key_format: key_format
       )
@@ -990,6 +987,52 @@ module MarkdownExec
       ]
     end
 
+    # Executes the allowed exec command and processes the output
+    # @param export [Object] The export configuration object
+    # @param inherited_code [Array] The inherited code lines
+    # @param code_lines [Array] The code lines to append to
+    # @param required [Hash] Required code information
+    # @return [String, Symbol] The command output or :ux_exec_prohibited if execution failed
+    def process_allowed_exec(export, inherited_code, code_lines, required)
+      output = export_exec_with_code(
+        export, inherited_code, code_lines, required
+      )
+      return :ux_exec_prohibited if output == :invalidated
+
+      output.split("\n")
+    end
+
+    def code_from_automatic_ux_blocks(
+      all_blocks,
+      mdoc
+    )
+      unless @ux_most_recent_filename != @delegate_object[:filename]
+        return
+      end
+
+      blocks = select_automatic_ux_blocks(all_blocks)
+      if blocks.empty?
+        blocks = select_automatic_ux_blocks(all_blocks)
+      end
+      return if blocks.empty?
+
+      @ux_most_recent_filename = @delegate_object[:filename]
+
+      (blocks.each.with_object([]) do |block, merged_options|
+        code = code_from_ux_block_to_set_environment_variables(
+          block,
+          mdoc,
+          force: @delegate_object[:ux_auto_load_force_default],
+          only_default: true
+        )
+        if code == :ux_exec_prohibited
+          merged_options
+        else
+          merged_options.push(code)
+        end
+      end).to_a
+    end
+
     # parse YAML body defining the UX for a single variable
     # set ENV value for the variable and return code lines for the same
     def code_from_ux_block_to_set_environment_variables(
@@ -1023,105 +1066,30 @@ module MarkdownExec
             code_lines.push "[[ -z $#{precondition} ]] && exit 1"
           end
 
-          exportable = true
           if only_default
-            value = case export.default
-                    # echo > default
-                    when :echo
-                      raise unless export.echo.present?
-
-                      output = export_echo_with_code(
-                        export, inherited_code, code_lines, required
-                      )
-                      if output == :invalidated
-                        return :ux_exec_prohibited
-                      end
-
-                      transform_export_value(output, export)
-
-                    # exec > default
-                    when :exec
-                      raise unless export.exec.present?
-
-                      output = export_exec_with_code(
-                        export, inherited_code, code_lines, required
-                      )
-                      if output == :invalidated
-                        return :ux_exec_prohibited
-                      end
-
-                      transform_export_value(output, export)
-
-                    # default
-                    else
-                      export.default.to_s
-                    end
-          else
-            value = nil
-
-            # echo > exec
-            if export.echo
-              value = export_echo_with_code(
+            value, exportable, transformable =
+              ux_block_export_automatic(
                 export, inherited_code, code_lines, required
               )
-              if value == :invalidated
-                return :ux_exec_prohibited
-              end
-
-            # exec > allowed
-            elsif export.exec
-              value = export_exec_with_code(
-                export, inherited_code, code_lines, required
+          else
+            value, exportable, transformable =
+              ux_block_export_activated(
+                export, inherited_code, code_lines, required, exit_prompt
               )
-              if value == :invalidated
-                return :ux_exec_prohibited
-              end
-
-            # allowed > prompt
-            elsif export.allowed && export.allowed.count.positive?
-              case (choice = prompt_select_code_filename(
-                [exit_prompt] + export.allowed,
-                string: export.prompt,
-                color_sym: :prompt_color_after_script_execution
-              ))
-              when exit_prompt
-                exportable = false
-              else
-                value = choice
-              end
-
-            # prompt > default
-            elsif export.prompt.present?
-              begin
-                loop do
-                  print "#{export.prompt} [#{export.default}]: "
-                  value = gets.chomp
-                  value = export.default.to_s if value.empty?
-                  caps = NamedCaptureExtractor.extract_named_groups(value,
-                                                                    export.validate)
-                  break if caps
-
-                  # invalid input, retry
-                end
-              rescue Interrupt
-                exportable = false
-              end
+          end
+          return :ux_exec_prohibited if value == :ux_exec_prohibited
 
-            # default
-            else
-              value = export.default
+          if SelectResponse.continue?(value)
+            if transformable
+              value = transform_export_value(value, export)
             end
 
             if exportable
-              value = transform_export_value(value, export)
+              ENV[export.name] = value.to_s
+              code_lines.push code_line_safe_assign(export.name, value,
+                                                    force: force)
             end
           end
-
-          if exportable
-            ENV[export.name] = value.to_s
-            code_lines.push code_line_safe_assign(export.name, value,
-                                                  force: force)
-          end
         else
           raise "Invalid data type: #{data.inspect}"
         end
@@ -1363,7 +1331,7 @@ module MarkdownExec
     )
       # Initialize a counter for named group occurrences
       occurrence_count = Hash.new(0)
-      return occurrence_count if pattern == //
+      return occurrence_count if pattern.nil? || pattern == //
 
       blocks.each do |block|
         # Skip processing for shell-type blocks
@@ -1381,7 +1349,7 @@ module MarkdownExec
 
     def count_named_group_occurrences_block_body_fix_indent(block)
       ### actually double the entries, but not a problem since it's used as a boolean
-      ([block.oname || ''] + block.body).join("\n")
+      ([block.oname || ''] + (block.body || [''])).join("\n")
     end
 
     ##
@@ -1425,10 +1393,30 @@ module MarkdownExec
       line_cap[:line] ||= ''
 
       line_caps = [line_cap]
-      if wrap && line_cap[:text].length > screen_width_for_wrapping
-        wrapper = StringWrapper.new(width: screen_width_for_wrapping - line_cap[:indent].length)
-        line_caps = wrapper.wrap(line_cap[:text]).map do |wrapped_line|
-          line_cap.dup.merge(text: wrapped_line)
+
+      # split text with newlines, from variable expansion
+      if line_cap[:text].include?("\n")
+        lines = line_cap[:text].split("\n")
+        line_caps = lines.map do |line|
+          line_cap.dup.merge(text: line)
+        end.to_a
+      end
+
+      # wrap text on multiple lines to screen width, replacing line_caps
+      if wrap
+        line_caps = line_caps.flat_map do |line_cap|
+          text = line_cap[:text]
+          wrapper = StringWrapper.new(width: screen_width_for_wrapping - line_cap[:indent].length)
+
+          if text.length > screen_width_for_wrapping
+            # Wrap this text and create line_cap objects for each part
+            wrapper.wrap(text).map do |wrapped_text|
+              line_cap.dup.merge(text: wrapped_text)
+            end
+          else
+            # No change needed for this line
+            line_cap
+          end
         end
       end
 
@@ -1527,7 +1515,11 @@ module MarkdownExec
         if block_given?
           # expand references only if block is recognized (not a comment)
           yield if block_given?
-          mbody = fcb.body[0].match @delegate_object[criteria[:match]]
+
+          # parse multiline to capture output of variable expansion
+          mbody = fcb.body[0].match Regexp.new(
+            @delegate_object[criteria[:match]], Regexp::MULTILINE
+          )
         end
 
         create_and_add_chrome_block(
@@ -2432,7 +2424,8 @@ module MarkdownExec
       # update blocks
       #
       Regexp.union(replacements.keys.map do |word|
-                     Regexp.new(Regexp.escape(word))
+                     # match multiline text from variable expansion
+                     Regexp.new(Regexp.escape(word), Regexp::MULTILINE)
                    end).tap do |pattern|
         menu_blocks.each do |block|
           next if exclude_types.include?(block.type)
@@ -2446,14 +2439,16 @@ module MarkdownExec
       expand_variable_references!(
         blocks: [fcb],
         initial_code_required: false,
-        link_state: link_state
+        key_format: @delegate_object[:variable_expression_format],
+        link_state: link_state,
+        pattern: options_variable_expression_regexp
       )
       expand_variable_references!(
         blocks: [fcb],
         echo_format: '%s',
         group_name: :command,
         initial_code_required: false,
-        key_format: '$(%s)',
+        key_format: @delegate_object[:command_substitution_format],
         link_state: link_state,
         pattern: options_command_substitution_regexp
       )
@@ -2461,16 +2456,13 @@ module MarkdownExec
 
     def expand_variable_references!(
       blocks:,
-      echo_format: 'echo $%s',
+      echo_format: 'echo "$%s"',
       group_name: :variable,
       initial_code_required: false,
-      key_format: '${%s}',
+      key_format:,
       link_state:,
-      pattern: nil
+      pattern:
     )
-      pattern ||= options_variable_expression_regexp
-      return if pattern.nil?
-
       variable_counts = count_named_group_occurrences(blocks, pattern,
                                                       group_name: group_name)
       return if variable_counts.nil? || variable_counts == {}
@@ -2489,9 +2481,11 @@ module MarkdownExec
       expand_blocks_with_replacements(blocks, replacements)
     end
 
-    def export_echo_with_code(export, inherited_code, code_lines, required)
+    def export_echo_with_code_single(export_echo, inherited_code, code_lines,
+                                     required)
+      code = %(printf '%s' "#{export_echo}")
       value = execute_temporary_script(
-        %Q{eval printf '%s' "#{export.echo}"},
+        code,
         (inherited_code || []) +
          code_lines + required[:code]
       )
@@ -2501,6 +2495,26 @@ module MarkdownExec
       value
     end
 
+    def export_echo_with_code(export, inherited_code, code_lines, required,
+                              force:)
+      exportable = true
+      case export.echo
+      when String, Integer, Float, TrueClass, FalseClass
+        value = export_echo_with_code_single(export.echo.to_s, inherited_code,
+                                             code_lines, required)
+      when Hash
+        # each item in the hash is a variable name and value
+        export.echo.each do |name, expression|
+          value = export_echo_with_code_single(expression, inherited_code,
+                                               code_lines, required)
+          ENV[name] = value.to_s
+          code_lines.push code_line_safe_assign(name, value, force: force)
+        end
+        exportable = false
+      end
+      [value, exportable]
+    end
+
     def export_exec_with_code(export, inherited_code, code_lines, required)
       value = execute_temporary_script(
         export.exec,
@@ -2555,7 +2569,7 @@ module MarkdownExec
       end
 
       @dml_blocks_in_file.find(&match_block) ||
-       @dml_menu_blocks.find(&match_block)
+        @dml_menu_blocks.find(&match_block)
     end
 
     # find a block by its original (undecorated) name or nickname (not visible in menu)
@@ -2763,7 +2777,7 @@ module MarkdownExec
           menu_entries, current_display_format
         )
 
-        selection = prompt_select_code_filename(
+        selection = prompt_select_from_list(
           menu_options,
           string: menu_title,
           color_sym: :prompt_color_after_script_execution
@@ -2819,7 +2833,7 @@ module MarkdownExec
     def iter_source_blocks(source, source_id: nil, &block)
       case source
       when 1
-        blocks_from_nested_files(source_id: source_id).each(&block)
+        blocks_from_nested_files(source_id: source_id).blocks.each(&block)
       when 2
         @dml_blocks_in_file.each(&block)
       when 3
@@ -2862,7 +2876,8 @@ module MarkdownExec
                                                   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)
+            format1: @delegate_object.fetch(:output_assignment_format, nil),
+            name: ''
           )
 
         else
@@ -2969,69 +2984,45 @@ module MarkdownExec
       @fout.fout_list(list)
     end
 
-    # Loads auto blocks based on delegate object settings and updates
-    #  if new filename is detected.
-    # Executes a specified block once per filename.
-    # @param all_blocks [Array] Array of all block elements.
-    # @return [Boolean, nil] True if values were modified, nil otherwise.
+    # Loads and updates auto options for document blocks if the current filename has changed.
+    #
+    # This method checks if the delegate object specifies a document load options block name and if the filename
+    # has been updated. It then selects the appropriate blocks, collects their dependencies, processes their
+    # options, and updates the menu base with the merged options.
+    #
+    # @param all_blocks [Array] An array of all block elements.
+    # @param mdoc [Object] The document object managing dependencies and options.
+    # @return [Boolean, nil] Returns true if options were updated; nil otherwise.
     def load_auto_opts_block(all_blocks, mdoc:)
-      block_name = @delegate_object[:document_load_opts_block_name]
-      unless block_name.present? &&
-             @opts_most_recent_filename != @delegate_object[:filename]
-        return
-      end
+      opts_block_name = @delegate_object[:document_load_opts_block_name]
+      current_filename = @delegate_object[:filename]
 
-      blocks = HashDelegator.block_select(all_blocks, :oname, block_name)
-      return if blocks.empty?
+      return unless opts_block_name.present? &&
+                    @opts_most_recent_filename != current_filename
+
+      selected_blocks = HashDelegator.block_select(all_blocks, :oname,
+                                                   opts_block_name)
+      return if selected_blocks.empty?
+
+      dependency_map = {}
+      selected_blocks.each do |block|
+        mdoc.collect_dependencies(memo: dependency_map, block: block)
+      end
 
-      update_menu_base(
-        blocks.each.with_object({}) do |block, merged_options|
+      collected_options =
+        dependency_map.each.with_object({}) do |(block_id, _), merged_options|
+          matching_block = HashDelegator.block_find(all_blocks, :id, block_id)
           options_state = read_show_options_and_trigger_reuse(
-            mdoc: mdoc,
-            selected: block
+            mdoc: mdoc, selected: matching_block
           )
           merged_options.merge!(options_state.options)
         end
-      )
 
-      @opts_most_recent_filename = @delegate_object[:filename]
+      update_menu_base(collected_options)
+      @opts_most_recent_filename = current_filename
       true
     end
 
-    def load_auto_ux_block(
-      all_blocks,
-      mdoc,
-      block_name: @delegate_object[:document_load_ux_block_name]
-    )
-      unless block_name.present? &&
-             @ux_most_recent_filename != @delegate_object[:filename]
-        return
-      end
-
-      blocks = HashDelegator.block_select(all_blocks, :oname, block_name)
-      if blocks.empty?
-        blocks = HashDelegator.block_match(all_blocks, :nickname,
-                                           Regexp.new(block_name))
-      end
-      return if blocks.empty?
-
-      @ux_most_recent_filename = @delegate_object[:filename]
-
-      (blocks.each.with_object([]) do |block, merged_options|
-        code = code_from_ux_block_to_set_environment_variables(
-          block,
-          mdoc,
-          force: @delegate_object[:ux_auto_load_force_default],
-          only_default: true
-        )
-        if code == :ux_exec_prohibited
-          merged_options
-        else
-          merged_options.push(code)
-        end
-      end).to_a
-    end
-
     def load_auto_vars_block(
       all_blocks,
       block_name: @delegate_object[:document_load_vars_block_name]
@@ -3123,7 +3114,7 @@ module MarkdownExec
       else
         ## user selects from existing files or other
         #
-        case (name = prompt_select_code_filename(
+        case (name = prompt_select_from_list(
           [@delegate_object[:prompt_filespec_back]] + files,
           string: @delegate_object[:prompt_select_code_file],
           color_sym: :prompt_color_after_script_execution
@@ -3154,11 +3145,19 @@ module MarkdownExec
     end
 
     def mdoc_and_blocks_from_nested_files(source_id: nil)
-      menu_blocks = blocks_from_nested_files(source_id: source_id)
-      mdoc = MDoc.new(menu_blocks) do |nopts|
+      blocks_results = blocks_from_nested_files(source_id: source_id)
+
+      blocks_results.results.select do |_id, result|
+        result.failure?
+      end.each do |id, result|
+        HashDelegator.error_handler("#{id} - #{result.to_yaml}")
+      end
+
+      mdoc = MDoc.new(blocks_results.blocks) do |nopts|
         @delegate_object.merge!(nopts)
       end
-      [menu_blocks, mdoc]
+
+      [blocks_results.blocks, mdoc]
     end
 
     ## Handles the file loading and returns the blocks
@@ -3184,7 +3183,7 @@ module MarkdownExec
 
       # load document ux block
       #
-      if (code_lines = load_auto_ux_block(all_blocks, mdoc))
+      if (code_lines = code_from_automatic_ux_blocks(all_blocks, mdoc))
         new_code = HashDelegator.code_merge(link_state.inherited_lines,
                                             code_lines)
         next_state_set_code(nil, link_state, new_code)
@@ -3305,6 +3304,19 @@ module MarkdownExec
       end
     end
 
+    def menu_from_list_with_back(list)
+      case (name = prompt_select_from_list(
+        [@delegate_object[:prompt_filespec_back]] + list,
+        string: @delegate_object[:prompt_select_code_file],
+        color_sym: :prompt_color_after_script_execution
+      ))
+      when @delegate_object[:prompt_filespec_back]
+        SelectResponse::BACK
+      else
+        name
+      end
+    end
+
     def menu_toggle_collapsible_block(selected)
       # return true if @compress_ids.key?(fcb.id) && !!@compress_ids[fcb.id]
       # return false if @expand_ids.key?(fcb.id) && !!@expand_ids[fcb.id]
@@ -3487,6 +3499,11 @@ module MarkdownExec
       fout_execution_report if @delegate_object[:output_execution_report]
     end
 
+    # all UX blocks are automatic for the document
+    def select_automatic_ux_blocks(blocks)
+      blocks.select { |item| item.type == 'ux' }
+    end
+
     # Filter blocks per block_name_include_match, block_name_wrapper_match.
     #
     # @param all_blocks [Array<Hash>] The list of blocks from the file.
@@ -3538,7 +3555,7 @@ module MarkdownExec
     # private
 
     def process_string_array(arr, begin_pattern: nil, end_pattern: nil, scan1: nil,
-                             format1: nil)
+                             format1: nil, name: '')
       in_block = !begin_pattern.present?
       collected_lines = []
 
@@ -3560,6 +3577,9 @@ module MarkdownExec
                 collected_lines << formatted
               end
             end
+          elsif format1.present?
+            formatted = format(format1, { value: line })
+            collected_lines << formatted
           else
             collected_lines << line
           end
@@ -3685,9 +3705,22 @@ module MarkdownExec
       0
     end
 
+    def prompt_select_continue(filter: true, quiet: true)
+      sel = @prompt.select(
+        string_send_color(@delegate_object[:prompt_after_script_execution],
+                          :prompt_color_after_script_execution),
+        filter: filter,
+        quiet: quiet
+      ) do |menu|
+        menu.choice @delegate_object[:prompt_yes]
+        menu.choice @delegate_object[:prompt_exit]
+      end
+      sel == @delegate_object[:prompt_exit] ? MenuState::EXIT : MenuState::CONTINUE
+    end
+
     # public
 
-    def prompt_select_code_filename(
+    def prompt_select_from_list(
       filenames,
       color_sym: :prompt_color_after_script_execution,
       cycle: true,
@@ -3713,19 +3746,6 @@ module MarkdownExec
       end
     end
 
-    def prompt_select_continue(filter: true, quiet: true)
-      sel = @prompt.select(
-        string_send_color(@delegate_object[:prompt_after_script_execution],
-                          :prompt_color_after_script_execution),
-        filter: filter,
-        quiet: quiet
-      ) do |menu|
-        menu.choice @delegate_object[:prompt_yes]
-        menu.choice @delegate_object[:prompt_exit]
-      end
-      sel == @delegate_object[:prompt_exit] ? MenuState::EXIT : MenuState::CONTINUE
-    end
-
     # user prompt to exit if the menu will be displayed again
     #
     def prompt_user_exit(block_name_from_cli:, selected:)
@@ -3799,27 +3819,6 @@ module MarkdownExec
       end&.compact
     end
 
-    def saved_asset_for_history(
-      file:, form:, match_info:
-    )
-      OpenStruct.new(
-        file: file[(Dir.pwd.length + 1)..-1],
-        full: file,
-        row: format(
-          form,
-          # default '*' so unknown parameters are given a wildcard
-          match_info.names.each_with_object(Hash.new('*')) do |name, hash|
-            hash[name.to_sym] = match_info[name]
-          end
-        )
-      )
-    rescue KeyError
-      # pp $!, $@
-      warn "Cannot format with: #{@delegate_object[:saved_history_format]}"
-      error_handler('saved_history_format')
-      :break
-    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.
@@ -3874,8 +3873,8 @@ module MarkdownExec
     #      console [height, width]. If not provided or if the terminal
     #      is resized, it will be set to the current console dimensions.
     #   - :select_page_height [Integer, nil] The height of the page for
-    #      selection. If not provided or if not positive, it will be set
-    #      to the maximum of (console height - 3) or 4.
+    #      selection. If not provided or if not positive, it
+    #      will be set to the maximum of (console height - 3) or 4.
     #   - :per_page [Integer, nil] The number of items per page. If
     #      :select_page_height is not provided or if not positive, it
     #      will be set to the maximum of (console height - 3) or 4.
@@ -4002,7 +4001,7 @@ module MarkdownExec
         ## user selects from existing files or other
         # input into path with wildcard for easy entry
         #
-        case (name = prompt_select_code_filename(
+        case (name = prompt_select_from_list(
           [@delegate_object[:prompt_filespec_back],
            @delegate_object[:prompt_filespec_other]] + files,
           string: @delegate_object[:prompt_select_code_file],
@@ -4039,6 +4038,27 @@ module MarkdownExec
       ).generate_name
     end
 
+    def saved_asset_for_history(
+      file:, form:, match_info:
+    )
+      OpenStruct.new(
+        file: file[(Dir.pwd.length + 1)..-1],
+        full: file,
+        row: format(
+          form,
+          # default '*' so unknown parameters are given a wildcard
+          match_info.names.each_with_object(Hash.new('*')) do |name, hash|
+            hash[name.to_sym] = match_info[name]
+          end
+        )
+      )
+    rescue KeyError
+      # pp $!, $@
+      warn "Cannot format with: #{@delegate_object[:saved_history_format]}"
+      error_handler('saved_history_format')
+      :break
+    end
+
     def screen_width
       width = @delegate_object[:screen_width]
       if width&.positive?
@@ -4387,6 +4407,166 @@ module MarkdownExec
       @delegate_object.merge!(options)
     end
 
+    def ux_block_export_activated(export, inherited_code, code_lines, required,
+                                  exit_prompt)
+      exportable = true
+      transformable = true
+      [if export.allowed.present?
+         if export.allowed == :echo
+           output, exportable = export_echo_with_code(
+             export, inherited_code, code_lines, required, force: true
+           )
+           return :ux_exec_prohibited if output == :invalidated
+
+           menu_from_list_with_back(output.split("\n"))
+
+         elsif export.allowed == :exec
+           output = process_allowed_exec(export, inherited_code,
+                                         code_lines, required)
+           return :ux_exec_prohibited if output == :ux_exec_prohibited
+
+           menu_from_list_with_back(output)
+
+         else
+           menu_from_list_with_back(export.allowed)
+         end
+
+       # echo > exec
+       elsif export.echo
+         output, exportable = export_echo_with_code(
+           export, inherited_code, code_lines, required, force: true
+         )
+         return :ux_exec_prohibited if output == :invalidated
+
+         output
+
+       # exec > allowed
+       elsif export.exec
+         output = export_exec_with_code(
+           export, inherited_code, code_lines, required
+         )
+         return :ux_exec_prohibited if output == :invalidated
+
+         output
+
+       # allowed > prompt
+       elsif export.allowed && export.allowed.count.positive?
+         case (choice = prompt_select_from_list(
+           [exit_prompt] + export.allowed,
+           string: export.prompt,
+           color_sym: :prompt_color_after_script_execution
+         ))
+         when exit_prompt
+           exportable = false
+           transformable = false
+           nil
+         else
+           choice
+         end
+
+       # prompt > default
+       elsif export.prompt.present?
+         begin
+           loop do
+             print "#{export.prompt} [#{export.default}]: "
+             output = gets.chomp
+             output = export.default.to_s if output.empty?
+             caps = NamedCaptureExtractor.extract_named_groups(output,
+                                                               export.validate)
+             break if caps
+
+             # invalid input, retry
+           end
+         rescue Interrupt
+           exportable = false
+           transformable = false
+         end
+
+         output
+
+       # default
+       else
+         transformable = false
+         export.default
+       end, exportable, transformable]
+    end
+
+    def ux_block_export_automatic(export, inherited_code, code_lines, required)
+      transformable = true
+      exportable = true
+
+      if export.default == false
+        exportable = false
+        transformable = false
+        value = nil
+      else
+        if export.default.nil?
+          if export.echo.present?
+            export.default = :echo
+          elsif export.exec.present?
+            export.default = :exec
+          elsif export.allowed.present?
+            export.default = export.allowed.first
+          end
+        end
+
+        value = case export.default
+                when :allowed
+                  raise unless export.allowed.present?
+
+                  if export.allowed == :echo
+                    output, exportable = export_echo_with_code(
+                      export, inherited_code, code_lines, required, force: false
+                    )
+                    return :ux_exec_prohibited if output == :invalidated
+
+                    exportable && output.split("\n").first
+
+                  elsif export.allowed == :exec
+                    output = process_allowed_exec(export, inherited_code,
+                                                  code_lines, required)
+                    return :ux_exec_prohibited if output == :ux_exec_prohibited
+
+                    output.first
+
+                  else
+                    export.allowed.first
+                  end
+
+                # echo > default
+                when :echo
+                  raise unless export.echo.present?
+
+                  output, exportable = export_echo_with_code(
+                    export, inherited_code, code_lines, required, force: false
+                  )
+                  return :ux_exec_prohibited if output == :invalidated
+
+                  output
+
+                # exec > default
+                when :exec
+                  raise unless export.exec.present?
+
+                  output = export_exec_with_code(
+                    export, inherited_code, code_lines, required
+                  )
+                  return :ux_exec_prohibited if output == :invalidated
+
+                  output
+
+                # default
+                else
+                  transformable = false
+                  export.default.to_s
+                end
+      end
+
+      [value,
+       exportable,
+       transformable]
+    end
+
     def vux_await_user_selection(prior_answer: @dml_block_selection)
       @dml_block_state = load_cli_or_user_selected_block(
         all_blocks: @dml_blocks_in_file,
@@ -5324,7 +5504,7 @@ module MarkdownExec
     end
 
     def test_blocks_from_nested_files
-      result = @hd.blocks_from_nested_files
+      result = @hd.blocks_from_nested_files.blocks
       assert_kind_of Array, result
       assert_kind_of FCB, result.first
     end
@@ -5333,7 +5513,7 @@ module MarkdownExec
       @hd = HashDelegator.new(no_chrome: true)
       @hd.expects(:create_and_add_chrome_blocks).never
 
-      result = @hd.blocks_from_nested_files
+      result = @hd.blocks_from_nested_files.blocks
 
       assert_kind_of Array, result
     end