markdown_exec 3.0.8 → 3.1.0

data/lib/hash_delegator.rb

@@ -954,7 +954,7 @@ module MarkdownExec
                 blocks << fcb unless result.failure?
               end
             rescue StandardError
-              # ww $@, $!
+              ww $@, $!, caller.deref
               HashDelegator.error_handler('blocks_from_nested_files',
                                           { abort: true })
             end
@@ -978,8 +978,8 @@ module MarkdownExec
       end
       OpenStruct.new(blocks: blocks, results: results)
     rescue StandardError
-      # ww $@, $!
-      HashDelegator.error_handler('blocks_from_nested_files')
+      wwe 'link_state:', link_state, 'source_id:', source_id, 'btype:', btype,
+          'fcb:', fcb
     end
 
     def build_menu_options(exit_option, display_mode_option,
@@ -994,9 +994,6 @@ module MarkdownExec
       initial_code_required: false,
       occurrence_expressions: nil
     )
-ww commands
-ww link_state
-# binding.irb####
       evaluate_shell_expressions(
         (link_state&.inherited_lines_block || ''),
         commands,
@@ -1113,24 +1110,26 @@ ww link_state
       selected, mdoc, inherited_code: nil, force: true, only_default: false,
       silent:
     )
-ww selected
+      wwt :fcb, 'ux block with code', selected
       ret_command_result = nil
       exit_prompt = @delegate_object[:prompt_filespec_back]
 
-ww \
       required = mdoc.collect_recursively_required_code(
         anyname: selected.pub_name,
         label_format_above: @delegate_object[:shell_code_label_format_above],
         label_format_below: @delegate_object[:shell_code_label_format_below],
         block_source: block_source
       )
+      wwt :required, required
 
       # process each ux block in sequence, setting ENV and collecting lines
       required_lines = []
       required[:blocks].each do |block|
         next unless block.type == BlockType::UX
 
-        case data = YAML.load(block.body.join("\n"))
+        wwt :fcb, 'a required block', block
+
+        case data = safe_yaml_load(block.body.join("\n"))
         when Hash
           export = parse_yaml_of_ux_block(
             data,
@@ -1171,19 +1170,8 @@ ww \
           return command_result_w_e_t_nl if command_result_w_e_t_nl.failure?
 
           command_result_w_e_t_nl.new_lines =
-            command_result_w_e_t_nl.new_lines.map do |name_force|
-              transformed = if command_result_w_e_t_nl.transformable
-                              transform_export_value(name_force[:text], export)
-                            else
-                              name_force[:text]
-
-                            end
-              EnvInterface.set(name_force[:name], transformed)
-
-              code_line_safe_assign(
-                name_force[:name], transformed, force: name_force[:force]
-              )
-            end
+            process_command_result_lines(command_result_w_e_t_nl, export,
+                                         required_lines)
           required_lines.concat(command_result_w_e_t_nl.new_lines)
           ret_command_result = command_result_w_e_t_nl
         else
@@ -1191,24 +1179,23 @@ ww \
         end
       end
 
-      ret_command_result || CommandResult.new(stdout: required_lines)
+      (ret_command_result || CommandResult.new(stdout: required_lines)).tap do |ret|
+        wwt :cr, ret
+      end
     rescue StandardError
-      ww $@, $!
-      HashDelegator.error_handler('code_from_ux_block_to_set_environment_variables')
-    end
-
-    def env_set(name, value)
-      EnvInterface.set(name, value)
+      wwe 'selected:', selected, 'required:', required, 'block:', block,
+          'data:', data
     end
 
     # sets ENV
     def code_from_vars_block_to_set_environment_variables(selected)
       code_lines = []
+      # code_lines << '# code_from_vars_block_to_set_environment_variables'
       case data = YAML.load(selected.body.join("\n"))
       when Hash
         data.each do |key, value|
           EnvInterface.set(key, value.to_s)
-          code_lines.push "#{key}=#{Shellwords.escape(value)}"
+          code_lines << assign_key_value_in_bash(key, value)
 
           next unless @delegate_object[:menu_vars_set_format].present?
 
@@ -1218,9 +1205,14 @@ ww \
         end
       end
       code_lines
+    rescue StandardError
+      wwe 'selected:', selected, 'data:', data, 'key:', key, 'value:', value,
+          'code_lines:', code_lines, 'formatted_string:', formatted_string
     end
 
-    def code_line_safe_assign(name, value, force:)
+    # make a single line of shell code to assign an escaped value to a variable
+    # force/default
+    def code_line_to_assign_a_variable(name, value, force:)
       if force
         "#{name}=#{Shellwords.escape(value)}"
       else
@@ -1232,11 +1224,15 @@ ww \
       extract_patterns = lambda do |key|
         return [] unless delegate_object[key].present?
 
-        HashDelegator.safeval(delegate_object[key]).map do |pc|
-          {
-            color_method: pc[:color_method].to_sym,
-            pattern: Regexp.new(pc[:pattern])
-          }
+        begin
+          (value = HashDelegator.safeval(delegate_object[key])).map do |pc|
+            {
+              color_method: pc[:color_method].to_sym,
+              pattern: Regexp.new(pc[:pattern])
+            }
+          end
+        rescue StandardError
+          wwe({ error: $!, callback: $@[0], key: key, value: value })
         end
       end
 
@@ -1706,10 +1702,6 @@ ww \
       @prior_execution_block = nil
     end
 
-    def selected_shell(shell_name)
-      shell_name.empty? ? shell : shell_name
-    end
-
     # Determines the state of a selected block in the menu based
     #  on the selected option.
     # It categorizes the selected option into either EXIT, BACK,
@@ -1932,6 +1924,10 @@ ww \
       result_text
     end
 
+    def env_set(name, value)
+      EnvInterface.set(name, value)
+    end
+
     # Execute a code block after approval and provide user interaction options.
     #
     # This method displays required code blocks, asks for user approval, and
@@ -1977,8 +1973,9 @@ ww \
 
       elsif selected.type == BlockType::LOAD
         debounce_reset
-        code_lines = execute_block_type_load_code_lines(selected)
-        next_state_append_code(selected, link_state, code_lines)
+        load_result = execute_block_type_load_code_lines(selected)
+        next_state_append_code(selected, link_state, load_result.code,
+                               mode: load_result.mode)
 
       elsif selected.type == BlockType::SAVE
         debounce_reset
@@ -2176,10 +2173,10 @@ ww \
       # load key and values from link block into current environment
       #
       if link_block_data[LinkKeys::VARS]
-        code_lines.push BashCommentFormatter.format_comment(selected.pub_name)
-        (link_block_data[LinkKeys::VARS] || []).each do |(key, value)|
+        code_lines << BashCommentFormatter.format_comment(selected.pub_name)
+        link_block_data[LinkKeys::VARS].each do |key, value|
+          code_lines << assign_key_value_in_bash(key, value)
           EnvInterface.set(key, value.to_s)
-          code_lines.push(assign_key_value_in_bash(key, value))
         end
       end
 
@@ -2202,7 +2199,7 @@ ww \
       if link_block_data.fetch(LinkKeys::EVAL,
                                false) || link_block_data.fetch(LinkKeys::EXEC,
                                                                false)
-        code_lines = link_block_data_eval(
+        code_lines += link_block_data_eval(
           link_state, code_lines, selected, link_block_data,
           block_source: block_source,
           shell: @delegate_object[:block_type_default]
@@ -2265,38 +2262,54 @@ ww \
       )
       dirs.sort_by! { |f| File.mtime(f) }.reverse!
 
-      if !contains_glob?(block_data['directory']) &&
-         !contains_glob?(block_data['glob'])
-        if dirs[0]
-          File.readlines(dirs[0], chomp: true)
-        else
-          warn 'No matching file found.'
-        end
-      elsif (selected_option = select_option_with_metadata(
-        prompt_title,
-        [exit_prompt] + dirs.map do |file| # tty_menu_items
-          { name:
-              format(
-                block_data['view'] || view,
-                NamedCaptureExtractor.extract_named_group_match_data(
-                  file.match(
-                    Regexp.new(block_data['filename_pattern'] || filename_pattern)
-                  )
-                )
-              ),
-            oname: file }
-        end,
-        menu_options.merge(
-          cycle: true,
-          match_dml: false
-        )
-      ))
-        if selected_option.dname != exit_prompt
-          File.readlines(selected_option.oname, chomp: true)
+      code = if !contains_glob?(block_data['directory']) &&
+                !contains_glob?(block_data['glob'])
+               if dirs[0]
+                 File.readlines(dirs[0], chomp: true)
+               else
+                 warn 'No matching file found.'
+               end
+             elsif (selected_option = select_option_with_metadata(
+               prompt_title,
+               [exit_prompt] + dirs.map do |file| # tty_menu_items
+                 { name:
+                     format(
+                       block_data['view'] || view,
+                       NamedCaptureExtractor.extract_named_group_match_data(
+                         file.match(
+                           Regexp.new(block_data['filename_pattern'] || filename_pattern)
+                         )
+                       )
+                     ),
+                   oname: file }
+               end,
+               menu_options.merge(
+                 cycle: true,
+                 match_dml: false
+               )
+             ))
+               if selected_option.dname != exit_prompt
+                 File.readlines(selected_option.oname, chomp: true)
+               end
+             else
+               warn 'No matching files found.'
+             end
+
+      if (mode = block_data['mode']&.to_sym)
+        reason = 'specified Load mode'
+        unless [LoadMode::APPEND, LoadMode::REPLACE].include? mode
+          wwe 'Invalid mode', 'block_data:', block_data
         end
       else
-        warn 'No matching files found.'
+        reason = 'default Load mode'
+        mode = LoadMode::APPEND
       end
+
+      OpenStruct.new(
+        code: code,
+        mode: mode,
+        reason: reason
+      )
     end
 
     # Collects required code lines based on the selected block and
@@ -2540,7 +2553,7 @@ ww \
     end
 
     def expand_references!(fcb, link_state)
-ww fcb, link_state, caller.deref
+      # options expansions
       expand_variable_references!(
         blocks: [fcb],
         echo_formatter: method(:format_echo_command),
@@ -2583,22 +2596,15 @@ ww fcb, link_state, caller.deref
       link_state:,
       pattern:
     )
-ww blocks####
-ww link_state
-# binding.irb
       variable_counts, occurrence_expressions = count_named_group_occurrences(
         blocks, pattern, group_name: group_name
       )
       return if variable_counts.nil? || variable_counts == {}
-ww [variable_counts, occurrence_expressions]
 
-ww \
       echo_commands = generate_echo_commands(
         variable_counts, formatter: echo_formatter
       )
 
-ww link_state
-ww \
       replacements = build_replacement_dictionary(
         echo_commands, link_state,
         initial_code_required: initial_code_required,
@@ -2608,11 +2614,9 @@ ww \
       return if replacements.nil?
       if replacements == EvaluateShellExpression::StatusFail
         # happens on first processing of blocks before requirements are met
-        ww "EvaluateShellExpression::StatusFail", echo_commands, link_state
         return
       end
 
-ww \
       expand_blocks_with_replacements(blocks, replacements)
       # no return
     end
@@ -2620,17 +2624,20 @@ ww \
     def export_echo_with_code(
       bash_script_lines, export, force:, silent:, string: nil
     )
+      wwp
       exportable = true
       command_result = nil
       new_lines = []
       export_string = string.nil? ? export.echo : string
       case export_string
       when String, Integer, Float, TrueClass, FalseClass
-        command_result, exportable, new_lines = output_from_adhoc_bash_script_file(
+        command_result, exportable, = output_from_adhoc_bash_script_file(
           join_array_of_arrays(
             bash_script_lines,
             %(printf '%s' "#{export_string}")
-          )
+          ),
+          export,
+          force: force
         )
         if command_result.exit_status == EXIT_STATUS_REQUIRED_EMPTY
           exportable = false
@@ -2648,7 +2655,9 @@ ww \
             join_array_of_arrays(
               bash_script_lines,
               %(printf '%s' "#{expression}")
-            )
+            ),
+            export,
+            force: force
           )
           if command_result.exit_status == EXIT_STATUS_REQUIRED_EMPTY
             command_result.warning = warning_required_empty(export) unless silent
@@ -3015,7 +3024,11 @@ ww \
     # convert single items to arrays
     def join_array_of_arrays(*args)
       args.map do |item|
-        item.nil? ? nil : (item.is_a?(Array) ? item : [item])
+        if item.nil?
+          nil
+        else
+          (item.is_a?(Array) ? item : [item])
+        end
       end.compact.flatten(1)
     end
 
@@ -3549,12 +3562,13 @@ ww \
       list[(index + 1) % list.size] # Get the next item, wrap around if at the end
     end
 
-    def next_state_append_code(selected, link_state, code_lines)
+    def next_state_append_code(selected, link_state, code_lines,
+                               mode: LoadMode::APPEND)
       next_state_set_code(
         selected,
         link_state,
         HashDelegator.flatten_and_compact_arrays(
-          link_state&.inherited_lines,
+          mode == LoadMode::APPEND ? link_state&.inherited_lines : [],
           code_lines.is_a?(Array) ? code_lines : [] # no code for :ux_exec_prohibited
         )
       )
@@ -3616,7 +3630,8 @@ ww \
 
     def output_from_adhoc_bash_script_file(
       bash_script_lines,
-      export = nil
+      export = nil,
+      force:
     )
       Tempfile.create('script_exec') do |temp_file|
         temp_file.write(
@@ -3637,25 +3652,22 @@ ww \
 
         output = `#{shell} #{temp_file.path}`
 
-        exportable = export ? export.exportable : false
+        exportable = if export&.exportable.nil?
+                       true
+                     else
+                       (export ? export.exportable : false)
+                     end
         new_lines = []
-        if export
-          new_lines << "#{export.name}="
-          export_value = output
-          ### transform?
+        # new_lines << { comment: 'output_from_adhoc_bash_script_file' }
 
-          command_result, exportable, new_lines = export_echo_with_code(
-            ["#{export.name}=#{Shellwords.escape(export_value)}"],
-            export,
-            force: force,
-            silent: silent,
-            string: export_value
-          )
-        else
-          command_result = CommandResult.new(
-            stdout: output,
-            exit_status: $?.exitstatus
-          )
+        command_result = CommandResult.new(
+          stdout: output,
+          exit_status: $?.exitstatus
+        )
+        exportable &&= command_result.success?
+        if exportable
+          new_lines << { name: export.name, force: force,
+                         text: command_result.stdout }
         end
 
         [
@@ -3665,6 +3677,7 @@ ww \
         ]
       end
     rescue StandardError => err
+      # wwe 'bash_script_lines:', bash_script_lines, 'export:', export
       warn "Error executing script: #{err.message}"
       nil
     end
@@ -3811,6 +3824,35 @@ ww \
 
     # private
 
+    def process_command_result_lines(command_result_w_e_t_nl, export,
+                                     required_lines)
+      command_result_w_e_t_nl.new_lines.map do |name_force|
+        comment = name_force.fetch(:comment, '')
+        name = name_force.fetch(:name, '')
+        if name.empty?
+          "# #{comment}" unless comment.empty?
+        else
+          transformed = if command_result_w_e_t_nl.transformable
+                          transform_export_value(name_force[:text], export)
+                        else
+                          name_force[:text]
+                        end
+
+          # store the transformed value in ENV
+          EnvInterface.set(name, transformed)
+
+          set = code_line_to_assign_a_variable(
+            name, transformed, force: name_force[:force]
+          )
+
+          comment.empty? ? set : "#{set} # #{comment}"
+        end
+      end
+    rescue StandardError
+      ww $@, $!, caller.deref
+      raise StandardError, $!
+    end
+
     def process_string_array(arr, begin_pattern: nil, end_pattern: nil, scan1: nil,
                              format1: nil, name: '')
       in_block = !begin_pattern.present?
@@ -4440,6 +4482,10 @@ ww \
       selected
     end
 
+    def selected_shell(shell_name)
+      shell_name.empty? ? shell : shell_name
+    end
+
     def shell
       @delegate_object[:shell]
     end
@@ -4575,7 +4621,6 @@ ww \
       return value unless export.transform.present?
 
       if export.transform.is_a? Symbol
-        ### TBD validate for symbol
         value.send(export.transform)
       else
         format(
@@ -4679,7 +4724,7 @@ ww \
     )
       command_result = nil
       exportable = true
-      force = true
+      force = export.force.nil? ? true : export.force
       new_lines = []
       silent = false
       transformable = true
@@ -4713,7 +4758,9 @@ ww \
 
         when :exec, UxActSource::EXEC
           command_result, = output_from_adhoc_bash_script_file(
-            join_array_of_arrays(bash_script_lines, export.exec)
+            join_array_of_arrays(bash_script_lines, export.exec),
+            export,
+            force: force
           )
 
           if command_result.exit_status == EXIT_STATUS_REQUIRED_EMPTY
@@ -4729,7 +4776,7 @@ ww \
         else
           export_init = menu_from_list_with_back(export.allow)
           command_result, exportable, new_lines = export_echo_with_code(
-            ["#{export.name}=#{Shellwords.escape(export_init)}"],
+            [assign_key_value_in_bash(export.name, export_init)],
             export,
             force: force,
             silent: silent,
@@ -4739,6 +4786,7 @@ ww \
         end
 
       when :echo, UxActSource::ECHO
+        wwp
         command_result, exportable, new_lines = export_echo_with_code(
           bash_script_lines,
           export,
@@ -4747,7 +4795,7 @@ ww \
         )
 
       when :edit, UxActSource::EDIT
-        output = nil
+        output = ''
         begin
           loop do
             print "#{export.prompt} [#{export.default}]: "
@@ -4764,12 +4812,18 @@ ww \
           transformable = false
         end
 
+        if exportable
+          EnvInterface.set(export.name, output)
+          new_lines << { name: export.name, force: force,
+                         text: output }
+        end
         command_result = CommandResult.new(stdout: output)
 
       when :exec, UxActSource::EXEC
         command_result, exportable, new_lines = output_from_adhoc_bash_script_file(
           join_array_of_arrays(bash_script_lines, export.exec),
-          export
+          export,
+          force: force
         )
 
       else
@@ -4794,7 +4848,7 @@ ww \
     )
       command_result = nil
       exportable = true
-      force = false
+      force = export.force.nil? ? false : export.force
       new_lines = []
       silent = true
       transformable = true
@@ -4815,11 +4869,12 @@ ww \
               bash_script_lines,
               %(printf '%s' "#{export.echo}")
             ),
-            export
+            export,
+            force: force
           )
           export_init = cr_echo.stdout.split("\n").first
           command_result, exportable, new_lines = export_echo_with_code(
-            ["#{export.name}=#{Shellwords.escape(export_init)}"],
+            [assign_key_value_in_bash(export.name, export_init)],
             export,
             force: force,
             silent: silent,
@@ -4830,12 +4885,13 @@ ww \
           # extract first line from 'exec' output
           command_result, exportable, new_lines = output_from_adhoc_bash_script_file(
             join_array_of_arrays(bash_script_lines, export.exec),
-            export
+            export,
+            force: force
           )
           unless command_result.failure?
             export_init = command_result.stdout.split("\n").first
             command_result, exportable, new_lines = export_echo_with_code(
-              ["#{export.name}=#{Shellwords.escape(export_init)}"],
+              [assign_key_value_in_bash(export.name, export_init)],
               export,
               force: force,
               silent: silent,
@@ -4847,7 +4903,7 @@ ww \
           # first item from 'allow' list
           export_init = export.allow.first
           command_result, exportable, new_lines = export_echo_with_code(
-            ["#{export.name}=#{Shellwords.escape(export_init)}"],
+            [assign_key_value_in_bash(export.name, export_init)],
             export,
             force: force,
             silent: silent,
@@ -4869,18 +4925,20 @@ ww \
           force: force,
           silent: silent
         )
+
       when :exec, UxActSource::EXEC
         raise unless export.exec.present?
 
         command_result, exportable, new_lines = output_from_adhoc_bash_script_file(
           join_array_of_arrays(bash_script_lines, export.exec),
-          export
+          export,
+          force: force
         )
 
       else
         export_init = export.init.to_s
         command_result, exportable, new_lines = export_echo_with_code(
-          ["#{export.name}=#{Shellwords.escape(export_init)}"],
+          [assign_key_value_in_bash(export.name, export_init)],
           export,
           force: force,
           silent: silent,
@@ -5337,7 +5395,6 @@ ww \
         mdoc_menu_and_blocks_from_nested_files(
           @dml_link_state, source_id: source_id
         )
-ww @dml_link_state####
       dump_delobj(@dml_blocks_in_file, @dml_menu_blocks, @dml_link_state)
     end
 
@@ -5541,6 +5598,16 @@ ww @dml_link_state####
         link_block_data[LinkKeys::FILE] || @delegate_object[:filename]
       end
     end
+
+    def safe_yaml_load(body)
+      return {} unless body&.present?
+
+      YAML.load(body.to_s)
+    rescue Psych::SyntaxError => err
+      wwe 'YAML parsing error', { body: body, error: err.message }
+    rescue StandardError => err
+      wwe 'YAML loading error', { body: body, error: err.message }
+    end
   end
 
   class HashDelegator < HashDelegatorParent
@@ -5884,7 +5951,7 @@ module MarkdownExec
         mdoc: @mdoc, selected: @selected, block_source: {}
       )
 
-      assert_equal ['code line', 'key=value'], result
+      assert_equal ['code line', 'key="value"'], result
     end
   end
 

data/lib/markdown_exec/version.rb

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

data/lib/mdoc.rb

@@ -178,11 +178,12 @@ module MarkdownExec
                 collect_block_code_stdout(fcb)
               elsif [BlockType::OPTS].include? fcb.type
                 fcb.body # entire body is returned to requesing block
+
               elsif [BlockType::LINK,
                      BlockType::LOAD,
                      BlockType::UX,
                      BlockType::VARS].include? fcb.type
-                nil
+                nil # Vars for all types are collected later
               elsif fcb[:chrome] # for Link blocks like History
                 nil
               elsif fcb.type == BlockType::PORT