markdown_exec 3.0.4 → 3.0.6

data/lib/hash_delegator.rb

@@ -44,6 +44,7 @@ require_relative 'string_util'
 require_relative 'table_extractor'
 require_relative 'text_analyzer'
 require_relative 'value_or_exception'
+require_relative 'env_interface'
 
 $pd = false unless defined?($pd)
 $table_cell_truncate = true
@@ -96,10 +97,6 @@ module HashDelegatorSelf
     blocks.select { |item| item.send(msg) == value }
   end
 
-  def code_merge(*bodies)
-    merge_lists(*bodies)
-  end
-
   def count_matches_in_lines(lines, regex)
     lines.count { |line| line.to_s.match(regex) }
   end
@@ -157,6 +154,14 @@ module HashDelegatorSelf
     )
   end
 
+  # Takes multiple arrays as arguments, flattens them into a single array, and removes nil values.
+  # @param args [Array<Array>] Variable number of arrays to be processed
+  # @return [Array] A single flattened array with nil values removed, or an empty array if the result is empty
+  def flatten_and_compact_arrays(*args)
+    merged = args.compact.flatten
+    merged.empty? ? [] : merged
+  end
+
   # Indents all lines in a given string with a specified indentation string.
   # @param body [String] A multi-line string to be indented.
   # @param indent [String] The string used for indentation
@@ -177,13 +182,6 @@ module HashDelegatorSelf
     ((lines || []) + ['']).join("\n")
   end
 
-  def merge_lists(*args)
-    # Filters out nil values, flattens the arrays, and ensures an
-    #  empty list is returned if no valid lists are provided.
-    merged = args.compact.flatten
-    merged.empty? ? [] : merged
-  end
-
   def next_link_state(
     block_name_from_cli:, was_using_cli:, block_state:, block_name: nil
   )
@@ -501,10 +499,6 @@ class BashCommentFormatter
     end
     formatted.join("\n")
   end
-  # # fit oname in single bash comment
-  # def oname_for_bash_comment(oname)
-  #   oname.gsub("\n", ' ~ ').gsub(/  +/, ' ')
-  # end
 end
 
 class StringWrapper
@@ -1094,17 +1088,18 @@ module MarkdownExec
       @ux_most_recent_filename = @delegate_object[:filename]
 
       (blocks.each.with_object([]) do |block, merged_options|
-        command_result_w_e_t_nl = code_from_ux_block_to_set_environment_variables(
-          block,
-          mdoc,
-          force: @delegate_object[:ux_auto_load_force_default],
-          only_default: true,
-          silent: true
-        )
+        command_result_w_e_t_nl =
+          code_from_ux_block_to_set_environment_variables(
+            block,
+            mdoc,
+            force: @delegate_object[:ux_auto_load_force_default],
+            only_default: true,
+            silent: true
+          )
         if command_result_w_e_t_nl.failure?
           merged_options
         else
-          merged_options.push(command_result_w_e_t_nl.stdout)
+          merged_options.push(command_result_w_e_t_nl.new_lines)
         end
       end).to_a
     end
@@ -1115,6 +1110,7 @@ module MarkdownExec
       selected, mdoc, inherited_code: nil, force: true, only_default: false,
       silent:
     )
+      ret_command_result = nil
       exit_prompt = @delegate_object[:prompt_filespec_back]
 
       required = mdoc.collect_recursively_required_code(
@@ -1169,26 +1165,32 @@ module MarkdownExec
           end
           return command_result_w_e_t_nl if command_result_w_e_t_nl.failure?
 
-          required_lines.concat(command_result_w_e_t_nl.new_lines)
-          if SelectResponse.continue?(command_result_w_e_t_nl.stdout)
-            if command_result_w_e_t_nl.transformable
-              command_result_w_e_t_nl.stdout = transform_export_value(
-                command_result_w_e_t_nl.stdout, export
-              )
-            end
+          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]
 
-            if command_result_w_e_t_nl.exportable
-              ENV[export.name] = command_result_w_e_t_nl.stdout.to_s
-              required_lines.push code_line_safe_assign(export.name, command_result_w_e_t_nl.stdout,
-                                                        force: force)
+                            end
+              EnvInterface.set(name_force[:name], transformed)
+
+              code_line_safe_assign(
+                name_force[:name], transformed, force: name_force[:force]
+              )
             end
-          end
+          required_lines.concat(command_result_w_e_t_nl.new_lines)
+          ret_command_result = command_result_w_e_t_nl
         else
           raise "Invalid data type: #{data.inspect}"
         end
       end
 
-      CommandResult.new(stdout: required_lines)
+      ret_command_result || CommandResult.new(stdout: required_lines)
+    end
+
+    def env_set(name, value)
+      EnvInterface.set(name, value)
     end
 
     # sets ENV
@@ -1197,7 +1199,7 @@ module MarkdownExec
       case data = YAML.load(selected.body.join("\n"))
       when Hash
         data.each do |key, value|
-          ENV[key] = value.to_s
+          EnvInterface.set(key, value.to_s)
           code_lines.push "#{key}=#{Shellwords.escape(value)}"
 
           next unless @delegate_object[:menu_vars_set_format].present?
@@ -1891,7 +1893,7 @@ module MarkdownExec
       before_mtime = temp_file.mtime
 
       # Open the temporary file in the default editor
-      system("#{ENV['EDITOR'] || 'vi'} #{temp_file.path}")
+      system("#{EnvInterface.get('EDITOR', default: 'vi')} #{temp_file.path}")
 
       # Capture the exit status of the editor
       editor_exit_status = $?.exitstatus
@@ -2034,13 +2036,16 @@ module MarkdownExec
         next_state_append_code(
           selected,
           link_state,
-          command_result_w_e_t_nl.failure? ? [] : command_result_w_e_t_nl.stdout
+          command_result_w_e_t_nl.failure? ? [] : command_result_w_e_t_nl.new_lines
         )
 
       elsif selected.type == BlockType::VARS
         debounce_reset
-        next_state_append_code(selected, link_state,
-                               code_from_vars_block_to_set_environment_variables(selected))
+        next_state_append_code(
+          selected,
+          link_state,
+          code_from_vars_block_to_set_environment_variables(selected)
+        )
 
       elsif COLLAPSIBLE_TYPES.include?(selected.type)
         debounce_reset
@@ -2165,7 +2170,7 @@ module MarkdownExec
       if link_block_data[LinkKeys::VARS]
         code_lines.push BashCommentFormatter.format_comment(selected.pub_name)
         (link_block_data[LinkKeys::VARS] || []).each do |(key, value)|
-          ENV[key] = value.to_s
+          EnvInterface.set(key, value.to_s)
           code_lines.push(assign_key_value_in_bash(key, value))
         end
       end
@@ -2220,7 +2225,7 @@ module MarkdownExec
            ((link_state&.inherited_block_names || []) + block_names).sort.uniq,
           inherited_dependencies:
            (link_state&.inherited_dependencies || {}).merge(dependencies || {}), ### merge, not replace, key data
-          inherited_lines: HashDelegator.code_merge(
+          inherited_lines: HashDelegator.flatten_and_compact_arrays(
             link_state&.inherited_lines, code_lines
           ),
           keep_code: link_state&.keep_code,
@@ -2328,15 +2333,15 @@ module MarkdownExec
 
       if selected[:type] == BlockType::OPTS
         # body of blocks is returned as a list of lines to be read an YAML
-        HashDelegator.code_merge(required[:blocks].map(&:body).flatten(1))
+        HashDelegator.flatten_and_compact_arrays(required[:blocks].map(&:body).flatten(1))
       else
         code_lines = if selected.type == BlockType::VARS
                        code_from_vars_block_to_set_environment_variables(selected)
                      else
                        []
                      end
-        HashDelegator.code_merge(link_state&.inherited_lines,
-                                 required[:code] + code_lines)
+        HashDelegator.flatten_and_compact_arrays(link_state&.inherited_lines,
+                                                 required[:code] + code_lines)
       end
     end
 
@@ -2558,6 +2563,7 @@ module MarkdownExec
         link_state: link_state,
         pattern: options_command_substitution_regexp
       )
+      # no return
     end
 
     def expand_variable_references!(
@@ -2587,31 +2593,37 @@ module MarkdownExec
       return if replacements == EvaluateShellExpression::StatusFail
 
       expand_blocks_with_replacements(blocks, replacements)
+      # no return
     end
 
     def export_echo_with_code(
-      bash_script_lines, export, force:, silent:
+      bash_script_lines, export, force:, silent:, string: nil
     )
       exportable = true
       command_result = nil
       new_lines = []
-      case export.echo
+      export_string = string || export.echo
+      case export_string
       when String, Integer, Float, TrueClass, FalseClass
-        command_result = output_from_adhoc_bash_script_file(
+        command_result, = output_from_adhoc_bash_script_file(
           join_array_of_arrays(
             bash_script_lines,
-            %(printf '%s' "#{export.echo}")
+            %(printf '%s' "#{export_string}")
           )
         )
         if command_result.exit_status == EXIT_STATUS_REQUIRED_EMPTY
           exportable = false
           command_result.warning = warning_required_empty(export) unless silent
+        else
+          EnvInterface.set(export.name, command_result.stdout.to_s)
+          new_lines << { name: export.name, force: force,
+                         text: command_result.stdout }
         end
 
       when Hash
         # each item in the hash is a variable name and value
-        export.echo.each do |name, expression|
-          command_result = output_from_adhoc_bash_script_file(
+        export_string.each do |name, expression|
+          command_result, = output_from_adhoc_bash_script_file(
             join_array_of_arrays(
               bash_script_lines,
               %(printf '%s' "#{expression}")
@@ -2620,14 +2632,11 @@ module MarkdownExec
           if command_result.exit_status == EXIT_STATUS_REQUIRED_EMPTY
             command_result.warning = warning_required_empty(export) unless silent
           else
-            ENV[name] = command_result.stdout.to_s
-            new_lines << code_line_safe_assign(name, command_result.stdout,
-                                               force: force)
+            EnvInterface.set(name, command_result.stdout.to_s)
+            new_lines << { name: name, force: force,
+                           text: command_result.stdout }
           end
         end
-
-        # individual items have been exported, none remain
-        exportable = false
       end
 
       [command_result, exportable, new_lines]
@@ -2738,7 +2747,7 @@ module MarkdownExec
     # Format expression using environment variables and run state
     def format_expression(expr)
       data = link_load_format_data
-      ENV.each { |key, value| data[key.to_sym] = value }
+      EnvInterface.each { |key, value| data[key.to_sym] = value }
       format(expr, data)
     end
 
@@ -2991,8 +3000,8 @@ module MarkdownExec
 
     def link_block_data_eval(link_state, code_lines, selected, link_block_data,
                              block_source:, shell:)
-      all_code = HashDelegator.code_merge(link_state&.inherited_lines,
-                                          code_lines)
+      all_code = HashDelegator.flatten_and_compact_arrays(link_state&.inherited_lines,
+                                                          code_lines)
       output_lines = []
 
       Tempfile.open do |file|
@@ -3287,8 +3296,11 @@ module MarkdownExec
       [block_name_from_cli, now_using_cli]
     end
 
-    def mdoc_and_blocks_from_nested_files(source_id: nil)
-      blocks_results = blocks_from_nested_files(source_id: source_id)
+    def mdoc_and_blocks_from_nested_files(source_id: nil, link_state: nil)
+      blocks_results = blocks_from_nested_files(
+        link_state: link_state,
+        source_id: source_id
+      )
 
       blocks_results.results.select do |_id, result|
         result.failure?
@@ -3311,7 +3323,10 @@ module MarkdownExec
       #
       reload_blocks = false
 
-      all_blocks, mdoc = mdoc_and_blocks_from_nested_files(source_id: source_id)
+      all_blocks, mdoc = mdoc_and_blocks_from_nested_files(
+        link_state: link_state,
+        source_id: source_id
+      )
       if load_auto_opts_block(all_blocks, mdoc: mdoc)
         reload_blocks = true
       end
@@ -3327,8 +3342,8 @@ module MarkdownExec
       # load document ux block
       #
       if (code_lines = code_from_automatic_ux_blocks(all_blocks, mdoc))
-        new_code = HashDelegator.code_merge(link_state.inherited_lines,
-                                            code_lines)
+        new_code = HashDelegator.flatten_and_compact_arrays(link_state.inherited_lines,
+                                                            code_lines)
         next_state_set_code(nil, link_state, new_code)
         link_state.inherited_lines = new_code
         reload_blocks = true
@@ -3337,15 +3352,18 @@ module MarkdownExec
       # load document vars block
       #
       if (code_lines = load_auto_vars_block(all_blocks))
-        new_code = HashDelegator.code_merge(link_state.inherited_lines,
-                                            code_lines)
+        new_code = HashDelegator.flatten_and_compact_arrays(link_state.inherited_lines,
+                                                            code_lines)
         next_state_set_code(nil, link_state, new_code)
         link_state.inherited_lines = new_code
         reload_blocks = true
       end
 
       if reload_blocks
-        all_blocks, mdoc = mdoc_and_blocks_from_nested_files(source_id: source_id)
+        all_blocks, mdoc = mdoc_and_blocks_from_nested_files(
+          link_state: link_state,
+          source_id: source_id
+        )
       end
 
       # filter by name, collapsed
@@ -3514,7 +3532,7 @@ module MarkdownExec
       next_state_set_code(
         selected,
         link_state,
-        HashDelegator.code_merge(
+        HashDelegator.flatten_and_compact_arrays(
           link_state&.inherited_lines,
           code_lines.is_a?(Array) ? code_lines : [] # no code for :ux_exec_prohibited
         )
@@ -3531,7 +3549,7 @@ module MarkdownExec
           ((link_state&.inherited_block_names || []) + block_names).sort.uniq,
         inherited_dependencies:
           (link_state&.inherited_dependencies || {}).merge(dependencies || {}), ### merge, not replace, key data
-        inherited_lines: HashDelegator.code_merge(code_lines),
+        inherited_lines: HashDelegator.flatten_and_compact_arrays(code_lines),
         keep_code: link_state&.keep_code,
         next_block_name: '',
         next_document_filename: @delegate_object[:filename],
@@ -3575,7 +3593,10 @@ module MarkdownExec
       }
     end
 
-    def output_from_adhoc_bash_script_file(bash_script_lines)
+    def output_from_adhoc_bash_script_file(
+      bash_script_lines,
+      export = nil
+    )
       Tempfile.create('script_exec') do |temp_file|
         temp_file.write(
           HashDelegator.join_code_lines(
@@ -3595,7 +3616,32 @@ module MarkdownExec
 
         output = `#{shell} #{temp_file.path}`
 
-        CommandResult.new(stdout: output, exit_status: $?.exitstatus)
+        exportable = export ? export.exportable : false
+        new_lines = []
+        if export
+          new_lines << "#{export.name}="
+          export_value = output
+          ### transform?
+
+          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
+          )
+        end
+
+        [
+          command_result,
+          exportable,
+          new_lines
+        ]
       end
     rescue StandardError => err
       warn "Error executing script: #{err.message}"
@@ -3636,7 +3682,8 @@ module MarkdownExec
           inherited_dependencies:
            dependencies.merge(pop.inherited_dependencies || {}), ### merge, not replace, key data
           inherited_lines:
-           HashDelegator.code_merge(pop.inherited_lines, code_lines)
+           HashDelegator.flatten_and_compact_arrays(pop.inherited_lines,
+                                                    code_lines)
         )
         @link_history.push(next_state)
 
@@ -3653,7 +3700,9 @@ module MarkdownExec
           inherited_dependencies:
            (link_state&.inherited_dependencies || {}).merge(dependencies || {}), ### merge, not replace, key data
           inherited_lines:
-           HashDelegator.code_merge(link_state&.inherited_lines, code_lines),
+           HashDelegator.flatten_and_compact_arrays(
+             link_state&.inherited_lines, code_lines
+           ),
           keep_code: link_state&.keep_code,
           next_block_name: next_block_name,
           next_document_filename: @delegate_object[:filename], # not next_document_filename
@@ -4395,7 +4444,6 @@ module MarkdownExec
       marker = Random.new.rand.to_s
 
       code = (code_lines || []) + ["echo -n \"#{marker}#{raw}\""]
-      # !!t code
       File.write filespec, HashDelegator.join_code_lines(code)
       File.chmod 0o755, filespec
 
@@ -4506,6 +4554,7 @@ module MarkdownExec
       return value unless export.transform.present?
 
       if export.transform.is_a? Symbol
+        ### TBD validate for symbol
         value.send(export.transform)
       else
         format(
@@ -4607,16 +4656,21 @@ module MarkdownExec
     def ux_block_export_activated(
       bash_script_lines, export, exit_prompt
     )
+      command_result = nil
       exportable = true
-      transformable = true
+      force = true
       new_lines = []
-      command_result = nil
+      silent = false
+      transformable = true
 
       case FCB.act_source(export)
       when false, UxActSource::FALSE
-        raise 'Should not be reached.'
+        # read-only
+        command_result = CommandResult.new
+        exportable = false
+        transformable = false
 
-      when ':allow', UxActSource::ALLOW
+      when :allow, UxActSource::ALLOW
         raise unless export.allow.present?
 
         case export.allow
@@ -4624,9 +4678,10 @@ module MarkdownExec
           command_result, exportable, new_lines = export_echo_with_code(
             bash_script_lines,
             export,
-            force: true,
-            silent: false
+            force: force,
+            silent: silent
           )
+
           if command_result.failure?
             command_result
           else
@@ -4635,8 +4690,8 @@ module MarkdownExec
             )
           end
 
-        when ':exec', UxActSource::EXEC
-          command_result = output_from_adhoc_bash_script_file(
+        when :exec, UxActSource::EXEC
+          command_result, = output_from_adhoc_bash_script_file(
             join_array_of_arrays(bash_script_lines, export.exec)
           )
 
@@ -4651,22 +4706,26 @@ module MarkdownExec
           end
 
         else
-          command_result = CommandResult.new(
-            stdout: menu_from_list_with_back(export.allow)
+          export_init = menu_from_list_with_back(export.allow)
+          command_result, exportable, new_lines = export_echo_with_code(
+            ["#{export.name}=#{Shellwords.escape(export_init)}"],
+            export,
+            force: force,
+            silent: silent,
+            string: export_init
           )
+
         end
 
-      when ':echo', UxActSource::ECHO
+      when :echo, UxActSource::ECHO
         command_result, exportable, new_lines = export_echo_with_code(
           bash_script_lines,
           export,
-          force: true,
-          silent: false
+          force: force,
+          silent: silent
         )
 
-        command_result
-
-      when ':edit', UxActSource::EDIT
+      when :edit, UxActSource::EDIT
         output = nil
         begin
           loop do
@@ -4686,13 +4745,11 @@ module MarkdownExec
 
         command_result = CommandResult.new(stdout: output)
 
-      when ':exec', UxActSource::EXEC
-        command_result = output_from_adhoc_bash_script_file(
+      when :exec, UxActSource::EXEC
+        command_result, = output_from_adhoc_bash_script_file(
           join_array_of_arrays(bash_script_lines, export.exec)
         )
 
-        command_result
-
       else
         transformable = false
         command_result = CommandResult.new(stdout: export.default.to_s)
@@ -4701,7 +4758,7 @@ module MarkdownExec
       # add message for required variables
       if command_result.exit_status == EXIT_STATUS_REQUIRED_EMPTY
         command_result.warning = warning_required_empty(export)
-        # warn command_result.warning
+        warn command_result.warning unless silent
       end
 
       command_result.exportable = exportable
@@ -4710,12 +4767,15 @@ module MarkdownExec
       command_result
     end
 
-    def ux_block_export_automatic(bash_script_lines, export)
-      transformable = true
+    def ux_block_export_automatic(
+      bash_script_lines, export
+    )
+      command_result = nil
       exportable = true
+      force = false
       new_lines = []
-      command_result = nil
       silent = true
+      transformable = true
 
       case FCB.init_source(export)
       when false, UxActSource::FALSE
@@ -4723,57 +4783,85 @@ module MarkdownExec
         transformable = false
         command_result = CommandResult.new
 
-      when ':allow', UxActSource::ALLOW
+      when :allow, UxActSource::ALLOW
         raise unless export.allow.present?
 
         case export.allow
         when :echo, ExportValueSource::ECHO
+          cr_echo, = output_from_adhoc_bash_script_file(
+            join_array_of_arrays(
+              bash_script_lines,
+              %(printf '%s' "#{export.echo}")
+            )
+          )
+          export_init = cr_echo.stdout.split("\n").first
           command_result, exportable, new_lines = export_echo_with_code(
-            bash_script_lines,
+            ["#{export.name}=#{Shellwords.escape(export_init)}"],
             export,
-            force: false,
-            silent: silent
+            force: force,
+            silent: silent,
+            string: export_init
           )
-          unless command_result.failure?
-            command_result.stdout = (exportable && command_result.stdout.split("\n").first) || ''
-          end
 
         when :exec, ExportValueSource::EXEC
-          command_result = output_from_adhoc_bash_script_file(
+          # extract first line from 'exec' output
+          command_result, = output_from_adhoc_bash_script_file(
             join_array_of_arrays(bash_script_lines, export.exec)
           )
           unless command_result.failure?
-            command_result.stdout = command_result.stdout.split("\n").first
+            export_init = command_result.stdout.split("\n").first
+            command_result, exportable, new_lines = export_echo_with_code(
+              ["#{export.name}=#{Shellwords.escape(export_init)}"],
+              export,
+              force: force,
+              silent: silent,
+              string: export_init
+            )
           end
 
         else
-          # must be a list
-          command_result = CommandResult.new(stdout: export.allow.first)
+          # 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)}"],
+            export,
+            force: force,
+            silent: silent,
+            string: export_init
+          )
+
         end
 
-      when ':default', UxActSource::DEFAULT
+      when :default, UxActSource::DEFAULT
         transformable = false
         command_result = CommandResult.new(stdout: export.default.to_s)
 
-      when ':echo', UxActSource::ECHO
+      when :echo, UxActSource::ECHO
         raise unless export.echo.present?
 
         command_result, exportable, new_lines = export_echo_with_code(
           bash_script_lines,
           export,
-          force: false,
+          force: force,
           silent: silent
         )
-
-      when ':exec', UxActSource::EXEC
+      when :exec, UxActSource::EXEC
         raise unless export.exec.present?
 
-        command_result = output_from_adhoc_bash_script_file(
-          join_array_of_arrays(bash_script_lines, export.exec)
+        command_result, exportable, new_lines = output_from_adhoc_bash_script_file(
+          join_array_of_arrays(bash_script_lines, export.exec),
+          export
         )
 
       else
-        command_result = CommandResult.new(stdout: export.init.to_s)
+        export_init = export.init.to_s
+        command_result, exportable, new_lines = export_echo_with_code(
+          ["#{export.name}=#{Shellwords.escape(export_init)}"],
+          export,
+          force: force,
+          silent: silent,
+          string: export_init
+        )
         # raise "Unknown FCB.init_source(export) #{FCB.init_source(export)}"
       end
 
@@ -5189,9 +5277,6 @@ module MarkdownExec
         )
       end
       # rubocop:enable Style/GuardClause
-
-      # # reflect new menu items
-      # @dml_mdoc = MDoc.new(@dml_menu_blocks)
     end
 
     def vux_navigate_back_for_ls
@@ -5228,7 +5313,6 @@ module MarkdownExec
         mdoc_menu_and_blocks_from_nested_files(
           @dml_link_state, source_id: source_id
         )
-
       dump_delobj(@dml_blocks_in_file, @dml_menu_blocks, @dml_link_state)
     end