markdown_exec 3.5.1 → 3.6.0

data/lib/cached_nested_file_reader.rb

@@ -33,7 +33,8 @@ class CachedNestedFileReader
     symbol_evaluated_expression:,
     symbol_force_quoted_literal:,
     symbol_raw_literal:,
-    symbol_variable_reference:
+    symbol_variable_reference:,
+    hide_shebang: true
   )
     @file_cache = {}
     @import_directive_line_pattern = import_directive_line_pattern
@@ -46,16 +47,18 @@ class CachedNestedFileReader
     @symbol_force_quoted_literal = symbol_force_quoted_literal
     @symbol_raw_literal = symbol_raw_literal
     @symbol_variable_reference = symbol_variable_reference
+    @hide_shebang = hide_shebang
   end
 
   def error_handler(name = '', opts = {})
     Exceptions.error_handler(
       "CachedNestedFileReader.#{name} -- #{$!}",
+      caller.deref(6),
       opts
     )
   end
 
-  def warn_format(name, message, opts = {})
+  def self.warn_format(name, message, opts = {})
     Exceptions.warn_format(
       "CachedNestedFileReader.#{name} -- #{message}",
       opts
@@ -94,6 +97,11 @@ class CachedNestedFileReader
       wwt :readline, 'depth:', depth, 'filename:', filename, 'ind:', ind,
           'segment:', segment
 
+      # [REQ:SHEBANG_HIDING] Filter shebang lines from processed output
+      # [IMPL:SHEBANG_FILTERING] [ARCH:SHEBANG_EXTRACTION] [REQ:SHEBANG_HIDING]
+      # first line is a shebang line if it starts with '#!'
+      next if @hide_shebang && is_shebang_line?(segment, ind == 0)
+
       if continued_line || (Regexp.new(@import_directive_line_pattern) =~ segment)
         line = (continued_line || '') + segment
         # if segment ends in a continuation, prepend to next line
@@ -106,7 +114,7 @@ class CachedNestedFileReader
 
         # apply substitutions to the @import line
         line_sub1 = apply_line_substitutions(line, substitutions,
-                                                    use_template_delimiters)
+                                             use_template_delimiters)
 
         # parse the @import line
         Regexp.new(@import_directive_line_pattern) =~ line_sub1
@@ -190,8 +198,10 @@ class CachedNestedFileReader
     wwt :read_document_code, 'processed_lines:', processed_lines
     @file_cache[cache_key] = processed_lines
   rescue Errno::ENOENT => err
-    warn_format('readlines', "#{err} @@ #{context}",
-                { abort: true })
+    CachedNestedFileReader.warn_format(
+      'readlines', "#{err} @@ #{context}",
+      { abort: true }
+    )
   rescue StandardError
     wwe $!
   end
@@ -314,6 +324,15 @@ class CachedNestedFileReader
     sorted_params = substitutions.sort.to_h.hash
     "#{filename}##{name_strip}##{params_string}##{sorted_params}"
   end
+
+  # [REQ:SHEBANG_HIDING] Detect shebang lines at the start of file content
+  # [IMPL:SHEBANG_DETECTION] [ARCH:SHEBANG_EXTRACTION] [REQ:SHEBANG_HIDING]
+  # Matches the beginning of the first line as '#!' - anything after that matches a shebang
+  def is_shebang_line?(line, is_first_line)
+    return false unless is_first_line
+
+    line.start_with?('#!')
+  end
 end
 
 return if $PROGRAM_NAME != __FILE__
@@ -501,4 +520,125 @@ class CachedNestedFileReaderTest < Minitest::Test
     importing_file.close
     importing_file.unlink
   end
+
+  # [REQ:SHEBANG_HIDING] Test shebang line detection and filtering
+  # [IMPL:SHEBANG_DETECTION] [IMPL:SHEBANG_FILTERING] [ARCH:SHEBANG_EXTRACTION] [REQ:SHEBANG_HIDING]
+  def test_readlines_with_shebang_hidden
+    file_with_shebang = Tempfile.new('test_shebang.txt')
+    file_with_shebang.write("#!/usr/bin/env mde\nLine1\nLine2")
+    file_with_shebang.rewind
+
+    reader_with_hide = CachedNestedFileReader.new(
+      import_directive_line_pattern:
+        /^(?<indention> *)@import +(?<name>\S+)(?<params>(?: +[A-Za-z_]\w*=(?:"[^"]*"|'[^']*'|\S+))*) *$/,
+      import_directive_parameter_scan:
+        /([A-Za-z_]\w*)(:=|\?=|!=|=)(?:"([^"]*)"|'([^']*)'|(\S+))/,
+      import_parameter_variable_assignment: '%{key}=%{value}',
+      shell: 'bash',
+      shell_block_name: '(document_shell)',
+      symbol_command_substitution: ':c=',
+      symbol_evaluated_expression: ':e=',
+      symbol_raw_literal: '=',
+      symbol_force_quoted_literal: ':q=',
+      symbol_variable_reference: ':v=',
+      hide_shebang: true
+    )
+
+    result = reader_with_hide.readlines(file_with_shebang.path).map(&:to_s)
+    assert_equal %w[Line1 Line2], result, 'Shebang line should be filtered when hide_shebang is true'
+
+    file_with_shebang.close
+    file_with_shebang.unlink
+  end
+
+  def test_readlines_with_shebang_shown
+    file_with_shebang = Tempfile.new('test_shebang.txt')
+    file_with_shebang.write("#!/usr/bin/env mde\nLine1\nLine2")
+    file_with_shebang.rewind
+
+    reader_without_hide = CachedNestedFileReader.new(
+      import_directive_line_pattern:
+        /^(?<indention> *)@import +(?<name>\S+)(?<params>(?: +[A-Za-z_]\w*=(?:"[^"]*"|'[^']*'|\S+))*) *$/,
+      import_directive_parameter_scan:
+        /([A-Za-z_]\w*)(:=|\?=|!=|=)(?:"([^"]*)"|'([^']*)'|(\S+))/,
+      import_parameter_variable_assignment: '%{key}=%{value}',
+      shell: 'bash',
+      shell_block_name: '(document_shell)',
+      symbol_command_substitution: ':c=',
+      symbol_evaluated_expression: ':e=',
+      symbol_raw_literal: '=',
+      symbol_force_quoted_literal: ':q=',
+      symbol_variable_reference: ':v=',
+      hide_shebang: false
+    )
+
+    result = reader_without_hide.readlines(file_with_shebang.path).map(&:to_s)
+    assert_equal ['#!/usr/bin/env mde', 'Line1', 'Line2'], result, 'Shebang line should be included when hide_shebang is false'
+
+    file_with_shebang.close
+    file_with_shebang.unlink
+  end
+
+  def test_readlines_with_shebang_in_imported_file
+    imported_file = Tempfile.new('imported_shebang.txt')
+    imported_file.write("#!/usr/bin/env mde\nImportedLine1\nImportedLine2")
+    imported_file.rewind
+
+    main_file = Tempfile.new('main_file.txt')
+    main_file.write("Line1\n @import #{imported_file.path}\nLine2")
+    main_file.rewind
+
+    reader_with_hide = CachedNestedFileReader.new(
+      import_directive_line_pattern:
+        /^(?<indention> *)@import +(?<name>\S+)(?<params>(?: +[A-Za-z_]\w*=(?:"[^"]*"|'[^']*'|\S+))*) *$/,
+      import_directive_parameter_scan:
+        /([A-Za-z_]\w*)(:=|\?=|!=|=)(?:"([^"]*)"|'([^']*)'|(\S+))/,
+      import_parameter_variable_assignment: '%{key}=%{value}',
+      shell: 'bash',
+      shell_block_name: '(document_shell)',
+      symbol_command_substitution: ':c=',
+      symbol_evaluated_expression: ':e=',
+      symbol_raw_literal: '=',
+      symbol_force_quoted_literal: ':q=',
+      symbol_variable_reference: ':v=',
+      hide_shebang: true
+    )
+
+    result = reader_with_hide.readlines(main_file.path).map(&:to_s)
+    assert_equal ['Line1', ' ImportedLine1', ' ImportedLine2', 'Line2'], result,
+                 'Shebang in imported file should be filtered when hide_shebang is true'
+
+    imported_file.close
+    imported_file.unlink
+    main_file.close
+    main_file.unlink
+  end
+
+  def test_readlines_without_shebang
+    file_without_shebang = Tempfile.new('test_no_shebang.txt')
+    file_without_shebang.write("Line1\nLine2\nLine3")
+    file_without_shebang.rewind
+
+    reader_with_hide = CachedNestedFileReader.new(
+      import_directive_line_pattern:
+        /^(?<indention> *)@import +(?<name>\S+)(?<params>(?: +[A-Za-z_]\w*=(?:"[^"]*"|'[^']*'|\S+))*) *$/,
+      import_directive_parameter_scan:
+        /([A-Za-z_]\w*)(:=|\?=|!=|=)(?:"([^"]*)"|'([^']*)'|(\S+))/,
+      import_parameter_variable_assignment: '%{key}=%{value}',
+      shell: 'bash',
+      shell_block_name: '(document_shell)',
+      symbol_command_substitution: ':c=',
+      symbol_evaluated_expression: ':e=',
+      symbol_raw_literal: '=',
+      symbol_force_quoted_literal: ':q=',
+      symbol_variable_reference: ':v=',
+      hide_shebang: true
+    )
+
+    result = reader_with_hide.readlines(file_without_shebang.path).map(&:to_s)
+    assert_equal %w[Line1 Line2 Line3], result, 'File without shebang should work normally'
+
+    file_without_shebang.close
+    file_without_shebang.unlink
+  end
 end

data/lib/command_result.rb

@@ -3,11 +3,18 @@
 
 # encoding=utf-8
 
+ALL = [
+  BASH = 'bash',
+  FISH = 'fish',
+  SH = 'sh'
+].freeze
+
 # Encapsulates the result of executing a system command, storing its output,
 # exit status, and any number of additional, arbitrary attributes.
 #
 # @example
-#   result = CommandResult.new(stdout: output, exit_status: $?.exitstatus, duration: 1.23)
+#   result = CommandResult.new(stdout: output, exit_status: $?.exitstatus,
+#                              duration: 1.23)
 #   result.stdout        # => output
 #   result.exit_status   # => 0
 #   result.duration      # => 1.23
@@ -15,13 +22,19 @@
 #   result.new_field     # => 42
 #   result.success?      # => true
 class CommandResult
+  ALL = [
+    EXIT_STATUS_OK = 0,
+    EXIT_STATUS_FAIL = 127,
+    EXIT_STATUS_REQUIRED_EMPTY = 248
+  ].freeze
+
   # @param attributes [Hash{Symbol=>Object}] initial named attributes
   def initialize(**attributes)
-    @attributes = {}
-    @attributes[:exit_status] = 0
-    @attributes[:stdout] = ''
-    @attributes[:warning] = ''
-    attributes.each { |name, value| @attributes[name] = value }
+    @attributes = {
+      exit_status: EXIT_STATUS_OK,
+      stdout: '',
+      warning: ''
+    }.merge(attributes)
   end
 
   def failure?
@@ -39,6 +52,14 @@ class CommandResult
     value
   end
 
+  def stdout
+    @attributes[:stdout]
+  end
+
+  def transformed
+    @attributes[:transformed]
+  end
+
   # # trap assignment to new_lines
   # def new_lines=(value)
   #   ww caller.deref[0..4], value