markdown_exec 2.0.8.4 → 2.2.0

data/lib/link_history.rb

@@ -2,10 +2,13 @@
 # frozen_string_literal: true
 
 # encoding=utf-8
+
+$pd = false unless defined?($pd)
+
 module MarkdownExec
   class LinkState
     attr_accessor :block_name, :display_menu, :document_filename,
-                  :inherited_block_names, :inherited_dependencies, :inherited_lines,
+                  :inherited_block_names, :inherited_dependencies,
                   :prior_block_was_link
 
     # Initialize the LinkState with keyword arguments for each attribute.
@@ -45,6 +48,36 @@ module MarkdownExec
         other.inherited_lines == inherited_lines &&
         other.prior_block_was_link == prior_block_was_link
     end
+
+    def inherited_lines
+      @inherited_lines.tap { |ret| pp ['LinkState.inherited_lines() ->', ret] if $pd }
+    end
+
+    def inherited_lines=(value)
+      @inherited_lines = value.tap { |ret| pp ['LinkState.inherited_lines=() ->', ret] if $pd }
+    end
+
+    def inherited_lines_append(value)
+      @inherited_lines = ((@inherited_lines || []) + value).tap { |ret| pp ['LinkState.inherited_lines_append() ->', ret] if $pd }
+    end
+
+    def inherited_lines_block
+      @inherited_lines.join("\n").tap { |ret| pp ['LinkState.inherited_lines_block() ->', ret] if $pd }
+    end
+
+    def inherited_lines_count
+      (@inherited_lines&.count || 0).tap { |ret| pp ['LinkState.inherited_lines_count() ->', ret] if $pd }
+    end
+
+    def inherited_lines_map
+      @inherited_lines.map do |line|
+        yield line
+      end.tap { |ret| pp ['LinkState.inherited_lines_map() ->', ret] if $pd }
+    end
+
+    def inherited_lines_present?
+      @inherited_lines.present?.tap { |ret| pp ['LinkState.inherited_lines_present?() ->', ret] if $pd }
+    end
   end
 
   class LinkHistory

data/lib/markdown_exec/version.rb

@@ -7,5 +7,5 @@ module MarkdownExec
   BIN_NAME = 'mde'
   GEM_NAME = 'markdown_exec'
   TAP_DEBUG = 'MDE_DEBUG'
-  VERSION = '2.0.8.4'
+  VERSION = '2.2.0'
 end

data/lib/markdown_exec.rb

@@ -45,6 +45,8 @@ tap_config envvar: MarkdownExec::TAP_DEBUG
 $stderr.sync = true
 $stdout.sync = true
 
+$pd = false unless defined?($pd)
+
 ARGV_SEP = '--'
 
 # custom error: file specified is missing
@@ -86,20 +88,6 @@ def extract_named_captures_from_option(str, option)
   str.match(Regexp.new(option))&.named_captures&.sym_keys
 end
 
-# :reek:UtilityFunction
-def list_recent_output(saved_stdout_folder, saved_stdout_glob,
-                       list_count)
-  SavedFilesMatcher.most_recent_list(saved_stdout_folder,
-                                     saved_stdout_glob, list_count)
-end
-
-# :reek:UtilityFunction
-def list_recent_scripts(saved_script_folder, saved_script_glob,
-                        list_count)
-  SavedFilesMatcher.most_recent_list(saved_script_folder,
-                                     saved_script_glob, list_count)
-end
-
 # execute markdown documents
 #
 module MarkdownExec
@@ -167,12 +155,14 @@ module MarkdownExec
 
       # Conditionally add directory names if data is present
       unless directory_names[:data].count.zero?
-        choices << { disabled: '', name: "in #{directory_names[:section_title]}".send(@chrome_color) }
+        choices << { disabled: '',
+                     name: "in #{directory_names[:section_title]}".send(@chrome_color) }
         choices += files_in_directories
       end
 
       # Adding found in block names
-      choices << { disabled: '', name: "in #{found_in_block_names[:section_title]}".send(@chrome_color) }
+      choices << { disabled: '',
+                   name: "in #{found_in_block_names[:section_title]}".send(@chrome_color) }
 
       choices += vbn
 
@@ -186,16 +176,22 @@ module MarkdownExec
       {
         section_title: 'directory names',
         data: matched_directories,
-        formatted_text: [{ content: AnsiFormatter.new(search_options).format_and_highlight_array(matched_directories, highlight: [highlight_value]) }]
+        formatted_text: [{ content: AnsiFormatter.new(search_options).format_and_highlight_array(
+          matched_directories, highlight: [highlight_value]
+        ) }]
       }
     end
 
-    def found_in_block_names(search_options, highlight_value, formspec: '=%<index>4.d: %<line>s')
+    def found_in_block_names(search_options, highlight_value,
+                             formspec: '=%<index>4.d: %<line>s')
       matched_contents = (find_file_contents do |line|
-                            read_block_name(line, search_options[:fenced_start_and_end_regex], search_options[:block_name_match], search_options[:block_name_nick_match])
+                            read_block_name(line, search_options[:fenced_start_and_end_regex],
+                                            search_options[:block_name_match], search_options[:block_name_nick_match])
                           end).map.with_index do |(file, contents), index|
         # [file, contents.map { |detail| format(formspec, detail.index, detail.line) }, index]
-        [file, contents.map { |detail| format(formspec, { index: detail.index, line: detail.line }) }, index]
+        [file, contents.map do |detail|
+                 format(formspec, { index: detail.index, line: detail.line })
+               end, index]
       end
       {
         section_title: 'block names',
@@ -222,7 +218,8 @@ module MarkdownExec
       }
     end
 
-    def read_block_name(line, fenced_start_and_end_regex, block_name_match, block_name_nick_match)
+    def read_block_name(line, fenced_start_and_end_regex, block_name_match,
+                        block_name_nick_match)
       return unless line.match(fenced_start_and_end_regex)
 
       bm = extract_named_captures_from_option(line, block_name_match)
@@ -241,7 +238,6 @@ module MarkdownExec
   ##
   #
   # :reek:DuplicateMethodCall { allow_calls: ['block', 'item', 'lm', 'opts', 'option', '@options', 'required_blocks'] }
-  # rubocop:enable Layout/LineLength
   # :reek:MissingSafeMethod { exclude: [ read_configuration_file! ] }
   # :reek:TooManyInstanceVariables ### temp
   # :reek:TooManyMethods ### temp
@@ -267,6 +263,20 @@ module MarkdownExec
       )
     end
 
+    # :reek:UtilityFunction
+    def list_recent_output(saved_stdout_folder, saved_stdout_glob,
+                           list_count)
+      SavedFilesMatcher.most_recent_list(saved_stdout_folder,
+                                         saved_stdout_glob, list_count)
+    end
+
+    # :reek:UtilityFunction
+    def list_recent_scripts(saved_script_folder, saved_script_glob,
+                            list_count)
+      SavedFilesMatcher.most_recent_list(saved_script_folder,
+                                         saved_script_glob, list_count)
+    end
+
     def warn_format(name, message, opts = {})
       Exceptions.warn_format(
         "CachedNestedFileReader.#{name} -- #{message}",
@@ -390,8 +400,6 @@ module MarkdownExec
                              },
         pwd: -> { @fout.fout File.expand_path('..', __dir__) },
         run_last_script: -> { run_last_script },
-        select_recent_output: -> { select_recent_output },
-        select_recent_script: -> { select_recent_script },
         tab_completions: -> { @fout.fout tab_completions },
         menu_export: -> { @fout.fout menu_export }
       }
@@ -480,7 +488,9 @@ module MarkdownExec
         find_files('*', [dn], exclude_dirs: true)
       end.flatten(1).map { |str| FileInMenu.for_menu(str) }
 
-      return { exit: true } unless file_names[:data]&.count.positive? || files_in_directories&.count.positive? || found_in_block_names[:data]&.count.positive?
+      unless file_names[:data]&.count.positive? || files_in_directories&.count.positive? || found_in_block_names[:data]&.count.positive?
+        return { exit: true }
+      end
 
       vbn = found_in_block_names[:matched_contents].map do |matched_contents|
         filename, details, = matched_contents
@@ -488,10 +498,13 @@ module MarkdownExec
           details,
           highlight: [value]
         )
-        [FileInMenu.for_menu(filename)] + nexo.map { |str| { disabled: '', name: (' ' * 20) + str } }
+        [FileInMenu.for_menu(filename)] + nexo.map do |str|
+                                            { disabled: '', name: (' ' * 20) + str }
+                                          end
       end.flatten
 
-      choices = MenuBuilder.new.build_menu(file_names, directory_names, found_in_block_names, files_in_directories, vbn)
+      choices = MenuBuilder.new.build_menu(file_names, directory_names, found_in_block_names,
+                                           files_in_directories, vbn)
 
       @options[:filename] = FileInMenu.from_menu(
         select_document_if_multiple(
@@ -545,7 +558,8 @@ module MarkdownExec
         ->(_) { exit }
       when 'find', 'open'
         ->(value) {
-          exit if find_value(value, execute_chosen_found: procname == 'open').fetch(:exit, false)
+          exit if find_value(value, execute_chosen_found: procname == 'open').fetch(:exit,
+                                                                                    false)
         }
       when 'help'
         ->(_) {
@@ -571,9 +585,9 @@ module MarkdownExec
           value.instance_of?(::String) ? (value.chomp != '0') : value
         }
       when 'val_as_int'
-        ->(value) { value.to_i }
+        lambda(&:to_i)
       when 'val_as_str'
-        ->(value) { value.to_s }
+        lambda(&:to_s)
       when 'version'
         lambda { |_|
           @fout.fout MarkdownExec::VERSION
@@ -734,59 +748,26 @@ module MarkdownExec
                                            @options[:saved_filename_replacement])
     end
 
-    def select_document_if_multiple(files = list_markdown_files_in_path, prompt: options[:prompt_select_md].to_s)
+    def select_document_if_multiple(files = list_markdown_files_in_path,
+                                    prompt: options[:prompt_select_md].to_s)
       return files[0] if (count = files.count) == 1
 
       return unless count >= 2
 
       opts = options.dup
-      select_option_or_exit(HashDelegator.new(@options).string_send_color(prompt, :prompt_color_after_script_execution),
-                            files,
-                            opts.merge(per_page: opts[:select_page_height]))
-    end
-
-    # Presents a TTY prompt to select an option or exit, returns selected option or nil
-    def select_option_or_exit(prompt_text, strings, opts = {})
-      result = @options.select_option_with_metadata(prompt_text, strings,
-                                                    opts)
-      ### 2024-04-20 what for?
-      # return unless result.fetch(:option, nil)
-
-      result[:selected]
-    end
-
-    def select_recent_output
-      filename = select_option_or_exit(
-        HashDelegator.new(@options).string_send_color(@options[:prompt_select_output].to_s,
+      select_option_or_exit(
+        HashDelegator.new(@options).string_send_color(prompt,
                                                       :prompt_color_after_script_execution),
-        list_recent_output(
-          @options[:saved_stdout_folder],
-          @options[:saved_stdout_glob],
-          @options[:list_count]
-        ),
-        @options.merge({ per_page: @options[:select_page_height] })
+        files,
+        opts.merge(per_page: opts[:select_page_height])
       )
-      return unless filename.present?
-
-      `open #{filename} #{options[:output_viewer_options]}`
     end
 
-    def select_recent_script
-      filename = select_option_or_exit(
-        HashDelegator.new(@options).string_send_color(@options[:prompt_select_md].to_s,
-                                                      :prompt_color_after_script_execution),
-        list_recent_scripts(
-          @options[:saved_script_folder],
-          @options[:saved_script_glob],
-          @options[:list_count]
-        ),
-        @options.merge({ per_page: @options[:select_page_height] })
-      )
-      return if filename.nil?
-
-      saved_name_split(filename)
-
-      @options.document_inpseq ### ({ save_executed_script: false })
+    # Presents a TTY prompt to select an option or exit, returns selected option or nil
+    def select_option_or_exit(prompt_text, strings, opts = {})
+      @options.select_option_with_metadata(
+        prompt_text, strings, opts
+      )&.fetch(:selected)
     end
 
     public
@@ -827,4 +808,4 @@ if $PROGRAM_NAME == __FILE__
       assert_equal MenuState::CONTINUE, state
     end
   end # module MarkdownExec
-end  # if
+end # if

data/lib/mdoc.rb

@@ -6,6 +6,8 @@
 require_relative 'block_types'
 require_relative 'filter'
 
+$pd = false unless defined?($pd)
+
 module MarkdownExec
   ##
   # MDoc represents an imported markdown document.
@@ -23,11 +25,11 @@ module MarkdownExec
     #
     def initialize(table = [])
       @table = table
-      # &bc '@table.count:',@table.count
+      # &bt @table.count
     end
 
     def collect_block_code_cann(fcb)
-      body = fcb[:body].join("\n")
+      body = fcb.body.join("\n")
       xcall = fcb[:cann][1..-2]
       mstdin = xcall.match(/<(?<type>\$)?(?<name>[A-Za-z_\-.\w]+)/)
       mstdout = xcall.match(/>(?<type>\$)?(?<name>[A-Za-z_\-.\w]+)/)
@@ -44,15 +46,6 @@ module MarkdownExec
       end
     end
 
-    def collect_block_code_shell(fcb)
-      # write named variables to block at top of script
-      #
-      fcb[:body].join(' ').split.compact.map do |key|
-        ### format(opts[:block_type_port_set_format], { key: key, value: ENV.fetch(key, nil) })
-        "key: #{key}, value: #{ENV.fetch(key, nil)}"
-      end
-    end
-
     # Collects and formats the shell command output to redirect script block code to a file or a variable.
     #
     # @param [Hash] fcb A hash containing information about the script block's stdout and body.
@@ -66,7 +59,7 @@ module MarkdownExec
     #   If stdout[:type] is false, the command will write the body to a file.
     def collect_block_code_stdout(fcb)
       stdout = fcb[:stdout]
-      body = fcb[:body].join("\n")
+      body = fcb.body.join("\n")
       if stdout[:type]
         %(export #{stdout[:name]}=$(cat <<"EOF"\n#{body}\nEOF\n))
       else
@@ -83,35 +76,38 @@ module MarkdownExec
     #
     def collect_block_dependencies(anyname:)
       name_block = get_block_by_anyname(anyname)
-      raise "Named code block `#{anyname}` not found. (@#{__LINE__})" if name_block.nil? || name_block.keys.empty?
+      if name_block.nil? || name_block.keys.empty?
+        raise "Named code block `#{anyname}` not found. (@#{__LINE__})"
+      end
 
       nickname = name_block.pub_name
 
       dependencies = collect_dependencies(nickname)
-      # &bc 'dependencies.count:',dependencies.count
+      # &bt dependencies.count
       all_dependency_names = collect_unique_names(dependencies).push(nickname).uniq
-      # &bc 'all_dependency_names.count:',all_dependency_names.count
+      # &bt all_dependency_names.count
 
       # select non-chrome blocks in order of appearance in source documents
       #
       blocks = @table.select do |fcb|
-        !fcb.fetch(:chrome, false) && all_dependency_names.include?(fcb.pub_name)
+        # !fcb.fetch(:chrome, false) && all_dependency_names.include?(fcb.pub_name)
+        all_dependency_names.include?(fcb.pub_name)
       end
-      # &bc 'blocks.count:',blocks.count
+      # &bt blocks.count
 
       ## add cann key to blocks, calc unmet_dependencies
       #
       unmet_dependencies = all_dependency_names.dup
       blocks = blocks.map do |fcb|
         unmet_dependencies.delete(fcb.pub_name) # may not exist if block name is duplicated
-        if (call = fcb[:call])
+        if (call = fcb.call)
           [get_block_by_anyname("[#{call.match(/^%\((\S+) |\)/)[1]}]")
             .merge({ cann: call })]
         else
           []
         end + [fcb]
       end.flatten(1)
-      # &bc 'unmet_dependencies.count:',unmet_dependencies.count
+      # &bt unmet_dependencies.count
 
       { all_dependency_names: all_dependency_names,
         blocks: blocks,
@@ -129,7 +125,7 @@ module MarkdownExec
       block_search = collect_block_dependencies(anyname: anyname)
       if block_search[:blocks]
         blocks = collect_wrapped_blocks(block_search[:blocks])
-        # &bc 'blocks.count:',blocks.count
+        # &bt blocks.count
 
         block_search.merge(
           { block_names: blocks.map(&:pub_name),
@@ -138,20 +134,20 @@ module MarkdownExec
                 collect_block_code_cann(fcb)
               elsif fcb[:stdout]
                 collect_block_code_stdout(fcb)
-              elsif [BlockType::LINK, BlockType::OPTS,
-                     BlockType::VARS].include? fcb[:shell]
+              elsif [BlockType::OPTS].include? fcb.shell
+                fcb.body # entire body is returned to requesing block
+              elsif [BlockType::LINK,
+                     BlockType::VARS].include? fcb.shell
+                nil
+              elsif fcb[:chrome] # for Link blocks like History
                 nil
-              elsif fcb[:shell] == BlockType::PORT
-                collect_block_code_shell(fcb)
+              elsif fcb.shell == BlockType::PORT
+                generate_env_variable_shell_commands(fcb)
               elsif label_body
-                block_name_for_bash_comment = fcb.pub_name.gsub(/\s+/, '_')
-                [label_format_above && format(label_format_above,
-                                              block_source.merge({ block_name: block_name_for_bash_comment }))] +
-                 fcb[:body] +
-                 [label_format_below && format(label_format_below,
-                                               block_source.merge({ block_name: block_name_for_bash_comment }))]
+                generate_label_body_code(fcb, block_source, label_format_above,
+                                         label_format_below)
               else # raw body
-                fcb[:body]
+                fcb.body
               end
             end.compact.flatten(1).compact }
         )
@@ -222,10 +218,69 @@ module MarkdownExec
       # . empty chrome between code; edges are same as blanks
       #
       select_elements_with_neighbor_conditions(selrows) do |prev_element, current, next_element|
-        !(current[:chrome] && !current[:oname].present?) || !(!prev_element.nil? && prev_element[:shell].present? && !next_element.nil? && next_element[:shell].present?)
+        !(current[:chrome] && !current.oname.present?) ||
+          !(!prev_element.nil? &&
+            prev_element.shell.present? &&
+            !next_element.nil? &&
+            next_element.shell.present?)
+      end
+    end
+
+    # Generates shell code lines to set environment variables named in the body of the given object.
+    # Reads a whitespace-separated list of environment variable names from `fcb.body`,
+    # retrieves their values from the current environment, and constructs shell commands
+    # to set these environment variables.
+    #
+    # @param fcb [Object] An object with a `body` method that returns an array of strings,
+    #   where each string is a name of an environment variable.
+    # @return [Array<String>] An array of strings, each representing a shell command to
+    #   set an environment variable in the format `KEY=value`.
+    #
+    # Example:
+    #   If `fcb.body` returns ["PATH", "HOME"], and the current environment has PATH=/usr/bin
+    #   and HOME=/home/user, this method will return:
+    #     ["PATH=/usr/bin", "HOME=/home/user"]
+    #
+    def generate_env_variable_shell_commands(fcb)
+      fcb.body.join(' ').split.compact.map do |key|
+        "#{key}=#{Shellwords.escape ENV.fetch(key, '')}"
       end
     end
 
+    # Generates a formatted code block with labels above and below the main content.
+    # The labels and content are based on the provided format strings and the body of the given object.
+    #
+    # @param fcb [Object] An object with a `pub_name` method that returns a string, and a `body` method that returns an array of strings.
+    # @param block_source [Hash] A hash containing additional information to be merged into the format strings.
+    # @param label_format_above [String, nil] A format string for the label above the content, or nil if no label is needed.
+    # @param label_format_below [String, nil] A format string for the label below the content, or nil if no label is needed.
+    # @return [Array<String>] An array of strings representing the formatted code block, with optional labels above and below the main content.
+    #
+    # Example:
+    #   If `fcb.pub_name` returns "Example Block", `fcb.body` returns ["line1", "line2"],
+    #   `block_source` is { source: "source_info" }, `label_format_above` is "Start of %{block_name}",
+    #   and `label_format_below` is "End of %{block_name}", the method will return:
+    #     ["Start of Example_Block", "line1", "line2", "End of Example_Block"]
+    #
+    def generate_label_body_code(fcb, block_source, label_format_above, label_format_below)
+      block_name_for_bash_comment = fcb.pub_name.gsub(/\s+/, '_')
+
+      label_above = if label_format_above
+                      format(label_format_above,
+                             block_source.merge({ block_name: block_name_for_bash_comment }))
+                    else
+                      nil
+                    end
+      label_below = if label_format_below
+                      format(label_format_below,
+                             block_source.merge({ block_name: block_name_for_bash_comment }))
+                    else
+                      nil
+                    end
+
+      [label_above, *fcb.body, label_below].compact
+    end
+
     # Retrieves a code block by its name.
     #
     # @param name [String] The name of the code block to retrieve.
@@ -233,10 +288,14 @@ module MarkdownExec
     # @return [Hash] The code block as a hash or the default value if not found.
     #
     def get_block_by_anyname(name, default = {})
+      # &bt name
       @table.select do |fcb|
-        fcb.fetch(:nickname,
-                  '') == name || fcb.fetch(:dname, '') == name || fcb.fetch(:oname, '') == name
-      end.fetch(0, default)
+        fcb.tap { |_ret| pp [__LINE__, 'get_block_by_anyname()', 'fcb', fcb] if $pd }
+        fcb.nickname == name ||
+          fcb.dname == name ||
+          fcb.oname == name ||
+          fcb.pub_name == name
+      end.fetch(0, default).tap { |ret| pp [__LINE__, 'get_block_by_anyname() ->', ret] if $pd }
     end
 
     # Checks if a code block should be hidden based on the given options.
@@ -250,15 +309,15 @@ module MarkdownExec
       if block.fetch(:chrome, false)
         false
       else
-        (opts[:hide_blocks_by_name] &&
-                ((opts[:block_name_hidden_match]&.present? &&
-                  block.oname&.match(Regexp.new(opts[:block_name_hidden_match]))) ||
-                 (opts[:block_name_include_match]&.present? &&
-                  block.oname&.match(Regexp.new(opts[:block_name_include_match]))) ||
-                 (opts[:block_name_wrapper_match]&.present? &&
-                  block.oname&.match(Regexp.new(opts[:block_name_wrapper_match])))) &&
-                (block.oname&.present? || block[:label]&.present?)
-        )
+        opts[:hide_blocks_by_name] &&
+          ((opts[:block_name_hidden_match]&.present? &&
+            block.oname&.match(Regexp.new(opts[:block_name_hidden_match]))) ||
+           (opts[:block_name_include_match]&.present? &&
+            block.oname&.match(Regexp.new(opts[:block_name_include_match]))) ||
+           (opts[:block_name_wrapper_match]&.present? &&
+            block.oname&.match(Regexp.new(opts[:block_name_wrapper_match])))) &&
+          (block.oname&.present? || block[:label]&.present?)
+
       end
     end
 
@@ -277,7 +336,7 @@ module MarkdownExec
           next if memo.include? req
 
           memo += [req]
-          get_block_by_anyname(req).fetch(:reqs, [])
+          get_block_by_anyname(req).reqs
         end
                  .compact
                  .flatten(1)
@@ -295,9 +354,11 @@ module MarkdownExec
       return memo if memo.keys.include? source
 
       block = get_block_by_anyname(source)
-      raise "Named code block `#{source}` not found. (@#{__LINE__})" if block.nil? || block.keys.empty?
+      if block.nil? || block.keys.empty?
+        raise "Named code block `#{source}` not found. (@#{__LINE__})"
+      end
 
-      memo[source] = block[:reqs]
+      memo[source] = block.reqs
       return memo unless memo[source]&.count&.positive?
 
       memo[source].each do |req|
@@ -322,11 +383,11 @@ module MarkdownExec
 
       end
 
-      return memo unless block[:reqs]
+      return memo unless block.reqs
 
-      memo[source] = block[:reqs]
+      memo[source] = block.reqs
 
-      block[:reqs].each { |req| collect_dependencies(req, memo) unless memo.key?(req) }
+      block.reqs.each { |req| collect_dependencies(req, memo) unless memo.key?(req) }
       memo
     end
 
@@ -364,7 +425,7 @@ module MarkdownExec
     #     next_element = array[index + 1]
 
     #     # Check the conditions for property A on the current element and property B on adjacent elements
-    #     unless element[:chrome] && !element[:oname].present? && prev_element[:shell].present? && next_element[:shell].present?
+    #     unless element[:chrome] && !element[:oname].present? && prev_element.shell.present? && next_element.shell.present?
     #       selected_elements << element
     #     # else
     # # pp 'SKIPPING', element
@@ -512,12 +573,6 @@ if $PROGRAM_NAME == __FILE__
         # Test case 1: blocks with wraps
         OpenStruct.new(oname: 'block1')
 
-        assert_equal(%w[{wrap1} a],
-                     @mdoc.collect_wrapped_blocks(
-                       [OpenStruct.new(oname: 'a',
-                                       wraps: ['{wrap1}'])]
-                     ).map(&:oname))
-
         assert_equal(%w[{wrap2-before} {wrap2} b {wrap2-after}],
                      @mdoc.collect_wrapped_blocks(
                        [OpenStruct.new(oname: 'b',