markdown_exec 1.2.0 → 1.3.1

data/lib/markdown_exec.rb

@@ -6,23 +6,32 @@
 require 'English'
 require 'clipboard'
 require 'open3'
-require 'optparse'
+# require 'optparse'
+require 'shellwords'
 require 'tty-prompt'
 require 'yaml'
 
+require_relative 'cli'
 require_relative 'colorize'
 require_relative 'env'
+require_relative 'environment_opt_parse'
+require_relative 'object_present'
 require_relative 'shared'
 require_relative 'tap'
 require_relative 'markdown_exec/version'
 
-include Tap # rubocop:disable Style/MixinUsage
+include CLI
+include Tap
+
+tap_config envvar: MarkdownExec::TAP_DEBUG
 
 $stderr.sync = true
 $stdout.sync = true
 
 BLOCK_SIZE = 1024
 
+class FileMissingError < StandardError; end
+
 # hash with keys sorted by name
 #
 class Hash
@@ -31,42 +40,38 @@ class Hash
   end
 end
 
-# is the value a non-empty string or a binary?
+# stdout manager
 #
-# :reek:ManualDispatch ### temp
-class Object
-  def present?
-    case self.class.to_s
-    when 'FalseClass', 'TrueClass'
-      true
-    else
-      self && (!respond_to?(:blank?) || !blank?)
-    end
+module FOUT
+  # standard output; not for debug
+  #
+  def fout(str)
+    puts str
   end
-end
 
-# is value empty?
-#
-class String
-  BLANK_RE = /\A[[:space:]]*\z/.freeze
-  def blank?
-    empty? || BLANK_RE.match?(self)
+  def fout_list(str)
+    puts str
   end
-end
 
-public
+  def fout_section(name, data)
+    puts "# #{name}"
+    puts data.to_yaml
+  end
 
-# display_level values
-DISPLAY_LEVEL_BASE = 0 # required output
-DISPLAY_LEVEL_ADMIN = 1
-DISPLAY_LEVEL_DEBUG = 2
-DISPLAY_LEVEL_DEFAULT = DISPLAY_LEVEL_ADMIN
-DISPLAY_LEVEL_MAX = DISPLAY_LEVEL_DEBUG
+  def approved_fout?(level)
+    level <= @options[:display_level]
+  end
 
-# @execute_files[ind] = @execute_files[ind] + [block]
-EF_STDOUT = 0
-EF_STDERR = 1
-EF_STDIN = 2
+  # display output at level or lower than filter (DISPLAY_LEVEL_DEFAULT)
+  #
+  def lout(str, level: DISPLAY_LEVEL_BASE)
+    return unless approved_fout? level
+
+    fout level == DISPLAY_LEVEL_BASE ? str : @options[:display_level_xbase_prefix] + str
+  end
+end
+
+public
 
 # execute markdown documents
 #
@@ -74,6 +79,29 @@ module MarkdownExec
   # :reek:IrresponsibleModule
   class Error < StandardError; end
 
+  # cache lines in text file
+  #
+  class CFile
+    def initialize
+      @cache = {}
+    end
+
+    def readlines(filename)
+      if @cache[filename]
+        @cache[filename].each do |line|
+          yield line if block_given?
+        end
+      else
+        lines = []
+        File.readlines(filename).each do |line|
+          lines.push line
+          yield line if block_given?
+        end
+        @cache[filename] = lines
+      end
+    end
+  end # class CFile
+
   ## an imported markdown document
   #
   class MDoc
@@ -81,36 +109,78 @@ module MarkdownExec
       @table = table
     end
 
-    def code(block)
-      all = [block[:name]] + recursively_required(block[:reqs])
-      all.reverse.map do |req|
-        get_block_by_name(req).fetch(:body, '')
-      end
-         .flatten(1)
-         .tap_inspect
+    def collect_recursively_required_code(name)
+      get_required_blocks(name)
+        .map do |block|
+        block.tap_yaml name: :block
+        body = block[:body].join("\n")
+
+        if block[:cann]
+          xcall = block[:cann][1..-2].tap_inspect name: :xcall
+          mstdin = xcall.match(/<(?<type>\$)?(?<name>[A-Za-z_-]\S+)/).tap_inspect name: :mstdin
+          mstdout = xcall.match(/>(?<type>\$)?(?<name>[A-Za-z_-]\S+)/).tap_inspect name: :mstdout
+          yqcmd = if mstdin[:type]
+                    "echo \"$#{mstdin[:name]}\" | yq '#{body}'"
+                  else
+                    "yq e '#{body}' '#{mstdin[:name]}'"
+                  end.tap_inspect name: :yqcmd
+          if mstdout[:type]
+            "export #{mstdout[:name]}=$(#{yqcmd})"
+          else
+            "#{yqcmd} > '#{mstdout[:name]}'"
+          end
+        elsif block[:stdout]
+          stdout = block[:stdout].tap_inspect name: :stdout
+          body = block[:body].join("\n").tap_inspect name: :body
+          if stdout[:type]
+            # "export #{stdout[:name]}=#{Shellwords.escape body}"
+            %(export #{stdout[:name]}=$(cat <<"EOF"\n#{body}\nEOF\n))
+          else
+            "cat > '#{stdout[:name]}' <<\"EOF\"\n" \
+              "#{body}\n" \
+              "EOF\n"
+          end
+        else
+          block[:body]
+        end
+      end.flatten(1)
+        .tap_yaml
     end
 
     def get_block_by_name(name, default = {})
-      @table.select { |block| block[:name] == name }.fetch(0, default)
+      name.tap_inspect name: :name
+      @table.select { |block| block[:name] == name }.fetch(0, default).tap_yaml
     end
 
-    def list_recursively_required_blocks(name)
+    def get_required_blocks(name)
       name_block = get_block_by_name(name)
       raise "Named code block `#{name}` not found." if name_block.nil? || name_block.keys.empty?
 
       all = [name_block[:name]] + recursively_required(name_block[:reqs])
 
       # in order of appearance in document
-      @table.select { |block| all.include? block[:name] }
-            .map { |block| block.fetch(:body, '') }
-            .flatten(1)
-            .tap_inspect
+      sel = @table.select { |block| all.include? block[:name] }
+
+      # insert function blocks
+      sel.map do |block|
+        block.tap_yaml name: :block
+        if (call = block[:call])
+          [get_block_by_name("[#{call.match(/^\((\S+) |\)/)[1]}]").merge({ cann: call })]
+        else
+          []
+        end + [block]
+      end.flatten(1) # .tap_yaml
+    end
+
+    # :reek:UtilityFunction
+    def hide_menu_block_per_options(opts, block)
+      (opts[:hide_blocks_by_name] &&
+              block[:name].match(Regexp.new(opts[:block_name_hidden_match]))).tap_inspect
     end
 
-    def option_exclude_blocks(opts)
-      block_name_excluded_match = Regexp.new opts[:block_name_excluded_match]
+    def blocks_for_menu(opts)
       if opts[:hide_blocks_by_name]
-        @table.reject { |block| block[:name].match(block_name_excluded_match) }
+        @table.reject { |block| hide_menu_block_per_options opts, block }
       else
         @table
       end
@@ -128,11 +198,10 @@ module MarkdownExec
         end
                  .compact
                  .flatten(1)
-                 .tap_inspect(name: 'rem')
       end
-      all.tap_inspect
+      all.tap_yaml
     end
-  end
+  end # class MDoc
 
   # format option defaults and values
   #
@@ -161,7 +230,7 @@ module MarkdownExec
           end
         )).join('  ')
     end
-  end
+  end # class BlockLabel
 
   FNR11 = '/'
   FNR12 = ',~'
@@ -184,7 +253,7 @@ module MarkdownExec
     def stdout_name
       "#{[@prefix, @time.strftime('%F-%H-%M-%S'), @filename, @blockname].join('_')}.out.txt".tap_inspect
     end
-  end
+  end # class SavedAsset
 
   # format option defaults and values
   #
@@ -228,7 +297,7 @@ module MarkdownExec
         @value.to_s
       end
     end
-  end
+  end # class OptionValue
 
   # a generated list of saved files
   #
@@ -242,20 +311,20 @@ module MarkdownExec
       Dir.glob(File.join(@folder, @glob)).tap_inspect
     end
 
-    def most_recent(arr = list_all)
-      return unless arr
+    def most_recent(arr = nil)
+      arr = list_all if arr.nil?
       return if arr.count < 1
 
       arr.max.tap_inspect
     end
 
-    def most_recent_list(arr = list_all)
-      return unless arr
+    def most_recent_list(list_count, arr = nil)
+      arr = list_all if arr.nil?
       return if (ac = arr.count) < 1
 
-      arr.sort[-[ac, options[:list_count]].min..].reverse.tap_inspect
+      arr.sort[-[ac, list_count].min..].reverse.tap_inspect
     end
-  end
+  end # class Sfiles
 
   ##
   #
@@ -266,9 +335,12 @@ module MarkdownExec
   class MarkParse
     attr_reader :options
 
+    include FOUT
+
     def initialize(options = {})
       @options = options
-      @prompt = TTY::Prompt.new(interrupt: :exit)
+      @prompt = TTY::Prompt.new(interrupt: :exit, symbols: { cross: ' ' })
+      # @prompt = TTY::Prompt.new(interrupt: :exit, symbols: { cross: options[:menu_divider_symbol] })
       @execute_aborted_at = nil
       @execute_completed_at = nil
       @execute_error = nil
@@ -278,6 +350,7 @@ module MarkdownExec
       @execute_script_filespec = nil
       @execute_started_at = nil
       @option_parser = nil
+      @cfile = CFile.new
     end
 
     ##
@@ -285,7 +358,7 @@ module MarkdownExec
 
     def base_options
       menu_iter do |item|
-        # noisy item.tap_inspect name: :item, format: :yaml
+        # noisy item.tap_yaml name: :item
         next unless item[:opt_name].present?
 
         item_default = item[:default]
@@ -295,13 +368,13 @@ module MarkdownExec
                 else
                   env_str(item[:env_var], default: OptionValue.new(item_default).for_hash)
                 end
-        [item[:opt_name], item[:proc1] ? item[:proc1].call(value) : value]
+        [item[:opt_name], item[:proccode] ? item[:proccode].call(value) : value]
       end.compact.to_h.merge(
         {
           menu_exit_at_top: true,
           menu_with_exit: true
         }
-      ).tap_inspect format: :yaml
+      ).tap_yaml
     end
 
     def default_options
@@ -310,18 +383,14 @@ module MarkdownExec
         exclude_expect_blocks: true,
         hide_blocks_by_name: true,
         output_saved_script_filename: false,
-        prompt_approve_block: 'Process?',
-        prompt_select_block: 'Choose a block:',
-        prompt_select_md: 'Choose a file:',
-        prompt_select_output: 'Choose a file:',
         saved_script_filename: nil, # calculated
         struct: true # allow get_block_summary()
       }
     end
 
     def approve_block(opts, mdoc)
-      required_blocks = mdoc.list_recursively_required_blocks(opts[:block_name])
-      display_command(opts, required_blocks) if opts[:output_script] || opts[:user_must_approve]
+      required_blocks = mdoc.collect_recursively_required_code(opts[:block_name])
+      display_required_code(opts, required_blocks) if opts[:output_script] || opts[:user_must_approve]
 
       allow = true
       if opts[:user_must_approve]
@@ -331,10 +400,10 @@ module MarkdownExec
              # menu.enum '.'
              # menu.filter true
 
-             menu.choice 'Yes', 1
-             menu.choice 'No', 2
-             menu.choice 'Copy script to clipboard', 3
-             menu.choice 'Save script', 4
+             menu.choice opts[:prompt_yes], 1
+             menu.choice opts[:prompt_no], 2
+             menu.choice opts[:prompt_script_to_clipboard], 3
+             menu.choice opts[:prompt_save_script], 4
            end).tap_inspect name: :sel
           allow = (sel == 1)
           if sel == 3
@@ -366,17 +435,22 @@ module MarkdownExec
       selected[:name]
     end
 
+    # def cc(str)
+    #   puts " - - - #{Process.clock_gettime(Process::CLOCK_MONOTONIC)} - #{str}"
+    # end
+
     # :reek:DuplicateMethodCall
     # :reek:UncommunicativeVariableName { exclude: [ e ] }
     # :reek:LongYieldList
     def command_execute(opts, command)
+      # dd = lambda { |s| puts 'command_execute() ' + s }
+      #d 'execute command and yield outputs'
       @execute_files = Hash.new([])
       @execute_options = opts
       @execute_started_at = Time.now.utc
 
       Open3.popen3(@options[:shell], '-c', command) do |stdin, stdout, stderr, exec_thr|
-        # pid = exec_thr.pid # pid of the started process
-
+        #d 'command started'
         Thread.new do
           until (line = stdout.gets).nil?
             @execute_files[EF_STDOUT] = @execute_files[EF_STDOUT] + [line]
@@ -384,7 +458,7 @@ module MarkdownExec
             yield nil, line, nil, exec_thr if block_given?
           end
         rescue IOError
-          # thread killed, do nothing
+          #d 'stdout IOError, thread killed, do nothing'
         end
 
         Thread.new do
@@ -394,7 +468,7 @@ module MarkdownExec
             yield nil, nil, line, exec_thr if block_given?
           end
         rescue IOError
-          # thread killed, do nothing
+          #d 'stderr IOError, thread killed, do nothing'
         end
 
         in_thr = Thread.new do
@@ -403,22 +477,33 @@ module MarkdownExec
             @execute_files[EF_STDIN] = @execute_files[EF_STDIN] + [line]
             yield line, nil, nil, exec_thr if block_given?
           end
+          #d 'exec_thr now dead'
+        rescue
+          #d 'stdin error, thread killed, do nothing'
         end
 
+        #d 'join exec_thr'
         exec_thr.join
+
+        #d 'wait before closing stdin'
+        sleep 0.1
+
+        #d 'kill stdin thread'
         in_thr.kill
         # @return_code = exec_thr.value
+        #d 'command end'
       end
+      #d 'command completed'
       @execute_completed_at = Time.now.utc
     rescue Errno::ENOENT => e
-      # error triggered by missing command in script
+      #d 'command error ENOENT triggered by missing command in script'
       @execute_aborted_at = Time.now.utc
       @execute_error_message = e.message
       @execute_error = e
       @execute_files[EF_STDERR] += [@execute_error_message]
       fout "Error ENOENT: #{e.inspect}"
     rescue SignalException => e
-      # SIGTERM triggered by user or system
+      #d 'command SIGTERM triggered by user or system'
       @execute_aborted_at = Time.now.utc
       @execute_error_message = 'SIGTERM'
       @execute_error = e
@@ -429,15 +514,15 @@ module MarkdownExec
     def count_blocks_in_filename
       fenced_start_and_end_match = Regexp.new @options[:fenced_start_and_end_match]
       cnt = 0
-      File.readlines(@options[:filename]).each do |line|
+      @cfile.readlines(@options[:filename]).each do |line|
         cnt += 1 if line.match(fenced_start_and_end_match)
       end
       cnt / 2
     end
 
     # :reek:DuplicateMethodCall
-    def display_command(_opts, required_blocks)
-      frame = ' #=#=#'.yellow
+    def display_required_code(opts, required_blocks)
+      frame = opts[:output_divider].send(opts[:output_divider_color].to_sym)
       fout frame
       required_blocks.each { |cb| fout cb }
       fout frame
@@ -462,8 +547,14 @@ module MarkdownExec
         list_default_yaml: -> { fout_list list_default_yaml },
         list_docs: -> { fout_list files },
         list_default_env: -> { fout_list list_default_env },
-        list_recent_output: -> { fout_list list_recent_output },
-        list_recent_scripts: -> { fout_list list_recent_scripts },
+        list_recent_output: lambda {
+                              fout_list list_recent_output(@options[:saved_stdout_folder],
+                                                           @options[:saved_stdout_glob], @options[:list_count])
+                            },
+        list_recent_scripts: lambda {
+                               fout_list list_recent_scripts(options[:saved_script_folder],
+                                                             options[:saved_script_glob], options[:list_count])
+                             },
         pwd: -> { fout File.expand_path('..', __dir__) },
         run_last_script: -> { run_last_script },
         select_recent_output: -> { select_recent_output },
@@ -488,73 +579,57 @@ module MarkdownExec
       fout "saved_filespec: #{@execute_script_filespec}" if @options[:output_saved_script_filename]
     end
 
-    # standard output; not for debug
-    #
-    def fout(str)
-      puts str
-    end
-
-    def fout_list(str)
-      puts str
-    end
-
-    def fout_section(name, data)
-      puts "# #{name}"
-      puts data.to_yaml
-    end
-
     # :reek:LongParameterList
-    def get_block_summary(opts, headings:, block_title:, current:)
-      return [current] unless opts[:struct]
-
-      return [summarize_block(headings, block_title).merge({ body: current })] unless opts[:bash]
+    def get_block_summary(call_options = {}, headings:, block_title:, block_body:)
+      opts = optsmerge call_options
+      return [block_body] unless opts[:struct]
+      return [summarize_block(headings, block_title).merge({ body: block_body })] unless opts[:bash]
 
-      bm = block_title.match(Regexp.new(opts[:block_name_match]))
-      reqs = block_title.scan(Regexp.new(opts[:block_required_scan]))
+      block_title.tap_inspect name: :block_title
+      call = block_title.scan(Regexp.new(opts[:block_calls_scan]))
                         .map { |scanned| scanned[1..] }
+                          &.first.tap_inspect name: :call
+      (titlexcall = call ? block_title.sub("%#{call}", '') : block_title).tap_inspect name: :titlexcall
 
-      if bm && bm[1]
-        [summarize_block(headings, bm[:title]).merge({ body: current, reqs: reqs })]
-      else
-        [summarize_block(headings, block_title).merge({ body: current, reqs: reqs })]
-      end
-    end
-
-    def approved_fout?(level)
-      level <= @options[:display_level]
-    end
-
-    # display output at level or lower than filter (DISPLAY_LEVEL_DEFAULT)
-    #
-    def lout(str, level: DISPLAY_LEVEL_BASE)
-      return unless approved_fout? level
+      bm = titlexcall.match(Regexp.new(opts[:block_name_match]))
+      reqs = titlexcall.scan(Regexp.new(opts[:block_required_scan]))
+                       .map { |scanned| scanned[1..] }
+      stdin = titlexcall.match(Regexp.new(opts[:block_stdin_scan])).tap_inspect name: :stdin
+      stdout = titlexcall.match(Regexp.new(opts[:block_stdout_scan])).tap_inspect name: :stdout
 
-      # fout level == DISPLAY_LEVEL_BASE ? str : DISPLAY_LEVEL_XBASE_PREFIX + str
-      fout level == DISPLAY_LEVEL_BASE ? str : @options[:display_level_xbase_prefix] + str
+      title = bm && bm[1] ? bm[:title] : titlexcall
+      [summarize_block(headings, title).merge({ body: block_body,
+                                                call: call,
+                                                reqs: reqs,
+                                                stdin: stdin,
+                                                stdout: stdout })].tap_yaml
     end
 
     # :reek:DuplicateMethodCall
-    def list_blocks_in_file(call_options = {}, &options_block)
-      opts = optsmerge call_options, options_block
+    # :reek:LongYieldList
+    def iter_blocks_in_file(opts = {})
+      # opts = optsmerge call_options, options_block
 
       unless opts[:filename]&.present?
         fout 'No blocks found.'
-        exit 1
+        return
       end
 
       unless File.exist? opts[:filename]
         fout 'Document is missing.'
-        exit 1
+        return
       end
 
       fenced_start_and_end_match = Regexp.new opts[:fenced_start_and_end_match]
       fenced_start_ex = Regexp.new opts[:fenced_start_ex_match]
       block_title = ''
-      blocks = []
-      current = nil
+      block_body = nil
       headings = []
       in_block = false
-      File.readlines(opts[:filename]).each do |line|
+
+      selected_messages = yield :filter
+
+      @cfile.readlines(opts[:filename]).each do |line|
         continue unless line
 
         if opts[:menu_blocks_with_headings]
@@ -569,15 +644,17 @@ module MarkdownExec
 
         if line.match(fenced_start_and_end_match)
           if in_block
-            if current
-              block_title = current.join(' ').gsub(/  +/, ' ')[0..64] if block_title.nil? || block_title.empty?
-              blocks += get_block_summary opts, headings: headings, block_title: block_title, current: current
-              current = nil
+            if block_body
+              # end block
+              #
+              block_title = block_body.join(' ').gsub(/  +/, ' ')[0..64] if block_title.nil? || block_title.empty?
+              yield :blocks, headings, block_title, block_body if block_given? && selected_messages.include?(:blocks)
+              block_body = nil
             end
             in_block = false
             block_title = ''
           else
-            # new block
+            # start block
             #
             lm = line.match(fenced_start_ex)
             block_allow = false
@@ -590,15 +667,50 @@ module MarkdownExec
 
             in_block = true
             if block_allow && (!opts[:title_match] || (lm && lm[:name] && lm[:name].match(opts[:title_match])))
-              current = []
+              block_body = []
               block_title = (lm && lm[:name])
             end
           end
-        elsif current
-          current += [line.chomp]
+        elsif block_body
+          block_body += [line.chomp]
+        elsif block_given? && selected_messages.include?(:line)
+          # text outside of block
+          #
+          yield :line, nil, nil, line
+        end
+      end
+    end
+
+    def list_blocks_in_file(call_options = {}, &options_block)
+      opts = optsmerge call_options, options_block
+
+      blocks = []
+      if opts[:menu_initial_divider].present?
+        blocks += [{
+          name: format(opts[:menu_divider_format],
+                       opts[:menu_initial_divider]).send(opts[:menu_divider_color].to_sym), disabled: ''
+        }]
+      end
+      iter_blocks_in_file(opts) do |btype, headings, block_title, body|
+        case btype
+        when :filter
+          %i[blocks line]
+        when :line
+          if opts[:menu_divider_match] && (mbody = body.match opts[:menu_divider_match])
+            blocks += [{ name: format(opts[:menu_divider_format], mbody[:name]).send(opts[:menu_divider_color].to_sym),
+                         disabled: '' }]
+          end
+        when :blocks
+          blocks += get_block_summary opts, headings: headings, block_title: block_title, block_body: body
         end
       end
-      blocks.tap_inspect
+      if opts[:menu_divider_format].present? && opts[:menu_final_divider].present?
+        blocks += [{
+          name: format(opts[:menu_divider_format],
+                       opts[:menu_final_divider]).send(opts[:menu_divider_color].to_sym), disabled: ''
+        }]
+      end
+      blocks.tap_yaml
     end
 
     def list_default_env
@@ -636,22 +748,30 @@ module MarkdownExec
     def list_files_specified(specified_filename: nil, specified_folder: nil,
                              default_filename: nil, default_folder: nil, filetree: nil)
       fn = File.join(if specified_filename&.present?
-                       if specified_folder&.present?
-                         [specified_folder, specified_filename]
-                       elsif specified_filename.start_with? '/'
+                       # puts ' LFS 01'
+                       if specified_filename.start_with? '/'
+                         # puts ' LFS 02'
                          [specified_filename]
+                       elsif specified_folder&.present?
+                         # puts ' LFS 03'
+                         [specified_folder, specified_filename]
                        else
+                         # puts ' LFS 04'
                          [default_folder, specified_filename]
                        end
                      elsif specified_folder&.present?
+                       # puts ' LFS 05'
                        if filetree
+                         # puts ' LFS 06'
                          [specified_folder, @options[:md_filename_match]]
                        else
+                         # puts ' LFS 07'
                          [specified_folder, @options[:md_filename_glob]]
                        end
                      else
+                       # puts ' LFS 08'
                        [default_folder, default_filename]
-                     end)
+                     end).tap_inspect name: :fn
       if filetree
         filetree.select { |filename| filename == fn || filename.match(/^#{fn}$/) || filename.match(%r{^#{fn}/.+$}) }
       else
@@ -665,29 +785,27 @@ module MarkdownExec
 
     def list_named_blocks_in_file(call_options = {}, &options_block)
       opts = optsmerge call_options, options_block
-      block_name_excluded_match = Regexp.new opts[:block_name_excluded_match]
+      blocks_in_file = list_blocks_in_file(opts.merge(struct: true))
+      mdoc = MDoc.new(blocks_in_file)
+
       list_blocks_in_file(opts).map do |block|
-        next if opts[:hide_blocks_by_name] && block[:name].match(block_name_excluded_match)
+        next if mdoc.hide_menu_block_per_options(opts, block)
 
         block
       end.compact.tap_inspect
     end
 
-    def list_recent_output
-      Sfiles.new(@options[:saved_stdout_folder],
-                 @options[:saved_stdout_glob]).most_recent_list
+    def list_recent_output(saved_stdout_folder, saved_stdout_glob, list_count)
+      Sfiles.new(saved_stdout_folder, saved_stdout_glob).most_recent_list(list_count)
     end
 
-    def list_recent_scripts
-      Sfiles.new(@options[:saved_script_folder],
-                 @options[:saved_script_glob]).most_recent_list
+    def list_recent_scripts(saved_script_folder, saved_script_glob, list_count)
+      Sfiles.new(saved_script_folder, saved_script_glob).most_recent_list(list_count)
     end
 
     def make_block_labels(call_options = {})
       opts = options.merge(call_options)
       list_blocks_in_file(opts).map do |block|
-        # next if opts[:hide_blocks_by_name] && block[:name].match(%r{^:\(.+\)$})
-
         BlockLabel.new(filename: opts[:filename],
                        headings: block.fetch(:headings, []),
                        menu_blocks_with_docname: opts[:menu_blocks_with_docname],
@@ -697,419 +815,74 @@ module MarkdownExec
     end
 
     # :reek:DuplicateMethodCall
-    # :reek:UncommunicativeMethodName ### temp
-    def menu_data1
-      val_as_bool = ->(value) { value.class.to_s == 'String' ? (value.chomp != '0') : value }
-      val_as_int = ->(value) { value.to_i }
-      val_as_str = ->(value) { value.to_s }
-      # val_true = ->(_value) { true } # for commands, sets option to true
-      menu_options = [
-        {
-          arg_name: 'PATH',
-          default: '.',
-          description: 'Read configuration file',
-          long_name: 'config',
-          proc1: lambda { |value|
-                   read_configuration_file! options, value
-                 }
-        },
-        {
-          arg_name: 'BOOL',
-          default: false,
-          description: 'Debug output',
-          env_var: 'MDE_DEBUG',
-          long_name: 'debug',
-          short_name: 'd',
-          proc1: lambda { |value|
-                   tap_config value.to_i != 0
-                 }
-        },
-        {
-          arg_name: "INT.#{DISPLAY_LEVEL_BASE}-#{DISPLAY_LEVEL_MAX}",
-          default: DISPLAY_LEVEL_DEFAULT,
-          description: "Output display level (#{DISPLAY_LEVEL_BASE} to #{DISPLAY_LEVEL_MAX})",
-          env_var: 'MDE_DISPLAY_LEVEL',
-          long_name: 'display-level',
-          opt_name: :display_level,
-          proc1: val_as_int
-        },
-        {
-          arg_name: 'NAME',
-          compreply: false,
-          description: 'Name of block',
-          env_var: 'MDE_BLOCK_NAME',
-          long_name: 'block-name',
-          opt_name: :block_name,
-          short_name: 'f',
-          proc1: val_as_str
-        },
-        {
-          arg_name: 'RELATIVE_PATH',
-          compreply: '.',
-          description: 'Name of document',
-          env_var: 'MDE_FILENAME',
-          long_name: 'filename',
-          opt_name: :filename,
-          short_name: 'f',
-          proc1: val_as_str
-        },
-        {
-          description: 'List blocks',
-          long_name: 'list-blocks',
-          opt_name: :list_blocks,
-          proc1: val_as_bool
-        },
-        {
-          arg_name: 'INT.1-',
-          default: 32,
-          description: 'Max. items to return in list',
-          env_var: 'MDE_LIST_COUNT',
-          long_name: 'list-count',
-          opt_name: :list_count,
-          proc1: val_as_int
-        },
-        {
-          description: 'List default configuration as environment variables',
-          long_name: 'list-default-env',
-          opt_name: :list_default_env
-        },
-        {
-          description: 'List default configuration as YAML',
-          long_name: 'list-default-yaml',
-          opt_name: :list_default_yaml
-        },
-        {
-          description: 'List docs in current folder',
-          long_name: 'list-docs',
-          opt_name: :list_docs,
-          proc1: val_as_bool
-        },
-        {
-          description: 'List recent saved output',
-          long_name: 'list-recent-output',
-          opt_name: :list_recent_output,
-          proc1: val_as_bool
-        },
-        {
-          description: 'List recent saved scripts',
-          long_name: 'list-recent-scripts',
-          opt_name: :list_recent_scripts,
-          proc1: val_as_bool
-        },
-        {
-          arg_name: 'PREFIX',
-          default: MarkdownExec::BIN_NAME,
-          description: 'Name prefix for stdout files',
-          env_var: 'MDE_LOGGED_STDOUT_FILENAME_PREFIX',
-          long_name: 'logged-stdout-filename-prefix',
-          opt_name: :logged_stdout_filename_prefix,
-          proc1: val_as_str
-        },
-        {
-          arg_name: 'BOOL',
-          default: false,
-          description: 'Display document name in block selection menu',
-          env_var: 'MDE_MENU_BLOCKS_WITH_DOCNAME',
-          long_name: 'menu-blocks-with-docname',
-          opt_name: :menu_blocks_with_docname,
-          proc1: val_as_bool
-        },
-        {
-          arg_name: 'BOOL',
-          default: false,
-          description: 'Display headings (levels 1,2,3) in block selection menu',
-          env_var: 'MDE_MENU_BLOCKS_WITH_HEADINGS',
-          long_name: 'menu-blocks-with-headings',
-          opt_name: :menu_blocks_with_headings,
-          proc1: val_as_bool
-        },
-        {
-          arg_name: 'BOOL',
-          default: false,
-          description: 'Display summary for execution',
-          env_var: 'MDE_OUTPUT_EXECUTION_SUMMARY',
-          long_name: 'output-execution-summary',
-          opt_name: :output_execution_summary,
-          proc1: val_as_bool
-        },
-        {
-          arg_name: 'BOOL',
-          default: false,
-          description: 'Display script prior to execution',
-          env_var: 'MDE_OUTPUT_SCRIPT',
-          long_name: 'output-script',
-          opt_name: :output_script,
-          proc1: val_as_bool
-        },
-        {
-          arg_name: 'BOOL',
-          default: true,
-          description: 'Display standard output from execution',
-          env_var: 'MDE_OUTPUT_STDOUT',
-          long_name: 'output-stdout',
-          opt_name: :output_stdout,
-          proc1: val_as_bool
-        },
-        {
-          arg_name: 'RELATIVE_PATH',
-          default: '.',
-          description: 'Path to documents',
-          env_var: 'MDE_PATH',
-          long_name: 'path',
-          opt_name: :path,
-          short_name: 'p',
-          proc1: val_as_str
-        },
-        {
-          description: 'Gem home folder',
-          long_name: 'pwd',
-          opt_name: :pwd,
-          proc1: val_as_bool
-        },
-        {
-          description: 'Run most recently saved script',
-          long_name: 'run-last-script',
-          opt_name: :run_last_script,
-          proc1: val_as_bool
-        },
-        {
-          arg_name: 'BOOL',
-          default: false,
-          description: 'Save executed script',
-          env_var: 'MDE_SAVE_EXECUTED_SCRIPT',
-          long_name: 'save-executed-script',
-          opt_name: :save_executed_script,
-          proc1: val_as_bool
-        },
-        {
-          arg_name: 'BOOL',
-          default: false,
-          description: 'Save standard output of the executed script',
-          env_var: 'MDE_SAVE_EXECUTION_OUTPUT',
-          long_name: 'save-execution-output',
-          opt_name: :save_execution_output,
-          proc1: val_as_bool
-        },
-        {
-          arg_name: 'INT',
-          default: 0o755,
-          description: 'chmod for saved scripts',
-          env_var: 'MDE_SAVED_SCRIPT_CHMOD',
-          long_name: 'saved-script-chmod',
-          opt_name: :saved_script_chmod,
-          proc1: val_as_int
-        },
-        {
-          arg_name: 'PREFIX',
-          default: MarkdownExec::BIN_NAME,
-          description: 'Name prefix for saved scripts',
-          env_var: 'MDE_SAVED_SCRIPT_FILENAME_PREFIX',
-          long_name: 'saved-script-filename-prefix',
-          opt_name: :saved_script_filename_prefix,
-          proc1: val_as_str
-        },
-        {
-          arg_name: 'RELATIVE_PATH',
-          default: 'logs',
-          description: 'Saved script folder',
-          env_var: 'MDE_SAVED_SCRIPT_FOLDER',
-          long_name: 'saved-script-folder',
-          opt_name: :saved_script_folder,
-          proc1: val_as_str
-        },
-        {
-          arg_name: 'GLOB',
-          default: 'mde_*.sh',
-          description: 'Glob matching saved scripts',
-          env_var: 'MDE_SAVED_SCRIPT_GLOB',
-          long_name: 'saved-script-glob',
-          opt_name: :saved_script_glob,
-          proc1: val_as_str
-        },
-        {
-          arg_name: 'RELATIVE_PATH',
-          default: 'logs',
-          description: 'Saved stdout folder',
-          env_var: 'MDE_SAVED_STDOUT_FOLDER',
-          long_name: 'saved-stdout-folder',
-          opt_name: :saved_stdout_folder,
-          proc1: val_as_str
-        },
-        {
-          arg_name: 'GLOB',
-          default: 'mde_*.out.txt',
-          description: 'Glob matching saved outputs',
-          env_var: 'MDE_SAVED_STDOUT_GLOB',
-          long_name: 'saved-stdout-glob',
-          opt_name: :saved_stdout_glob,
-          proc1: val_as_str
-        },
-        {
-          description: 'Select and execute a recently saved output',
-          long_name: 'select-recent-output',
-          opt_name: :select_recent_output,
-          proc1: val_as_bool
-        },
-        {
-          description: 'Select and execute a recently saved script',
-          long_name: 'select-recent-script',
-          opt_name: :select_recent_script,
-          proc1: val_as_bool
-        },
-        {
-          description: 'YAML export of menu',
-          long_name: 'menu-export',
-          opt_name: :menu_export,
-          proc1: val_as_bool
-        },
-        {
-          description: 'List tab completions',
-          long_name: 'tab-completions',
-          opt_name: :tab_completions,
-          proc1: val_as_bool
-        },
-        {
-          arg_name: 'BOOL',
-          default: true,
-          description: 'Pause for user to approve script',
-          env_var: 'MDE_USER_MUST_APPROVE',
-          long_name: 'user-must-approve',
-          opt_name: :user_must_approve,
-          proc1: val_as_bool
-        },
-        {
-          description: 'Show current configuration values',
-          short_name: '0',
-          proc1: lambda { |_|
-                   options_finalize options
-                   fout options.sort_by_key.to_yaml
-                 }
-        },
-        {
-          description: 'App help',
-          long_name: 'help',
-          short_name: 'h',
-          proc1: lambda { |_|
-                   fout menu_help
-                   exit
-                 }
-        },
-        {
-          description: "Print the gem's version",
-          long_name: 'version',
-          short_name: 'v',
-          proc1: lambda { |_|
-                   fout MarkdownExec::VERSION
-                   exit
-                 }
-        },
-        {
-          description: 'Exit app',
-          long_name: 'exit',
-          short_name: 'x',
-          proc1: ->(_) { exit }
-        },
-        {
-          default: '^\(.*\)$',
-          description: 'Pattern for blocks to hide from user-selection',
-          env_var: 'MDE_BLOCK_NAME_EXCLUDED_MATCH',
-          opt_name: :block_name_excluded_match,
-          proc1: val_as_str
-        },
-        {
-          default: ':(?<title>\S+)( |$)',
-          env_var: 'MDE_BLOCK_NAME_MATCH',
-          opt_name: :block_name_match,
-          proc1: val_as_str
-        },
-        {
-          default: '\+\S+',
-          env_var: 'MDE_BLOCK_REQUIRED_SCAN',
-          opt_name: :block_required_scan,
-          proc1: val_as_str
-        },
-        {
-          default: '> ',
-          env_var: 'MDE_DISPLAY_LEVEL_XBASE_PREFIX',
-          opt_name: :display_level_xbase_prefix,
-          proc1: val_as_str
-        },
-        {
-          default: '^`{3,}',
-          env_var: 'MDE_FENCED_START_AND_END_MATCH',
-          opt_name: :fenced_start_and_end_match,
-          proc1: val_as_str
-        },
-        {
-          default: '^`{3,}(?<shell>[^`\s]*) *(?<name>.*)$',
-          env_var: 'MDE_FENCED_START_EX_MATCH',
-          opt_name: :fenced_start_ex_match,
-          proc1: val_as_str
-        },
-        {
-          default: '^# *(?<name>[^#]*?) *$',
-          env_var: 'MDE_HEADING1_MATCH',
-          opt_name: :heading1_match,
-          proc1: val_as_str
-        },
-        {
-          default: '^## *(?<name>[^#]*?) *$',
-          env_var: 'MDE_HEADING2_MATCH',
-          opt_name: :heading2_match,
-          proc1: val_as_str
-        },
-        {
-          default: '^### *(?<name>.+?) *$',
-          env_var: 'MDE_HEADING3_MATCH',
-          opt_name: :heading3_match,
-          proc1: val_as_str
-        },
-        {
-          default: '*.[Mm][Dd]',
-          env_var: 'MDE_MD_FILENAME_GLOB',
-          opt_name: :md_filename_glob,
-          proc1: val_as_str
-        },
-        {
-          default: '.+\\.md',
-          env_var: 'MDE_MD_FILENAME_MATCH',
-          opt_name: :md_filename_match,
-          proc1: val_as_str
-        },
-        {
-          description: 'Options for viewing saved output file',
-          env_var: 'MDE_OUTPUT_VIEWER_OPTIONS',
-          opt_name: :output_viewer_options,
-          proc1: val_as_str
-        },
-        {
-          default: 24,
-          description: 'Maximum # of rows in select list',
-          env_var: 'MDE_SELECT_PAGE_HEIGHT',
-          opt_name: :select_page_height,
-          proc1: val_as_int
-        },
-        {
-          default: '#!/usr/bin/env',
-          description: 'Shebang for saved scripts',
-          env_var: 'MDE_SHEBANG',
-          opt_name: :shebang,
-          proc1: val_as_str
-        },
-        {
-          default: 'bash',
-          description: 'Shell for launched scripts',
-          env_var: 'MDE_SHELL',
-          opt_name: :shell,
-          proc1: val_as_str
-        }
-      ]
-      # commands first, options second
-      (menu_options.reject { |option| option[:arg_name] }) +
-        (menu_options.select { |option| option[:arg_name] })
+    # :reek:NestedIterators
+    def menu_for_optparse
+      menu_from_yaml.map do |menu_item|
+        menu_item.merge(
+          {
+            opt_name: menu_item[:opt_name]&.to_sym,
+            proccode: case menu_item[:procname]
+                      when 'debug'
+                        lambda { |value|
+                          tap_config value: value
+                        }
+                      when 'exit'
+                        lambda { |_|
+                          exit
+                        }
+                      when 'help'
+                        lambda { |_|
+                          fout menu_help
+                          exit
+                        }
+                      when 'path'
+                        lambda { |value|
+                          read_configuration_file! options, value
+                        }
+                      when 'show_config'
+                        lambda { |_|
+                          options_finalize options
+                          fout options.sort_by_key.to_yaml
+                        }
+                      when 'val_as_bool'
+                        ->(value) { value.class.to_s == 'String' ? (value.chomp != '0') : value }
+                      when 'val_as_int'
+                        ->(value) { value.to_i }
+                      when 'val_as_str'
+                        ->(value) { value.to_s }
+                      when 'version'
+                        lambda { |_|
+                          fout MarkdownExec::VERSION
+                          exit
+                        }
+                      else
+                        menu_item[:procname]
+                      end
+          }
+        )
+      end
     end
 
-    def menu_iter(data = menu_data1, &block)
+    def menu_for_blocks(menu_options)
+      options = default_options.merge menu_options
+      menu = []
+      iter_blocks_in_file(options) do |btype, headings, block_title, body|
+        case btype
+        when :filter
+          %i[blocks line]
+        when :line
+          if options[:menu_divider_match] && (mbody = body.match options[:menu_divider_match])
+            menu += [{ name: mbody[:name], disabled: '' }]
+          end
+        when :blocks
+          summ = get_block_summary options, headings: headings, block_title: block_title, block_body: body
+          menu += [summ[0][:name]]
+        end
+      end
+      menu.tap_yaml
+    end
+
+    def menu_iter(data = menu_for_optparse, &block)
       data.map(&block)
     end
 
@@ -1117,6 +890,33 @@ module MarkdownExec
       @option_parser.help
     end
 
+    def menu_option_append(opts, options, item)
+      return unless item[:long_name].present? || item[:short_name].present?
+
+      opts.on(*[
+        # long name
+        if item[:long_name].present?
+          "--#{item[:long_name]}#{item[:arg_name].present? ? " #{item[:arg_name]}" : ''}"
+        end,
+
+        # short name
+        item[:short_name].present? ? "-#{item[:short_name]}" : nil,
+
+        # description and default
+        [item[:description],
+         item[:default].present? ? "[#{value_for_cli item[:default]}]" : nil].compact.join('  '),
+
+        # apply proccode, if present, to value
+        # save value to options hash if option is named
+        #
+        lambda { |value|
+          (item[:proccode] ? item[:proccode].call(value) : value).tap do |converted|
+            options[item[:opt_name]] = converted if item[:opt_name]
+          end
+        }
+      ].compact)
+    end
+
     ## post-parse options configuration
     #
     def options_finalize(rest)
@@ -1128,7 +928,7 @@ module MarkdownExec
         elsif File.exist?(pos)
           @options[:filename] = pos
         else
-          raise "Invalid parameter: #{pos}"
+          raise FileMissingError, pos, caller
         end
       end
 
@@ -1145,7 +945,7 @@ module MarkdownExec
         options_block.call class_call_options
       else
         class_call_options
-      end.tap_inspect
+      end
     end
 
     def output_execution_result
@@ -1196,14 +996,27 @@ module MarkdownExec
     def read_configuration_file!(options, configuration_path)
       return unless File.exist?(configuration_path)
 
-      # rubocop:disable Security/YAMLLoad
       options.merge!((YAML.load(File.open(configuration_path)) || {})
         .transform_keys(&:to_sym))
-      # rubocop:enable Security/YAMLLoad
     end
 
     # :reek:NestedIterators
     def run
+      # eop = EnvironmentOptParse.new(
+      #   menu: File.join(File.expand_path(__dir__), 'menu.yml'),
+      #   options: {
+      #     menu_exit_at_top: true,
+      #     menu_with_exit: true
+      #   }
+      # ).tap_yaml '** eop'
+      # # eop = EnvironmentOptParse.new(menu: 'lib/menu.yml', options: ".#{MarkdownExec::APP_NAME.downcase}.yml", version: MarkdownExec::VERSION).tap_yaml '** eop'
+      # eop.options.tap_inspect 'eop.options'
+      # eop.remainder.tap_inspect 'eop.remainder'
+
+      # exec_block eop.options, eop.options[:block_name]
+
+      # return
+
       ## default configuration
       #
       @options = base_options
@@ -1221,29 +1034,20 @@ module MarkdownExec
         ].join("\n")
 
         menu_iter do |item|
-          next unless item[:long_name].present? || item[:short_name].present?
-
-          opts.on(*[if item[:long_name].present?
-                      "--#{item[:long_name]}#{item[:arg_name].present? ? " #{item[:arg_name]}" : ''}"
-                    end,
-                    item[:short_name].present? ? "-#{item[:short_name]}" : nil,
-                    [item[:description],
-                     item[:default].present? ? "[#{value_for_cli item[:default]}]" : nil].compact.join('  '),
-                    lambda { |value|
-                      # ret = item[:proc1].call(value)
-                      ret = item[:proc1] ? item[:proc1].call(value) : value
-                      options[item[:opt_name]] = ret if item[:opt_name]
-                      ret
-                    }].compact)
+          item.tap_yaml 'item'
+          menu_option_append opts, options, item
         end
       end
       option_parser.load # filename defaults to basename of the program without suffix in a directory ~/.options
       option_parser.environment # env defaults to the basename of the program.
       rest = option_parser.parse! # (into: options)
 
-      options_finalize rest
-
-      exec_block options, options[:block_name]
+      begin
+        options_finalize rest
+        exec_block options, options[:block_name]
+      rescue FileMissingError => e
+        puts "File missing: #{e}"
+      end
     end
 
     def saved_name_split(name)
@@ -1291,16 +1095,18 @@ module MarkdownExec
 
     def select_and_approve_block(call_options = {}, &options_block)
       opts = optsmerge call_options, options_block
-      blocks_in_file = list_blocks_in_file(opts.merge(struct: true))
-      mdoc = MDoc.new(blocks_in_file)
+      blocks_in_file = list_blocks_in_file(opts.merge(struct: true)).tap_inspect name: :blocks_in_file
+      mdoc = MDoc.new(blocks_in_file) { |nopts| opts.merge!(nopts).tap_yaml name: :infiled_opts }
+      blocks_menu = mdoc.blocks_for_menu(opts.merge(struct: true)).tap_inspect name: :blocks_menu
 
       repeat_menu = true && !opts[:block_name].present?
-
       loop do
         unless opts[:block_name].present?
           pt = (opts[:prompt_select_block]).to_s
 
-          blocks_in_file.each do |block|
+          blocks_menu.each do |block|
+            next if block.fetch(:disabled, false)
+
             block.merge! label:
             BlockLabel.new(filename: opts[:filename],
                            headings: block.fetch(:headings, []),
@@ -1308,27 +1114,15 @@ module MarkdownExec
                            menu_blocks_with_headings: opts[:menu_blocks_with_headings],
                            title: block[:title]).make
           end
+          return nil if blocks_menu.count.zero?
 
-          block_labels = mdoc.option_exclude_blocks(opts).map { |block| block[:label] }
-
-          return nil if block_labels.count.zero?
-
-          sel = prompt_with_quit pt, block_labels, per_page: opts[:select_page_height]
+          sel = prompt_with_quit pt, blocks_menu, per_page: opts[:select_page_height]
           return nil if sel.nil?
 
-          # if sel.nil?
-          #   repeat_menu = false
-          #   break
-          # end
-
           label_block = blocks_in_file.select { |block| block[:label] == sel }.fetch(0, nil)
           opts[:block_name] = @options[:block_name] = label_block[:name]
-
         end
-        # if repeat_menu
         approve_block opts, mdoc
-        # end
-
         break unless repeat_menu
 
         opts[:block_name] = ''
@@ -1345,38 +1139,53 @@ module MarkdownExec
     end
 
     def select_recent_output
-      filename = prompt_with_quit @options[:prompt_select_output].to_s, list_recent_output,
-                                  per_page: @options[:select_page_height]
+      filename = prompt_with_quit(
+        @options[:prompt_select_output].to_s,
+        list_recent_output(
+          @options[:saved_stdout_folder],
+          @options[:saved_stdout_glob],
+          @options[:list_count]
+        ),
+        { per_page: @options[:select_page_height] }
+      )
       return unless filename.present?
 
       `open #{filename} #{options[:output_viewer_options]}`
     end
 
     def select_recent_script
-      filename = prompt_with_quit @options[:prompt_select_md].to_s, list_recent_scripts,
-                                  per_page: @options[:select_page_height]
+      filename = prompt_with_quit(
+        @options[:prompt_select_md].to_s,
+        list_recent_scripts(
+          @options[:saved_script_folder],
+          @options[:saved_script_glob],
+          @options[:list_count]
+        ),
+        { per_page: @options[:select_page_height] }
+      )
       return if filename.nil?
 
-      saved_name_split filename
-      select_and_approve_block(
-        bash: true,
-        save_executed_script: false,
-        struct: true
-      )
+      saved_name_split(filename)
+
+      select_and_approve_block({
+                                 bash: true,
+                                 save_executed_script: false,
+                                 struct: true
+                               })
     end
 
     def summarize_block(headings, title)
       { headings: headings, name: title, title: title }
     end
 
-    def menu_export(data = menu_data1)
+    def menu_export(data = menu_for_optparse)
       data.map do |item|
-        item.delete(:proc1)
+        item.delete(:procname)
         item
       end.to_yaml
     end
 
-    def tab_completions(data = menu_data1)
+    def tab_completions(data = menu_for_optparse)
       data.map do |item|
         "--#{item[:long_name]}" if item[:long_name]
       end.compact
@@ -1390,7 +1199,7 @@ module MarkdownExec
       else
         @options.merge! opts
       end
-      @options.tap_inspect format: :yaml
+      @options.tap_yaml
     end
 
     def write_command_file(call_options, required_blocks)
@@ -1425,5 +1234,5 @@ module MarkdownExec
 
       File.chmod @options[:saved_script_chmod], @options[:saved_filespec]
     end
-  end
-end
+  end # class MarkParse
+end # module MarkdownExec