ceedling 1.1.10 → 1.2.0

data/spec/units/c_extractor/c_extractor_spec.rb

@@ -37,7 +37,8 @@ describe CExtractor do
             c_extractor_preprocessing: CExtractorPreprocessing.new({ c_extractor_code_text: CExtractorCodeText.new }),
             c_extractor_definitions:   CExtractorDefinitions.new({ c_extractor_code_text: CExtractorCodeText.new }),
             configurator:              configurator,
-            loginator:                 double('Loginator').as_null_object
+            loginator:                 double('Loginator').as_null_object,
+            file_wrapper:              double('FileWrapper').as_null_object
           }
         )
         extractor.setup()
@@ -111,7 +112,8 @@ describe CExtractor do
             # Bare double (no :partials_max_extraction_length stub) so #respond_to? is
             # false and CExtractor falls back to its own built-in default buffer length.
             configurator:             double('Configurator'),
-            loginator:                double('Loginator').as_null_object
+            loginator:                double('Loginator').as_null_object,
+            file_wrapper:             double('FileWrapper').as_null_object
           }
         )
         extractor.setup()
@@ -370,11 +372,39 @@ describe CExtractor do
         content = "/* comment across\nchunk boundary */PATTERN"
         io = StringIO.new(content)
         extractor = create_pattern_extractor.call(/PATTERN/)
-        
+
         result = extract_feature.call(io, 1000, extractor)
-        
+
         expect(result).to eq("PATTERN")
       end
+
+      # try_extract_bare_macro_invocation's own success/failure decision depends on
+      # peeking past the invocation's closing ')' for a terminating ';'/'{' -- if that
+      # peek lands exactly at eos? because only THIS chunk has been read so far (not
+      # because the real file has ended), it must fail and let extract_next_feature grow
+      # the buffer and retry, never treat a mid-buffer eos? as "no terminator follows."
+      # Round-tripped through the real extract_next_feature (not called directly) so
+      # this exercises the real growth-and-retry behavior the fix depends on.
+      it "does not falsely succeed when a bare invocation's terminator would only appear in the next chunk" do
+        code_text     = CExtractorCodeText.new
+        preprocessing = CExtractorPreprocessing.new({ c_extractor_code_text: code_text })
+
+        # chunk_size=10: "FOO(0123)" is exactly 10 characters, so the first chunk read
+        # ends precisely at the invocation's closing ')' -- the very next character (a
+        # real terminating ';', making this NOT a bare invocation) only exists once a
+        # second chunk is read.
+        content = "FOO(0123);"
+        io = StringIO.new(content)
+
+        obj = build_extractor.call()
+        obj.chunk_size = 10
+        feature, _start = obj.send(
+          :extract_next_feature, io: io, max_length: 1000,
+          extractor: preprocessing.method(:try_extract_bare_macro_invocation)
+        )
+
+        expect(feature).to be_nil
+      end
     end
 
     context "performance and safety" do
@@ -396,17 +426,217 @@ describe CExtractor do
         content = "A B C D E F G H I J"
         io = StringIO.new(content)
         extractor = create_pattern_extractor.call(/\w/)
-        
+
         results = []
         10.times do
           result = extract_feature.call(io, 1000, extractor)
           break unless result
           results << result
         end
-        
+
         expect(results).to eq(["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"])
       end
     end
   end
 
+  ###
+  ### extract_contents() -- dispatch priority, termination, and cleanup
+  ###
+  ### extract_contents' own end-to-end dispatch correctness for every real construct
+  ### type, and element_sequence ordering, is already exhaustively proven with real
+  ### parsing by spec/integration/c_extractor_composition_spec.rb. These tests are
+  ### scoped narrowly to ordering/termination/cleanup behavior that a mocked-collaborator
+  ### test can isolate but a real-parsing test structurally can't (real C syntax is
+  ### rarely ambiguous between two constructs at the same position).
+  ###
+  describe "#extract_contents (private method testing)" do
+    # Helper to build a fully-wired CExtractor via DI, returning both the extractor and
+    # its individual real collaborators so tests can stub one collaborator's method while
+    # leaving the rest of the graph real -- mirrors #extract_next_feature's own
+    # build_extractor helper above.
+    let(:build_extractor) do
+      ->() do
+        code_text      = CExtractorCodeText.new
+        declarations   = CExtractorDeclarations.new({ c_extractor_code_text: code_text })
+        functions      = CExtractorFunctions.new({ c_extractor_code_text: code_text })
+        preprocessing  = CExtractorPreprocessing.new({ c_extractor_code_text: code_text })
+        definitions    = CExtractorDefinitions.new({ c_extractor_code_text: code_text })
+        declarations.setup()
+        functions.setup()
+        extractor = CExtractor.new(
+          {
+            c_extractor_code_text:    code_text,
+            c_extractor_functions:    functions,
+            c_extractor_declarations: declarations,
+            c_extractor_preprocessing: preprocessing,
+            c_extractor_definitions:  definitions,
+            configurator:             double('Configurator'),
+            loginator:                double('Loginator').as_null_object,
+            file_wrapper:             double('FileWrapper').as_null_object
+          }
+        )
+        extractor.setup()
+        {
+          extractor:     extractor,
+          preprocessing: preprocessing,
+          definitions:   definitions,
+          functions:     functions,
+          declarations:  declarations
+        }
+      end
+    end
+
+    it "tries directive extraction before typedef extraction at the same position" do
+      built = build_extractor.call()
+
+      allow(built[:preprocessing]).to receive(:try_extract_directive) do |scanner|
+        scanner.terminate
+        [true, "#define X 1"]
+      end
+      expect(built[:definitions]).not_to receive(:try_extract_typedef)
+
+      io = StringIO.new("TOKEN")
+      result = built[:extractor].send(:extract_contents, io, nil)
+
+      expect(result).to be_a(CExtractorTypes::CModule)
+      expect(result.macro_definitions.length).to eq(1)
+    end
+
+    it "tries typedef extraction before static-assert extraction at the same position" do
+      built = build_extractor.call()
+
+      allow(built[:definitions]).to receive(:try_extract_typedef) do |scanner|
+        scanner.terminate
+        [true, "typedef int foo_t;"]
+      end
+      expect(built[:preprocessing]).not_to receive(:try_extract_static_assert)
+
+      io = StringIO.new("TOKEN")
+      result = built[:extractor].send(:extract_contents, io, nil)
+
+      expect(result.type_definitions.length).to eq(1)
+    end
+
+    it "tries bare-macro-invocation extraction before function-definition extraction at the same position" do
+      built = build_extractor.call()
+
+      allow(built[:preprocessing]).to receive(:try_extract_bare_macro_invocation) do |scanner|
+        scanner.terminate
+        [true, CExtractorTypes::CStatement.new(text: "FOO(0)")]
+      end
+      expect(built[:functions]).not_to receive(:try_extract_function_definition)
+
+      io = StringIO.new("TOKEN")
+      result = built[:extractor].send(:extract_contents, io, nil)
+
+      expect(result.macro_invocations.length).to eq(1)
+    end
+
+    it "breaks out of the loop and returns the accumulated CModule when no extractor succeeds anywhere" do
+      built = build_extractor.call()
+
+      # None of the six extractors recognize this content at all (no leading '#',
+      # no keyword, no identifier characters), so every one of them fails and the
+      # loop must break rather than looping forever or raising.
+      io = StringIO.new("@@@")
+      result = built[:extractor].send(:extract_contents, io, nil)
+
+      expect(result).to be_a(CExtractorTypes::CModule)
+      expect(result.function_definitions).to eq([])
+      expect(result.function_declarations).to eq([])
+      expect(result.variable_declarations).to eq([])
+      expect(result.macro_definitions).to eq([])
+      expect(result.type_definitions).to eq([])
+      expect(result.aggregate_definitions).to eq([])
+      expect(result.macro_invocations).to eq([])
+      expect(result.element_sequence).to eq([])
+    end
+
+    it "closes the IO via ensure even when a collaborator raises mid-loop" do
+      built = build_extractor.call()
+      allow(built[:preprocessing]).to receive(:try_extract_directive).and_raise(StandardError, "boom")
+
+      io = StringIO.new("TOKEN")
+
+      expect {
+        built[:extractor].send(:extract_contents, io, nil)
+      }.to raise_error(StandardError, "boom")
+
+      expect(io.closed?).to be true
+    end
+  end
+
+  ###
+  ### _compute_line_info()
+  ###
+  describe "#_compute_line_info (private method testing)" do
+    let(:extractor) do
+      CExtractor.new(
+        {
+          c_extractor_code_text:     CExtractorCodeText.new,
+          c_extractor_functions:     CExtractorFunctions.new({ c_extractor_code_text: CExtractorCodeText.new }),
+          c_extractor_declarations:  CExtractorDeclarations.new({ c_extractor_code_text: CExtractorCodeText.new }),
+          c_extractor_preprocessing: CExtractorPreprocessing.new({ c_extractor_code_text: CExtractorCodeText.new }),
+          c_extractor_definitions:   CExtractorDefinitions.new({ c_extractor_code_text: CExtractorCodeText.new }),
+          configurator:              double('Configurator'),
+          loginator:                 double('Loginator').as_null_object,
+          file_wrapper:              double('FileWrapper').as_null_object
+        }
+      ).tap { |e| e.setup() }
+    end
+
+    it "reports line 1 when nothing consumed contains a newline" do
+      io = StringIO.new("int x; int y;")
+      io.seek(7) # positioned right after "int x; "
+
+      line, cumulative = extractor.send(:_compute_line_info, io, 0, 7, 0)
+
+      expect(line).to eq(1)
+      expect(cumulative).to eq(0)
+    end
+
+    it "advances the line number when newlines precede the feature start" do
+      io = StringIO.new("int x;\nint y;\nint z;")
+      io.seek(14) # positioned right after the second line
+
+      line, cumulative = extractor.send(:_compute_line_info, io, 0, 14, 0)
+
+      expect(line).to eq(3)
+      expect(cumulative).to eq(2)
+    end
+
+    it "does not count newlines consumed after the feature start toward this call's reported line" do
+      io = StringIO.new("int x;\nint y;\n")
+      io.seek(14)
+
+      # feature_start (0) is before any newline, but the call consumed through both lines --
+      # this call's own reported line must reflect only the gap up to feature_start, while
+      # the returned cumulative count reflects everything actually consumed.
+      line, cumulative = extractor.send(:_compute_line_info, io, 0, 0, 0)
+
+      expect(line).to eq(1)
+      expect(cumulative).to eq(2)
+    end
+
+    it "handles a zero-length gap where the feature starts exactly at call_start" do
+      io = StringIO.new("int x;\nint y;")
+      io.seek(7)
+
+      line, cumulative = extractor.send(:_compute_line_info, io, 7, 7, 3)
+
+      expect(line).to eq(4)
+      expect(cumulative).to eq(3)
+    end
+
+    it "adds newly consumed newlines on top of a nonzero starting cumulative count" do
+      io = StringIO.new("first\nsecond\nthird")
+      io.seek(13) # after "first\nsecond\n"
+
+      line, cumulative = extractor.send(:_compute_line_info, io, 0, 13, 5)
+
+      expect(line).to eq(8)
+      expect(cumulative).to eq(7)
+    end
+  end
+
 end

data/spec/units/ceedling/templateinator_golden_spec.rb

@@ -0,0 +1,84 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+require 'spec_helper'
+require 'ceedling/constants'
+require 'ceedling/reportinator'
+require 'ceedling/plugins/plugin_reportinator'
+require 'ceedling/templateinator'
+require 'template_render_cases'
+
+# Renders every real report template through the real PluginReportinator pipeline
+# and compares byte for byte against output captured from ERB 2.2.0 before ERB was
+# removed as a dependency.
+#
+# The fixtures carry ERB's behavior as committed data rather than as a live
+# dependency, which is what lets this equivalence check survive erb's removal and
+# keep working on a Ruby that has no erb at all. Treat the fixture bytes as the
+# frozen contract. A failure here means rendering changed, not that the fixtures
+# need refreshing, and regenerating them would destroy the only reference that
+# remains.
+describe 'Report template rendering against captured ERB output' do
+  # .gitattributes marks these fixtures as unconverted so their bytes survive a
+  # checkout intact. A clone made before that was added keeps its converted copies,
+  # because git does not re-check-out files whose content did not change, and every
+  # example below would then fail against bytes nobody recorded. Said plainly once
+  # here rather than discovered across 42 byte-level diffs.
+  before(:all) do
+    converted = Dir.glob( File.join( TemplateRenderCases::FIXTURES_PATH, '*.txt' ) ).select do |path|
+      File.binread( path ).include?( "\r\n" )
+    end
+
+    unless converted.empty?
+      raise "#{converted.length} golden fixture(s) hold carriage returns, so this checkout converted " +
+            "their line endings. Restore them with: git checkout -- spec/support/fixtures/templates/"
+    end
+  end
+
+  def render(template, hash)
+    captured = nil
+    loginator = double('loginator')
+    allow(loginator).to receive(:decorate) { |str, _label| str }
+    allow(loginator).to receive(:log) { |output, *_| captured = output }
+
+    reportinator_plugin = PluginReportinator.new(
+      {
+        plugin_reportinator_helper: nil,
+        plugin_manager: nil,
+        reportinator: Reportinator.new,
+        loginator: loginator,
+        templateinator: Templateinator.new
+      }
+    )
+    reportinator_plugin.set_system_objects({ plugin_reportinator: reportinator_plugin })
+    reportinator_plugin.run_report( template, hash )
+
+    return captured
+  end
+
+  TemplateRenderCases.templates.each_pair do |template_name, template|
+    context "the #{template_name} template" do
+      TemplateRenderCases.cases.each_pair do |case_name, hash|
+        it "renders #{case_name} exactly as ERB did" do
+          fixture = File.join( TemplateRenderCases::FIXTURES_PATH, "#{template_name}__#{case_name}.txt" )
+
+          # Each render gets its own deep copy, so no template can alter the input another
+          # example renders.
+          output = render( template, Marshal.load( Marshal.dump( hash ) ) )
+
+          # Compared as bytes on both sides. A rendered string carries the encoding
+          # its template was read with, while binread always yields ASCII-8BIT, and
+          # Ruby only treats two encodings as equal when both hold nothing but
+          # ASCII. Today every fixture is ASCII, so this changes no result, but one
+          # non-ASCII character in a future template would otherwise fail here for a
+          # reason that has nothing to do with rendering.
+          expect(output.b).to eq( File.binread( fixture ) )
+        end
+      end
+    end
+  end
+end

data/spec/units/ceedling/templateinator_spec.rb

@@ -0,0 +1,188 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+require 'spec_helper'
+require 'ceedling/templateinator'
+
+# Templateinator compiles Ceedling's report templates. It replaced ERB, so these
+# examples pin the template language itself rather than any one template. Every
+# expected value here was taken from real ERB 2.2.0 output before ERB was removed.
+#
+# Everything is strings in and strings out. Templateinator has no collaborators and
+# touches no IO. The real templates are covered byte for byte against captured ERB
+# output by templateinator_golden_spec.rb.
+describe Templateinator do
+  before(:each) do
+    @templateinator = described_class.new
+  end
+
+  def render(template)
+    return @templateinator.render( template, binding )
+  end
+
+  describe 'percent lines' do
+    # ERB accepted a percent only in column zero and allowed any whitespace after
+    # it. Ceedling's own templates indent heavily to show nesting, so stripping the
+    # percent alone, rather than a percent and a space, is load bearing.
+    it 'treats an indented percent line as Ruby' do
+      expect(render( "%   [1,2].each do |i|\n- <%=i%>\n%   end\n" )).to eq( "- 1\n- 2\n" )
+    end
+
+    it 'treats a Ruby comment on a percent line as code, emitting nothing' do
+      expect(render( "% # a comment\nx\n" )).to eq( "x\n" )
+    end
+
+    # One shared scope across the whole template, including across block
+    # boundaries, is what lets a template compute a value once and use it later.
+    it 'shares locals between percent lines and later output tags' do
+      expect(render( "% prefix = 'hi'\n%[1,2].each do |i|\n- <%=prefix%><%=i%>\n%end\n" )).to eq( "- hi1\n- hi2\n" )
+    end
+
+    it 'emits one literal percent for a doubled percent at column zero' do
+      expect(render( "%% literal\n" )).to eq( "% literal\n" )
+    end
+  end
+
+  describe 'output tags' do
+    it 'substitutes an expression' do
+      expect(render( "value: <%= 1 + 1 %>\n" )).to eq( "value: 2\n" )
+    end
+
+    it 'converts a non-string expression with to_s' do
+      expect(render( "value <%= :sym %>\n" )).to eq( "value sym\n" )
+    end
+
+    it 'emits nothing for a comment tag' do
+      expect(render( "a<%# ignored %>b\n" )).to eq( "ab\n" )
+    end
+
+    it 'executes a bare code tag without emitting it' do
+      expect(render( "a<% 1 + 1 %>b\n" )).to eq( "ab\n" )
+    end
+
+    it 'handles several tags on one line' do
+      expect(render( "x<%=1%> and <%=2%>\n" )).to eq( "x1 and 2\n" )
+    end
+
+    # The bullseye template ends its coverage lines with a literal percent sign.
+    # Only a percent in column zero is special.
+    it 'leaves a percent elsewhere on the line as literal text' do
+      expect(render( "50% done\nBRANCHES: <%=7%>%\n" )).to eq( "50% done\nBRANCHES: 7%\n" )
+    end
+
+    # The default template uses a tag whose whole purpose is emitting a newline.
+    it 'emits a newline from a tag that produces one' do
+      expect(render( 'a' + "\n" + '<%="\n"%>' + "\n" + 'b' + "\n" )).to eq( "a\n\nb\n" )
+    end
+  end
+
+  describe 'newline trimming' do
+    # A line whose first tag opens it and whose last tag closes it contributes no
+    # newline of its own. Text in the middle does not matter, only the two ends.
+    # Ceedling's templates depend on this to control blank lines in reports.
+    it 'drops the newline when the line both opens and closes with a tag' do
+      expect(render( "<%=1%>\n<%=2%>\n" )).to eq( "12" )
+    end
+
+    it 'drops the newline even when text sits between the opening and closing tags' do
+      expect(render( "<%=1%> and <%=2%>\nrest\n" )).to eq( "1 and 2rest\n" )
+    end
+
+    it 'keeps the newline when text follows the last tag' do
+      expect(render( "<%=1%>x\n" )).to eq( "1x\n" )
+    end
+
+    it 'keeps the newline when text precedes the first tag' do
+      expect(render( "x<%=1%>\n" )).to eq( "x1\n" )
+    end
+
+    it 'preserves a blank line' do
+      expect(render( "a\n\nb\n" )).to eq( "a\n\nb\n" )
+    end
+
+    it 'renders an empty template as an empty string' do
+      expect(render( '' )).to eq( '' )
+    end
+
+    it 'renders a template of only newlines unchanged' do
+      expect(render( "\n\n\n" )).to eq( "\n\n\n" )
+    end
+  end
+
+  describe 'line endings' do
+    # ERB emitted a bare newline after a tag-terminated line rather than echoing the
+    # carriage return it matched, while leaving a plain line's own ending alone.
+    # Reproduced so a template checked out with Windows line endings renders
+    # identically to one checked out with Unix endings.
+    it 'normalizes a carriage return on a tag-terminated line but not on a plain line' do
+      expect(render( "a\r\nb <%=1%>\r\n<%=2%>\r\n" )).to eq( "a\r\nb 1\n2" )
+    end
+
+    it 'does not invent a trailing newline where the template has none' do
+      expect(render( "a\nb" )).to eq( "a\nb" )
+      expect(render( "% x = 1\n<%=x%>" )).to eq( "1" )
+    end
+  end
+
+  describe 'malformed templates' do
+    # ERB treated an unterminated tag as though the rest of the template were Ruby
+    # and silently produced garbage rather than failing. A template author is better
+    # served by an error naming the line.
+    it 'raises naming the line number for an unterminated tag' do
+      expect {
+        render( "fine\nalso fine\nbroken <% oops\n" )
+      }.to raise_error( CeedlingException, /line 3/ )
+    end
+
+    # ERB accepted a tag spanning lines. Ceedling's own templates contain none, and
+    # the documented template language is one tag per line, so this is refused
+    # rather than silently supported.
+    it 'raises for a tag spanning multiple lines' do
+      expect {
+        render( "<%= 1 +\n 1 %>\n" )
+      }.to raise_error( CeedlingException, /line 1/ )
+    end
+  end
+
+  describe 'error reporting' do
+    # A template error has to point at the template line that caused it, otherwise a
+    # plugin author has nothing to go on.
+    it 'reports a Ruby syntax error against the template' do
+      expect {
+        render( "a\nb\n% if true\n" )
+      }.to raise_error( SyntaxError, /\(ceedling template\)/ )
+    end
+
+    # Ruby puts the location in the backtrace rather than the message, which is
+    # where ERB surfaced it too. The frame is matched anywhere in the backtrace
+    # rather than at its head, because the caller's own scope can contribute frames
+    # of its own first. RSpec's method_missing does exactly that here.
+    it 'reports an undefined reference against the template line' do
+      expect {
+        render( "line one\nline two\n<%=nope%>\n" )
+      }.to raise_error( NameError ) { |error|
+        expect(error.backtrace).to include( a_string_matching( /\(ceedling template\):3/ ) )
+      }
+    end
+  end
+
+  describe 'evaluation context' do
+    # No trailing newline, because the line both opens and closes with a tag.
+    it 'evaluates against the binding it is given' do
+      caller_local = 'from the caller'
+      expect(@templateinator.render( "<%=caller_local%>\n", binding )).to eq( 'from the caller' )
+    end
+
+    # Proves the template is evaluated in the caller's scope rather than inside
+    # Templateinator, where render's own parameter name would resolve.
+    it 'does not expose its own locals to the template' do
+      expect {
+        @templateinator.render( "<%=context_binding%>\n", binding )
+      }.to raise_error( NameError, /context_binding/ )
+    end
+  end
+end