markdown_exec 1.3.1 → 1.3.3.1

data/lib/markdown_exec.rb

@@ -6,16 +6,15 @@
 require 'English'
 require 'clipboard'
 require 'open3'
-# require 'optparse'
+require 'optparse'
 require 'shellwords'
 require 'tty-prompt'
 require 'yaml'
 
+require_relative 'cached_nested_file_reader'
 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'
@@ -30,13 +29,24 @@ $stdout.sync = true
 
 BLOCK_SIZE = 1024
 
+# custom error: file specified is missing
+#
 class FileMissingError < StandardError; end
 
 # hash with keys sorted by name
+# add Hash.sym_keys
 #
 class Hash
-  def sort_by_key
-    keys.sort.to_h { |key| [key, self[key]] }
+  unless defined?(sort_by_key)
+    def sort_by_key
+      keys.sort.to_h { |key| [key, self[key]] }
+    end
+  end
+
+  unless defined?(sym_keys)
+    def sym_keys
+      transform_keys(&:to_sym)
+    end
   end
 end
 
@@ -71,69 +81,226 @@ module FOUT
   end
 end
 
+def dp(str)
+  lout " => #{str}", level: DISPLAY_LEVEL_DEBUG
+end
+
 public
 
+# :reek:UtilityFunction
+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
+
+# :reek:UtilityFunction
+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
+
+# convert regex match groups to a hash with symbol keys
+#
+# :reek:UtilityFunction
+def option_match_groups(str, option)
+  str.match(Regexp.new(option))&.named_captures&.sym_keys
+end
+
 # execute markdown documents
 #
 module MarkdownExec
   # :reek:IrresponsibleModule
   class Error < StandardError; end
 
-  # cache lines in text file
+  # fenced code block
   #
-  class CFile
-    def initialize
-      @cache = {}
+  class FCB
+    def initialize(options = {})
+      @attrs = {
+        body: nil,
+        call: nil,
+        headings: [],
+        name: nil,
+        reqs: [],
+        shell: '',
+        title: '',
+        random: Random.new.rand,
+        text: nil # displayable in menu
+      }.merge options
     end
 
-    def readlines(filename)
-      if @cache[filename]
-        @cache[filename].each do |line|
-          yield line if block_given?
-        end
+    def to_h
+      @attrs
+    end
+
+    def to_yaml
+      @attrs.to_yaml
+    end
+
+    private
+
+    # :reek:ManualDispatch
+    def method_missing(method, *args, &block)
+      method_name = method.to_s
+
+      if @attrs.respond_to?(method_name)
+        @attrs.send(method_name, *args, &block)
+      elsif method_name[-1] == '='
+        @attrs[method_name.chop.to_sym] = args[0]
       else
-        lines = []
-        File.readlines(filename).each do |line|
-          lines.push line
-          yield line if block_given?
+        @attrs[method_name.to_sym]
+      end
+    rescue StandardError => err
+      warn(error = "ERROR ** FCB.method_missing(method: #{method_name}," \
+                   " *args: #{args.inspect}, &block)")
+      warn err.inspect
+      warn(caller[0..4])
+      raise StandardError, error
+    end
+
+    # option names are available as methods
+    #
+    def respond_to_missing?(_method_name, _include_private = false)
+      true # recognize all hash methods, rest are treated as hash keys
+    end
+  end
+
+  # select fcb per options
+  #
+  # :reek:UtilityFunction
+  class Filter
+    #     def self.fcb_title_parse(opts, fcb_title)
+    #       fcb_title.match(Regexp.new(opts[:fenced_start_ex_match])).named_captures.sym_keys
+    #     end
+
+    def self.fcb_select?(options, fcb)
+      # options.tap_yaml 'options'
+      # fcb.tap_inspect 'fcb'
+      name = fcb.fetch(:name, '').tap_inspect 'name'
+      shell = fcb.fetch(:shell, '').tap_inspect 'shell'
+
+      ## include hidden blocks for later use
+      #
+      name_default = true
+      name_exclude = nil
+      name_select = nil
+      shell_default = true
+      shell_exclude = nil
+      shell_select = nil
+      hidden_name = nil
+
+      if name.present? && options[:block_name]
+        if name =~ /#{options[:block_name]}/
+          '=~ block_name'.tap_puts
+          name_select = true
+          name_exclude = false
+        else
+          '!~ block_name'.tap_puts
+          name_exclude = true
+          name_select = false
         end
-        @cache[filename] = lines
       end
+
+      if name.present? && name_select.nil? && options[:select_by_name_regex].present?
+        '+select_by_name_regex'.tap_puts
+        name_select = (!!(name =~ /#{options[:select_by_name_regex]}/)).tap_inspect 'name_select'
+      end
+
+      if shell.present? && options[:select_by_shell_regex].present?
+        '+select_by_shell_regex'.tap_puts
+        shell_select = (!!(shell =~ /#{options[:select_by_shell_regex]}/)).tap_inspect 'shell_select'
+      end
+
+      if name.present? && name_exclude.nil? && options[:exclude_by_name_regex].present?
+        '-exclude_by_name_regex'.tap_puts
+        name_exclude = (!!(name =~ /#{options[:exclude_by_name_regex]}/)).tap_inspect 'name_exclude'
+      end
+
+      if shell.present? && options[:exclude_by_shell_regex].present?
+        '-exclude_by_shell_regex'.tap_puts
+        shell_exclude = (!!(shell =~ /#{options[:exclude_by_shell_regex]}/)).tap_inspect 'shell_exclude'
+      end
+
+      if name.present? && options[:hide_blocks_by_name] &&
+         options[:block_name_hidden_match].present?
+        '+block_name_hidden_match'.tap_puts
+        hidden_name = (!!(name =~ /#{options[:block_name_hidden_match]}/)).tap_inspect 'hidden_name'
+      end
+
+      if shell.present? && options[:hide_blocks_by_shell] &&
+         options[:block_shell_hidden_match].present?
+        '-hide_blocks_by_shell'.tap_puts
+        (!!(shell =~ /#{options[:block_shell_hidden_match]}/)).tap_inspect 'hidden_shell'
+      end
+
+      if options[:bash_only]
+        '-bash_only'.tap_puts
+        shell_default = (shell == 'bash').tap_inspect 'shell_default'
+      end
+
+      ## name matching does not filter hidden blocks
+      #
+      case
+      when options[:no_chrome] && fcb.fetch(:chrome, false)
+        '-no_chrome'.tap_puts
+        false
+      when options[:exclude_expect_blocks] && shell == 'expect'
+        '-exclude_expect_blocks'.tap_puts
+        false
+      when hidden_name == true
+        true
+      when name_exclude == true, shell_exclude == true,
+           name_select == false, shell_select == false
+        false
+      when name_select == true, shell_select == true
+        true
+      when name_default == false, shell_default == false
+        false
+      else
+        true
+      end.tap_inspect
+    # binding.pry
+    rescue StandardError => err
+      warn("ERROR ** Filter::fcb_select?(); #{err.inspect}")
+      raise err
     end
-  end # class CFile
+  end # class Filter
 
   ## an imported markdown document
   #
   class MDoc
+    attr_reader :table
+
+    # convert block name to fcb_parse
+    #
     def initialize(table)
       @table = table
     end
 
     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
+        .map do |fcb|
+        body = fcb[:body].join("\n")
+
+        if fcb[:cann]
+          xcall = fcb[:cann][1..-2]
+          mstdin = xcall.match(/<(?<type>\$)?(?<name>[A-Za-z_\-.\w]+)/)
+          mstdout = xcall.match(/>(?<type>\$)?(?<name>[A-Za-z_\-.\w]+)/)
+
           yqcmd = if mstdin[:type]
                     "echo \"$#{mstdin[:name]}\" | yq '#{body}'"
                   else
                     "yq e '#{body}' '#{mstdin[:name]}'"
-                  end.tap_inspect name: :yqcmd
+                  end
           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
+        elsif fcb[:stdout]
+          stdout = fcb[:stdout]
+          body = fcb[:body].join("\n")
           if stdout[:type]
-            # "export #{stdout[:name]}=#{Shellwords.escape body}"
             %(export #{stdout[:name]}=$(cat <<"EOF"\n#{body}\nEOF\n))
           else
             "cat > '#{stdout[:name]}' <<\"EOF\"\n" \
@@ -141,65 +308,84 @@ module MarkdownExec
               "EOF\n"
           end
         else
-          block[:body]
+          fcb[:body]
         end
       end.flatten(1)
-        .tap_yaml
     end
 
     def get_block_by_name(name, default = {})
-      name.tap_inspect name: :name
-      @table.select { |block| block[:name] == name }.fetch(0, default).tap_yaml
+      @table.select { |fcb| fcb.fetch(:name, '') == name }.fetch(0, default)
     end
 
     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])
+      all = [name_block.fetch(:name, '')] + recursively_required(name_block[:reqs])
 
       # in order of appearance in document
-      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 })]
+      @table.select { |fcb| all.include? fcb.fetch(:name, '') }
+            .map do |fcb|
+        if (call = fcb[:call])
+          [get_block_by_name("[#{call.match(/^%\((\S+) |\)/)[1]}]")
+            .merge({ cann: call })]
         else
           []
-        end + [block]
-      end.flatten(1) # .tap_yaml
+        end + [fcb]
+      end.flatten(1)
     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
+              block[:name]&.match(Regexp.new(opts[:block_name_hidden_match])) &&
+              (block[:name]&.present? || block[:label]&.present?)
+      ).tap_inspect
     end
 
-    def blocks_for_menu(opts)
+    # def blocks_for_menu(opts)
+    #   if opts[:hide_blocks_by_name]
+    #     @table.reject { |block| hide_menu_block_per_options opts, block }
+    #   else
+    #     @table
+    #   end
+    # end
+
+    def fcbs_per_options(opts = {})
+      options = opts.merge(block_name_hidden_match: nil)
+      selrows = @table.select do |fcb_title_groups|
+        Filter.fcb_select? options, fcb_title_groups
+      end
+      # binding.pry
+      ### hide rows correctly
+
       if opts[:hide_blocks_by_name]
-        @table.reject { |block| hide_menu_block_per_options opts, block }
+        selrows.reject { |block| hide_menu_block_per_options opts, block }
       else
-        @table
+        selrows
+      end.map do |block|
+        # block[:name] = block[:text] if block[:name].nil?
+        block
       end
     end
 
     def recursively_required(reqs)
-      all = []
+      return [] unless reqs
+
       rem = reqs
+      memo = []
       while rem.count.positive?
         rem = rem.map do |req|
-          next if all.include? req
+          next if memo.include? req
 
-          all += [req]
+          memo += [req]
           get_block_by_name(req).fetch(:reqs, [])
         end
                  .compact
                  .flatten(1)
       end
-      all.tap_yaml
+      memo
     end
   end # class MDoc
 
@@ -207,16 +393,30 @@ module MarkdownExec
   #
   # :reek:TooManyInstanceVariables
   class BlockLabel
-    def initialize(filename:, headings:, menu_blocks_with_docname:, menu_blocks_with_headings:, title:)
+    def initialize(filename:, headings:, menu_blocks_with_docname:,
+                   menu_blocks_with_headings:, title:, body:, text:)
       @filename = filename
       @headings = headings
       @menu_blocks_with_docname = menu_blocks_with_docname
       @menu_blocks_with_headings = menu_blocks_with_headings
+      # @title = title.present? ? title : body
       @title = title
+      @body = body
+      @text = text
+    rescue StandardError => err
+      warn(error = "ERROR ** BlockLabel.initialize(); #{err.inspect}")
+      binding.pry if $tap_enable
+      raise ArgumentError, error
     end
 
+    # join title, headings, filename
+    #
     def make
-      ([@title] +
+      label = @title
+      label = @body unless label.present?
+      label = @text unless label.present?
+      label.tap_inspect
+      ([label] +
         (if @menu_blocks_with_headings
            [@headings.compact.join(' # ')]
          else
@@ -229,6 +429,10 @@ module MarkdownExec
             []
           end
         )).join('  ')
+    rescue StandardError => err
+      warn(error = "ERROR ** BlockLabel.make(); #{err.inspect}")
+      binding.pry if $tap_enable
+      raise ArgumentError, error
     end
   end # class BlockLabel
 
@@ -247,11 +451,13 @@ module MarkdownExec
 
     def script_name
       fne = @filename.gsub(FNR11, FNR12)
-      "#{[@prefix, @time.strftime('%F-%H-%M-%S'), fne, ',', @blockname].join('_')}.sh".tap_inspect
+      "#{[@prefix, @time.strftime('%F-%H-%M-%S'), fne, ',',
+          @blockname].join('_')}.sh"
     end
 
     def stdout_name
-      "#{[@prefix, @time.strftime('%F-%H-%M-%S'), @filename, @blockname].join('_')}.out.txt".tap_inspect
+      "#{[@prefix, @time.strftime('%F-%H-%M-%S'), @filename,
+          @blockname].join('_')}.out.txt"
     end
   end # class SavedAsset
 
@@ -308,27 +514,29 @@ module MarkdownExec
     end
 
     def list_all
-      Dir.glob(File.join(@folder, @glob)).tap_inspect
+      Dir.glob(File.join(@folder, @glob))
     end
 
     def most_recent(arr = nil)
       arr = list_all if arr.nil?
       return if arr.count < 1
 
-      arr.max.tap_inspect
+      arr.max
     end
 
     def most_recent_list(list_count, arr = nil)
       arr = list_all if arr.nil?
       return if (ac = arr.count) < 1
 
-      arr.sort[-[ac, list_count].min..].reverse.tap_inspect
+      arr.sort[-[ac, list_count].min..].reverse
     end
   end # class Sfiles
 
   ##
   #
+  # rubocop:disable Layout/LineLength
   # :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
@@ -339,8 +547,8 @@ module MarkdownExec
 
     def initialize(options = {})
       @options = options
+      # hide disabled symbol
       @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
@@ -350,12 +558,35 @@ module MarkdownExec
       @execute_script_filespec = nil
       @execute_started_at = nil
       @option_parser = nil
-      @cfile = CFile.new
+    end
+
+    # return arguments before `--`
+    #
+    def arguments_for_mde(argv = ARGV)
+      case ind = argv.find_index('--')
+      when nil
+        argv
+      when 0
+        []
+      else
+        argv[0..ind - 1]
+      end #.tap_inspect
+    end
+
+    # return arguments after `--`
+    #
+    def arguments_for_child(argv = ARGV)
+      case ind = argv.find_index('--')
+      when nil, argv.count - 1
+        []
+      else
+        argv[ind + 1..-1]
+      end #.tap_inspect
     end
 
     ##
     # options necessary to start, parse input, defaults for cli options
-
+    #
     def base_options
       menu_iter do |item|
         # noisy item.tap_yaml name: :item
@@ -366,45 +597,39 @@ module MarkdownExec
         value = if item_default.nil?
                   item_default
                 else
-                  env_str(item[:env_var], default: OptionValue.new(item_default).for_hash)
+                  env_str(item[:env_var],
+                          default: OptionValue.new(item_default).for_hash)
                 end
         [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_yaml
+      end.compact.to_h
     end
 
-    def default_options
+    def calculated_options
       {
         bash: true, # bash block parsing in get_block_summary()
-        exclude_expect_blocks: true,
-        hide_blocks_by_name: true,
-        output_saved_script_filename: false,
         saved_script_filename: nil, # calculated
         struct: true # allow get_block_summary()
       }
     end
 
-    def approve_block(opts, mdoc)
+    def approve_and_execute_block(opts, mdoc)
       required_blocks = mdoc.collect_recursively_required_code(opts[:block_name])
-      display_required_code(opts, required_blocks) if opts[:output_script] || opts[:user_must_approve]
+      if opts[:output_script] || opts[:user_must_approve]
+        display_required_code(opts,
+                              required_blocks)
+      end
 
       allow = true
       if opts[:user_must_approve]
         loop do
-          (sel = @prompt.select(opts[:prompt_approve_block], filter: true) do |menu|
+          (sel = @prompt.select(opts[:prompt_approve_block],
+                                filter: true) do |menu|
              menu.default 1
-             # menu.enum '.'
-             # menu.filter true
-
              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
+           end)
           allow = (sel == 1)
           if sel == 3
             text = required_blocks.flatten.join($INPUT_RECORD_SEPARATOR)
@@ -414,13 +639,14 @@ module MarkdownExec
                  " #{text.length} characters"
           end
           if sel == 4
-            write_command_file(opts.merge(save_executed_script: true), required_blocks)
+            write_command_file(opts.merge(save_executed_script: true),
+                               required_blocks)
             fout "File saved: #{@options[:saved_filespec]}"
           end
           break if [1, 2].include? sel
         end
       end
-      (opts[:ir_approve] = allow).tap_inspect name: :allow
+      (opts[:ir_approve] = allow)
 
       selected = mdoc.get_block_by_name opts[:block_name]
 
@@ -435,21 +661,25 @@ module MarkdownExec
       selected[:name]
     end
 
-    # def cc(str)
-    #   puts " - - - #{Process.clock_gettime(Process::CLOCK_MONOTONIC)} - #{str}"
-    # end
+    def cfile
+# puts @options.inspect
+# binding.pry
+      @cfile ||= CachedNestedFileReader.new(import_pattern: @options.fetch(:import_pattern))
+      # @cfile ||= CachedNestedFileReader.new(import_pattern: /^ *#insert (.+)$/)
+    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|
+      args = []
+      Open3.popen3(@options[:shell], '-c',
+                   command, ARGV[0], *args) do |stdin, stdout, stderr, exec_thr|
         #d 'command started'
         Thread.new do
           until (line = stdout.gets).nil?
@@ -478,7 +708,7 @@ module MarkdownExec
             yield line, nil, nil, exec_thr if block_given?
           end
           #d 'exec_thr now dead'
-        rescue
+        rescue StandardError
           #d 'stdin error, thread killed, do nothing'
         end
 
@@ -495,26 +725,26 @@ module MarkdownExec
       end
       #d 'command completed'
       @execute_completed_at = Time.now.utc
-    rescue Errno::ENOENT => e
+    rescue Errno::ENOENT => err
       #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_error_message = err.message
+      @execute_error = err
       @execute_files[EF_STDERR] += [@execute_error_message]
-      fout "Error ENOENT: #{e.inspect}"
-    rescue SignalException => e
+      fout "Error ENOENT: #{err.inspect}"
+    rescue SignalException => err
       #d 'command SIGTERM triggered by user or system'
       @execute_aborted_at = Time.now.utc
       @execute_error_message = 'SIGTERM'
-      @execute_error = e
+      @execute_error = err
       @execute_files[EF_STDERR] += [@execute_error_message]
-      fout "Error ENOENT: #{e.inspect}"
+      fout "Error ENOENT: #{err.inspect}"
     end
 
     def count_blocks_in_filename
       fenced_start_and_end_match = Regexp.new @options[:fenced_start_and_end_match]
       cnt = 0
-      @cfile.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
@@ -530,7 +760,7 @@ module MarkdownExec
 
     # :reek:DuplicateMethodCall
     def exec_block(options, _block_name = '')
-      options = default_options.merge options
+      options = calculated_options.merge(options).tap_yaml 'options'
       update_options options, over: false
 
       # document and block reports
@@ -548,12 +778,16 @@ module MarkdownExec
         list_docs: -> { fout_list files },
         list_default_env: -> { fout_list list_default_env },
         list_recent_output: lambda {
-                              fout_list list_recent_output(@options[:saved_stdout_folder],
-                                                           @options[:saved_stdout_glob], @options[:list_count])
+                              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])
+                               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 },
@@ -572,41 +806,43 @@ module MarkdownExec
       # process
       #
       @options[:filename] = select_md_file(files)
-      select_and_approve_block(
-        bash: true,
-        struct: true
-      )
-      fout "saved_filespec: #{@execute_script_filespec}" if @options[:output_saved_script_filename]
+      select_approve_and_execute_block({
+                                         bash: true,
+                                         struct: true
+                                       })
+      return unless @options[:output_saved_script_filename]
+
+      fout "saved_filespec: #{@execute_script_filespec}"
+    rescue StandardError => err
+      warn(error = "ERROR ** MarkParse.exec_block(); #{err.inspect}")
+      binding.pry if $tap_enable
+      raise ArgumentError, error
     end
 
-    # :reek:LongParameterList
-    def get_block_summary(call_options = {}, headings:, block_title:, block_body:)
+    ## summarize blocks
+    #
+    def get_block_summary(call_options, fcb)
       opts = optsmerge call_options
-      return [block_body] unless opts[:struct]
-      return [summarize_block(headings, block_title).merge({ body: block_body })] unless opts[:bash]
+      # return fcb.body unless opts[:struct]
 
-      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
+      return fcb unless opts[:bash]
 
-      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
-
-      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
+      fcb.call = fcb.title.match(Regexp.new(opts[:block_calls_scan]))&.fetch(1, nil)
+      titlexcall = if fcb.call
+                     fcb.title.sub("%#{fcb.call}", '')
+                   else
+                     fcb.title
+                   end
+      bm = option_match_groups(titlexcall, opts[:block_name_match])
+      fcb.stdin = option_match_groups(titlexcall, opts[:block_stdin_scan])
+      fcb.stdout = option_match_groups(titlexcall, opts[:block_stdout_scan])
+      fcb.title = fcb.name = (bm && bm[1] ? bm[:title] : titlexcall)
+      fcb
     end
 
     # :reek:DuplicateMethodCall
     # :reek:LongYieldList
+    # :reek:NestedIterators
     def iter_blocks_in_file(opts = {})
       # opts = optsmerge call_options, options_block
 
@@ -622,14 +858,15 @@ module MarkdownExec
 
       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 = ''
-      block_body = nil
-      headings = []
+      fcb = FCB.new
       in_block = false
+      headings = []
 
+      ## get type of messages to select
+      #
       selected_messages = yield :filter
 
-      @cfile.readlines(opts[:filename]).each do |line|
+      cfile.readlines(opts[:filename]).each.with_index do |line, _line_num|
         continue unless line
 
         if opts[:menu_blocks_with_headings]
@@ -644,73 +881,130 @@ module MarkdownExec
 
         if line.match(fenced_start_and_end_match)
           if in_block
-            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 fcb
+            #
+            fcb.name = fcb.title || ''
+            if fcb.body
+              if fcb.title.nil? || fcb.title.empty?
+                fcb.title = fcb.body.join(' ').gsub(/  +/, ' ')[0..64]
+              end
+
+              if block_given? && selected_messages.include?(:blocks) &&
+                 Filter.fcb_select?(opts, fcb)
+                yield :blocks, fcb
+              end
             end
             in_block = false
-            block_title = ''
           else
-            # start block
+            # start fcb
             #
-            lm = line.match(fenced_start_ex)
-            block_allow = false
-            if opts[:bash_only]
-              block_allow = true if lm && (lm[:shell] == 'bash')
-            else
-              block_allow = true
-              block_allow = !(lm && (lm[:shell] == 'expect')) if opts[:exclude_expect_blocks]
-            end
-
             in_block = true
-            if block_allow && (!opts[:title_match] || (lm && lm[:name] && lm[:name].match(opts[:title_match])))
-              block_body = []
-              block_title = (lm && lm[:name])
-            end
+
+            fcb_title_groups = line.match(fenced_start_ex).named_captures.sym_keys
+            fcb = FCB.new
+            fcb.headings = headings
+            fcb.name = fcb_title_groups.fetch(:name, '')
+            fcb.shell = fcb_title_groups.fetch(:shell, '')
+            fcb.title = fcb_title_groups.fetch(:name, '')
+
+            # selected fcb
+            #
+            fcb.body = []
+
+            rest = fcb_title_groups.fetch(:rest, '')
+            fcb.reqs = rest.scan(/\+[^\s]+/).map { |req| req[1..-1] }
+
+            fcb.call = rest.match(Regexp.new(opts[:block_calls_scan]))&.to_a&.first
+            fcb.stdin = if (tn = rest.match(/<(?<type>\$)?(?<name>[A-Za-z_-]\S+)/))
+                          tn.named_captures.sym_keys
+                        end
+            fcb.stdout = if (tn = rest.match(/>(?<type>\$)?(?<name>[A-Za-z_\-.\w]+)/))
+                           tn.named_captures.sym_keys
+                         end
           end
-        elsif block_body
-          block_body += [line.chomp]
+        elsif in_block && fcb.body
+          dp 'append line to fcb body'
+          fcb.body += [line.chomp]
         elsif block_given? && selected_messages.include?(:line)
-          # text outside of block
-          #
-          yield :line, nil, nil, line
+          dp 'text outside of fcb'
+          fcb = FCB.new
+          fcb.body = [line]
+          yield :line, fcb
         end
       end
     end
 
+    # return body, title if option.struct
+    # return body if not struct
+    #
     def list_blocks_in_file(call_options = {}, &options_block)
-      opts = optsmerge call_options, options_block
-
+      opts = optsmerge(call_options, options_block) #.tap_yaml 'opts'
       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: ''
-        }]
+        blocks.push FCB.new({
+                              # name: '',
+                              chrome: true,
+                              text: format(
+                                opts[:menu_divider_format],
+                                opts[:menu_initial_divider]
+                              ).send(opts[:menu_divider_color].to_sym),
+                              disabled: '' # __LINE__.to_s
+                            })
       end
-      iter_blocks_in_file(opts) do |btype, headings, block_title, body|
+
+      iter_blocks_in_file(opts) do |btype, fcb|
+        # binding.pry
         case btype
         when :filter
+          ## return type of blocks to select
+          #
           %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: '' }]
+          ## convert line to block
+          #
+          # binding.pry
+          if opts[:menu_divider_match].present? &&
+             (mbody = fcb.body[0].match opts[:menu_divider_match])
+            # binding.pry
+            blocks.push FCB.new(
+              { chrome: true,
+                disabled: '',
+                text: format(opts[:menu_divider_format],
+                             mbody[:name]).send(opts[:menu_divider_color].to_sym) }
+            )
+          elsif opts[:menu_task_match].present? &&
+                (mbody = fcb.body[0].match opts[:menu_task_match])
+            blocks.push FCB.new(
+              { chrome: true,
+                disabled: '',
+                text: format(opts[:menu_task_format],
+                             mbody[:name]).send(opts[:menu_task_color].to_sym) }
+            )
+          else
+            # line not added
           end
         when :blocks
-          blocks += get_block_summary opts, headings: headings, block_title: block_title, block_body: body
+          ## enhance fcb with block summary
+          #
+          blocks.push get_block_summary(opts, fcb) ### if Filter.fcb_select? opts, fcb
         end
       end
+
       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: ''
-        }]
+        blocks.push FCB.new(
+          { chrome: true,
+            disabled: '',
+            text: format(opts[:menu_divider_format],
+                         opts[:menu_final_divider])
+                                 .send(opts[:menu_divider_color].to_sym) }
+        )
       end
-      blocks.tap_yaml
+      blocks.tap_inspect
+    rescue StandardError => err
+      warn(error = "ERROR ** MarkParse.list_blocks_in_file(); #{err.inspect}")
+      warn(caller[0..4])
+      raise StandardError, error
     end
 
     def list_default_env
@@ -741,77 +1035,77 @@ module MarkdownExec
         specified_folder: options[:path],
         default_filename: 'README.md',
         default_folder: '.'
-      ).tap_inspect
+      )
     end
 
     # :reek:LongParameterList
     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?
-                       # 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).tap_inspect name: :fn
+                     end)
       if filetree
-        filetree.select { |filename| filename == fn || filename.match(/^#{fn}$/) || filename.match(%r{^#{fn}/.+$}) }
+        filetree.select do |filename|
+          filename == fn || filename.match(/^#{fn}$/) || filename.match(%r{^#{fn}/.+$})
+        end
       else
         Dir.glob(fn)
-      end.tap_inspect
+      end
     end
 
     def list_markdown_files_in_path
-      Dir.glob(File.join(@options[:path], @options[:md_filename_glob])).tap_inspect
+      Dir.glob(File.join(@options[:path],
+                         @options[:md_filename_glob]))
     end
 
-    def list_named_blocks_in_file(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)
-
-      list_blocks_in_file(opts).map do |block|
-        next if mdoc.hide_menu_block_per_options(opts, block)
-
-        block
-      end.compact.tap_inspect
+    def blocks_per_opts(blocks, opts)
+      if opts[:struct]
+        blocks
+      else
+        # blocks.map(&:name)
+        blocks.map do |block|
+          block.fetch(:text, nil) || block.fetch(:name, nil)
+        end
+      end.compact.reject(&:empty?).tap_inspect
     end
 
-    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
+    ## output type (body string or full object) per option struct and bash
+    #
+    def list_named_blocks_in_file(call_options = {}, &options_block)
+      opts = optsmerge call_options, options_block
 
-    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)
+      blocks = list_blocks_in_file(opts.merge(struct: true)).select do |fcb|
+        # fcb.fetch(:name, '') != '' && Filter.fcb_select?(opts, fcb)
+        Filter.fcb_select?(opts.merge(no_chrome: true), fcb)
+      end
+      blocks_per_opts(blocks, opts).tap_inspect
     end
 
     def make_block_labels(call_options = {})
       opts = options.merge(call_options)
-      list_blocks_in_file(opts).map do |block|
+      list_blocks_in_file(opts).map do |fcb|
         BlockLabel.new(filename: opts[:filename],
-                       headings: block.fetch(:headings, []),
+                       headings: fcb.fetch(:headings, []),
                        menu_blocks_with_docname: opts[:menu_blocks_with_docname],
                        menu_blocks_with_headings: opts[:menu_blocks_with_headings],
-                       title: block[:title]).make
-      end.compact.tap_inspect
+                       title: fcb[:title],
+                       text: fcb[:text],
+                       body: fcb[:body]).make
+      end.compact
     end
 
     # :reek:DuplicateMethodCall
@@ -845,7 +1139,9 @@ module MarkdownExec
                           fout options.sort_by_key.to_yaml
                         }
                       when 'val_as_bool'
-                        ->(value) { value.class.to_s == 'String' ? (value.chomp != '0') : value }
+                        lambda { |value|
+                          value.instance_of?(::String) ? (value.chomp != '0') : value
+                        }
                       when 'val_as_int'
                         ->(value) { value.to_i }
                       when 'val_as_str'
@@ -864,22 +1160,22 @@ module MarkdownExec
     end
 
     def menu_for_blocks(menu_options)
-      options = default_options.merge menu_options
+      options = calculated_options.merge menu_options
       menu = []
-      iter_blocks_in_file(options) do |btype, headings, block_title, body|
+      iter_blocks_in_file(options) do |btype, fcb|
         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: '' }]
+          if options[:menu_divider_match] &&
+             (mbody = fcb.body[0].match(options[:menu_divider_match]))
+            menu.push FCB.new({ 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]]
+          menu += [fcb.name]
         end
       end
-      menu.tap_yaml
+      menu
     end
 
     def menu_iter(data = menu_for_optparse, &block)
@@ -894,17 +1190,17 @@ module MarkdownExec
       return unless item[:long_name].present? || item[:short_name].present?
 
       opts.on(*[
-        # long name
+        # - long name
         if item[:long_name].present?
           "--#{item[:long_name]}#{item[:arg_name].present? ? " #{item[:arg_name]}" : ''}"
         end,
 
-        # short name
+        # - short name
         item[:short_name].present? ? "-#{item[:short_name]}" : nil,
 
-        # description and default
+        # - description and default
         [item[:description],
-         item[:default].present? ? "[#{value_for_cli item[:default]}]" : nil].compact.join('  '),
+         ("[#{value_for_cli item[:default]}]" if item[:default].present?)].compact.join('  '),
 
         # apply proccode, if present, to value
         # save value to options hash if option is named
@@ -981,6 +1277,10 @@ module MarkdownExec
       }
     end
 
+    ## tty prompt to select
+    # insert exit option at head or tail
+    # return selected option or nil
+    #
     def prompt_with_quit(prompt_text, items, opts = {})
       exit_option = '* Exit'
       all_items = if @options[:menu_exit_at_top]
@@ -1002,28 +1302,14 @@ module MarkdownExec
 
     # :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
 
       ## read local configuration file
       #
-      read_configuration_file! @options, ".#{MarkdownExec::APP_NAME.downcase}.yml"
+      read_configuration_file! @options,
+                               ".#{MarkdownExec::APP_NAME.downcase}.yml"
 
       @option_parser = option_parser = OptionParser.new do |opts|
         executable_name = File.basename($PROGRAM_NAME)
@@ -1034,28 +1320,35 @@ module MarkdownExec
         ].join("\n")
 
         menu_iter do |item|
-          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)
+      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
+      # child_argv = arguments_for_child
+      rest = option_parser.parse!(arguments_for_mde) # (into: options)
 
       begin
         options_finalize rest
         exec_block options, options[:block_name]
-      rescue FileMissingError => e
-        puts "File missing: #{e}"
+      rescue FileMissingError => err
+        puts "File missing: #{err}"
       end
+    rescue StandardError => err
+      warn(error = "ERROR ** MarkParse.run(); #{err.inspect}")
+      binding.pry if $tap_enable
+      raise ArgumentError, error
     end
 
     def saved_name_split(name)
-      mf = name.match(/#{@options[:saved_script_filename_prefix]}_(?<time>[0-9\-]+)_(?<file>.+)_,_(?<block>.+)\.sh/)
+      # rubocop:disable Layout/LineLength
+      mf = /#{@options[:saved_script_filename_prefix]}_(?<time>[0-9\-]+)_(?<file>.+)_,_(?<block>.+)\.sh/.match name
+      # rubocop:enable Layout/LineLength
       return unless mf
 
-      @options[:block_name] = mf[:block].tap_inspect name: :options_block_name
-      @options[:filename] = mf[:file].gsub(FNR12, FNR11).tap_inspect name: :options_filename
+      @options[:block_name] = mf[:block]
+      @options[:filename] = mf[:file].gsub(FNR12, FNR11)
     end
 
     def run_last_script
@@ -1065,11 +1358,10 @@ module MarkdownExec
 
       saved_name_split filename
       @options[:save_executed_script] = false
-      select_and_approve_block
+      select_approve_and_execute_block({})
     end
 
     def save_execution_output
-      @options.tap_inspect name: :options
       return unless @options[:save_execution_output]
 
       @options[:logged_stdout_filename] =
@@ -1078,10 +1370,12 @@ module MarkdownExec
                        prefix: @options[:logged_stdout_filename_prefix],
                        time: Time.now.utc).stdout_name
 
-      @options[:logged_stdout_filespec] = File.join @options[:saved_stdout_folder], @options[:logged_stdout_filename]
+      @options[:logged_stdout_filespec] =
+        File.join @options[:saved_stdout_folder],
+                  @options[:logged_stdout_filename]
       @logged_stdout_filespec = @options[:logged_stdout_filespec]
-      (dirname = File.dirname(@options[:logged_stdout_filespec])).tap_inspect name: :dirname
-      Dir.mkdir dirname unless File.exist?(dirname)
+      (dirname = File.dirname(@options[:logged_stdout_filespec]))
+      Dir.mkdir_p dirname
 
       ol = ["-STDOUT-\n"]
       ol += @execute_files&.fetch(EF_STDOUT, [])
@@ -1093,40 +1387,61 @@ module MarkdownExec
       File.write(@options[:logged_stdout_filespec], ol.join)
     end
 
-    def select_and_approve_block(call_options = {}, &options_block)
+    def select_approve_and_execute_block(call_options, &options_block)
       opts = optsmerge call_options, options_block
-      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
+      blocks_in_file = list_blocks_in_file(opts.merge(struct: true)).tap_inspect
+      mdoc = MDoc.new(blocks_in_file) do |nopts|
+        opts.merge!(nopts)
+      end
+      blocks_menu = mdoc.fcbs_per_options(opts.merge(struct: true))
 
       repeat_menu = true && !opts[:block_name].present?
       loop do
         unless opts[:block_name].present?
           pt = (opts[:prompt_select_block]).to_s
 
-          blocks_menu.each do |block|
-            next if block.fetch(:disabled, false)
-
-            block.merge! label:
-            BlockLabel.new(filename: opts[:filename],
-                           headings: block.fetch(:headings, []),
-                           menu_blocks_with_docname: opts[:menu_blocks_with_docname],
-                           menu_blocks_with_headings: opts[:menu_blocks_with_headings],
-                           title: block[:title]).make
-          end
-          return nil if blocks_menu.count.zero?
-
-          sel = prompt_with_quit pt, blocks_menu, per_page: opts[:select_page_height]
+          bm = blocks_menu.map do |fcb|
+            # next if fcb.fetch(:disabled, false)
+            # next unless fcb.fetch(:name, '').present?
+
+            fcb.merge!(
+              label: BlockLabel.new(
+                body: fcb[:body],
+                filename: opts[:filename],
+                headings: fcb.fetch(:headings, []),
+                menu_blocks_with_docname: opts[:menu_blocks_with_docname],
+                menu_blocks_with_headings: opts[:menu_blocks_with_headings],
+                text: fcb[:text],
+                title: fcb[:title]
+              ).make
+            )
+
+            fcb.to_h
+          end.compact
+          return nil if bm.count.zero?
+
+          # binding.pry
+
+          sel = prompt_with_quit pt, bm,
+                                 per_page: opts[:select_page_height]
           return nil if sel.nil?
 
-          label_block = blocks_in_file.select { |block| block[:label] == sel }.fetch(0, nil)
-          opts[:block_name] = @options[:block_name] = label_block[:name]
+          ## store selected option
+          #
+          label_block = blocks_in_file.select do |fcb|
+            fcb[:label] == sel
+          end.fetch(0, nil)
+          opts[:block_name] = @options[:block_name] = label_block.fetch(:name, '')
         end
-        approve_block opts, mdoc
+        approve_and_execute_block opts, mdoc
         break unless repeat_menu
 
         opts[:block_name] = ''
       end
+    rescue StandardError => err
+      warn(error = "ERROR ** MarkParse.select_approve_and_execute_block(); #{err.inspect}")
+      binding.pry if $tap_enable
+      raise ArgumentError, error
     end
 
     def select_md_file(files = list_markdown_files_in_path)
@@ -1134,7 +1449,8 @@ module MarkdownExec
       if (count = files.count) == 1
         files[0]
       elsif count >= 2
-        prompt_with_quit opts[:prompt_select_md].to_s, files, per_page: opts[:select_page_height]
+        prompt_with_quit opts[:prompt_select_md].to_s, files,
+                         per_page: opts[:select_page_height]
       end
     end
 
@@ -1167,15 +1483,11 @@ module MarkdownExec
 
       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 }
+      select_approve_and_execute_block({
+                                         bash: true,
+                                         save_executed_script: false,
+                                         struct: true
+                                       })
     end
 
     def menu_export(data = menu_for_optparse)
@@ -1199,7 +1511,7 @@ module MarkdownExec
       else
         @options.merge! opts
       end
-      @options.tap_yaml
+      @options
     end
 
     def write_command_file(call_options, required_blocks)
@@ -1218,7 +1530,7 @@ module MarkdownExec
           File.join opts[:saved_script_folder], opts[:saved_script_filename]
 
       dirname = File.dirname(@options[:saved_filespec])
-      Dir.mkdir dirname unless File.exist?(dirname)
+      Dir.mkdir_p dirname
       (shebang = if @options[:shebang]&.present?
                    "#{@options[:shebang]} #{@options[:shell]}\n"
                  else