ceedling 1.0.0 → 1.1.0

data/spec/units/preprocess/preprocessinator_file_assembler_spec.rb

@@ -0,0 +1,263 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+require 'spec_helper'
+require 'stringio'
+require 'ceedling/preprocess/preprocessinator_file_assembler'
+require 'ceedling/preprocess/preprocessinator_reconstructor'
+require 'ceedling/parsing_parcels'
+require 'ceedling/encodinator'
+
+RSpec.describe PreprocessinatorFileAssembler do
+
+  # Use real ParsingParcels for _filter_conditionals and collect_file_contents_fallback tests
+  let(:real_parsing_parcels) { ParsingParcels.new }
+  let(:real_reconstructor) do
+    PreprocessinatorReconstructor.new({ parsing_parcels: real_parsing_parcels })
+  end
+
+  before :each do
+    @configurator   = double('configurator')
+    @tool_executor  = double('tool_executor')
+    @file_path_utils = double('file_path_utils')
+    @file_wrapper   = double('file_wrapper')
+    @loginator      = double('loginator')
+    @reportinator   = double('reportinator')
+
+    allow(@loginator).to receive(:log)
+    allow(@reportinator).to receive(:generate_module_progress).and_return('')
+  end
+
+  subject do
+    PreprocessinatorFileAssembler.new(
+      {
+        preprocessinator_reconstructor: real_reconstructor,
+        configurator:    @configurator,
+        tool_executor:   @tool_executor,
+        file_path_utils: @file_path_utils,
+        file_wrapper:    @file_wrapper,
+        parsing_parcels: real_parsing_parcels,
+        loginator:       @loginator,
+        reportinator:    @reportinator
+      }
+    )
+  end
+
+  # Helper: stub file_wrapper.open to yield StringIO of content
+  def stub_file_open(filepath, content, mode='rb')
+    allow(@file_wrapper).to receive(:open).with(filepath, mode).and_yield(StringIO.new(content))
+  end
+
+
+  # ===========================================================================
+  describe '#collect_file_contents_fallback' do
+  # ===========================================================================
+
+    let(:filepath) { '/src/module.c' }
+
+
+    context 'preprocessor directive stripping' do
+
+      it 'strips #include directives from output' do
+        stub_file_open(filepath, "#include \"foo.h\"\nint x = 0;\n")
+        result = subject.collect_file_contents_fallback(source_filepath: filepath)
+        expect(result).not_to include('#include "foo.h"')
+        expect(result).to include('int x = 0;')
+      end
+
+      it 'strips #define directives from output' do
+        stub_file_open(filepath, "#define MAX 100\nint x = 0;\n")
+        result = subject.collect_file_contents_fallback(source_filepath: filepath)
+        expect(result).not_to include('#define MAX 100')
+        expect(result).to include('int x = 0;')
+      end
+
+      it 'strips #pragma directives from output' do
+        stub_file_open(filepath, "#pragma once\nint x = 0;\n")
+        result = subject.collect_file_contents_fallback(source_filepath: filepath)
+        expect(result).not_to include('#pragma once')
+        expect(result).to include('int x = 0;')
+      end
+
+      it 'strips #ifdef and #endif directives from output' do
+        content = "#ifdef FOO\nint x = 0;\n#endif\n"
+        stub_file_open(filepath, content)
+        result = subject.collect_file_contents_fallback(source_filepath: filepath, defines: ['FOO'])
+        expect(result.join).not_to match(/#\s*ifdef/)
+        expect(result.join).not_to match(/#\s*endif/)
+      end
+
+      it 'strips #undef directives from output' do
+        stub_file_open(filepath, "#undef MAX\nint x = 0;\n")
+        result = subject.collect_file_contents_fallback(source_filepath: filepath)
+        expect(result).not_to include('#undef MAX')
+        expect(result).to include('int x = 0;')
+      end
+
+      it 'strips directives with leading whitespace' do
+        stub_file_open(filepath, "  #include <stdio.h>\nint x = 0;\n")
+        result = subject.collect_file_contents_fallback(source_filepath: filepath)
+        expect(result.join(' ')).not_to match(/#include/)
+        expect(result).to include('int x = 0;')
+      end
+
+      it 'returns an empty array for a file containing only preprocessor directives' do
+        content = "#include \"foo.h\"\n#define BAR 1\n#pragma once\n"
+        stub_file_open(filepath, content)
+        result = subject.collect_file_contents_fallback(source_filepath: filepath)
+        expect(result.reject { |l| l.strip.empty? }).to be_empty
+      end
+
+    end
+
+
+    context 'code line preservation' do
+
+      it 'preserves function declarations' do
+        stub_file_open(filepath, "void my_func(int x);\n")
+        result = subject.collect_file_contents_fallback(source_filepath: filepath)
+        expect(result).to include('void my_func(int x);')
+      end
+
+      it 'preserves function bodies' do
+        content = "void my_func(void) {\n  return;\n}\n"
+        stub_file_open(filepath, content)
+        result = subject.collect_file_contents_fallback(source_filepath: filepath)
+        expect(result).to include('void my_func(void) {')
+        expect(result).to include('  return;')
+        expect(result).to include('}')
+      end
+
+      it 'preserves inline // comments on code lines' do
+        stub_file_open(filepath, "int x = 0;  // initialize counter\n")
+        result = subject.collect_file_contents_fallback(source_filepath: filepath)
+        expect(result).to include('int x = 0;  // initialize counter')
+      end
+
+      it 'preserves block comments on code lines' do
+        stub_file_open(filepath, "int x = 0; /* zero-init */\n")
+        result = subject.collect_file_contents_fallback(source_filepath: filepath)
+        expect(result).to include('int x = 0; /* zero-init */')
+      end
+
+      it 'preserves standalone comment lines' do
+        stub_file_open(filepath, "/* Full-line comment. */\nint x = 0;\n")
+        result = subject.collect_file_contents_fallback(source_filepath: filepath)
+        expect(result).to include('/* Full-line comment. */')
+      end
+
+    end
+
+
+    context 'conditional filtering with defines' do
+
+      it 'excludes code inside inactive #ifdef block' do
+        content = <<~C
+          int a = 1;
+          #ifdef UNDEFINED_MACRO
+          int b = 2;
+          #endif
+          int c = 3;
+        C
+        stub_file_open(filepath, content)
+        result = subject.collect_file_contents_fallback(source_filepath: filepath, defines: [])
+        lines = result.map(&:strip).reject(&:empty?)
+        expect(lines).to include('int a = 1;')
+        expect(lines).not_to include('int b = 2;')
+        expect(lines).to include('int c = 3;')
+      end
+
+      it 'includes code inside active #ifdef block' do
+        content = <<~C
+          int a = 1;
+          #ifdef MY_FEATURE
+          int b = 2;
+          #endif
+          int c = 3;
+        C
+        stub_file_open(filepath, content)
+        result = subject.collect_file_contents_fallback(
+          source_filepath: filepath, defines: ['MY_FEATURE']
+        )
+        lines = result.map(&:strip).reject(&:empty?)
+        expect(lines).to include('int a = 1;')
+        expect(lines).to include('int b = 2;')
+        expect(lines).to include('int c = 3;')
+      end
+
+      it 'includes #else branch when #ifdef is inactive' do
+        content = <<~C
+          #ifdef PLATFORM_A
+          int platform = 0;
+          #else
+          int platform = 1;
+          #endif
+        C
+        stub_file_open(filepath, content)
+        result = subject.collect_file_contents_fallback(source_filepath: filepath, defines: [])
+        lines = result.map(&:strip).reject(&:empty?)
+        expect(lines).not_to include('int platform = 0;')
+        expect(lines).to include('int platform = 1;')
+      end
+
+      it 'excludes #else branch when #ifdef is active' do
+        content = <<~C
+          #ifdef PLATFORM_A
+          int platform = 0;
+          #else
+          int platform = 1;
+          #endif
+        C
+        stub_file_open(filepath, content)
+        result = subject.collect_file_contents_fallback(
+          source_filepath: filepath, defines: ['PLATFORM_A']
+        )
+        lines = result.map(&:strip).reject(&:empty?)
+        expect(lines).to include('int platform = 0;')
+        expect(lines).not_to include('int platform = 1;')
+      end
+
+    end
+
+
+    context 'encoding safety' do
+
+      it 'does not raise on UTF-8 characters in comments; keeps comment lines in output' do
+        # clean_encoding strips non-ASCII (© etc.) but must not crash.
+        # The comment line itself should still appear in output.
+        stub_file_open(filepath, "/* © 2024 — résumé */\nint x = 0;\n")
+        result = nil
+        expect { result = subject.collect_file_contents_fallback(source_filepath: filepath) }.not_to raise_error
+        expect(result).not_to be_empty
+        expect(result).to include('int x = 0;')
+      end
+
+      it 'does not raise on non-ASCII in kept code lines' do
+        stub_file_open(filepath, "int x = 0;  // naïve\n")
+        expect {
+          result = subject.collect_file_contents_fallback(source_filepath: filepath)
+          expect(result).not_to be_empty
+        }.not_to raise_error
+      end
+
+      it 'does not raise on non-ASCII near conditional directives' do
+        content = "/* © */\n#ifdef FEATURE\nint x = 1;\n#endif\n"
+        stub_file_open(filepath, content)
+        expect {
+          result = subject.collect_file_contents_fallback(
+            source_filepath: filepath, defines: ['FEATURE']
+          )
+          lines = result.map(&:strip).reject(&:empty?)
+          expect(lines).to include('int x = 1;')
+        }.not_to raise_error
+      end
+
+    end
+
+  end
+
+end

data/spec/units/preprocess/preprocessinator_includes_handler_spec.rb

@@ -0,0 +1,337 @@
+# =========================================================================
+#   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 'stringio'
+require 'ceedling/preprocess/preprocessinator_includes_handler'
+require 'ceedling/preprocess/preprocessinator_line_marker_includes_extractor'
+require 'ceedling/parsing_parcels'
+require 'ceedling/includes/includes'
+require 'ceedling/encodinator'
+
+RSpec.describe PreprocessinatorIncludesHandler do
+
+  # Use real ParsingParcels so code_lines / conditional tracking works correctly
+  let(:real_parsing_parcels) { ParsingParcels.new }
+
+  before :each do
+    @configurator    = double('configurator')
+    @include_factory = double('include_factory')
+    @file_wrapper    = double('file_wrapper')
+    @yaml_wrapper    = double('yaml_wrapper')
+    @loginator       = double('loginator')
+    @reportinator    = double('reportinator')
+    @preprocessinator_line_marker_includes_extractor =
+      double('preprocessinator_line_marker_includes_extractor')
+
+    allow(@loginator).to receive(:log)
+    allow(@reportinator).to receive(:generate_module_progress).and_return('')
+
+    # Include factory helpers: return typed Include objects based on the path
+    allow(@include_factory).to receive(:user_include_from_directive) do |line|
+      m = line.match(PATTERNS::USER_INCLUDE_DIRECTIVE_FILENAME)
+      m ? UserInclude.new(m[1]) : nil
+    end
+
+    allow(@include_factory).to receive(:system_include_from_directive) do |line|
+      m = line.match(PATTERNS::SYSTEM_INCLUDE_DIRECTIVE_FILENAME)
+      m ? SystemInclude.new(m[1]) : nil
+    end
+  end
+
+  subject do
+    PreprocessinatorIncludesHandler.new(
+      {
+        configurator:           @configurator,
+        include_factory:        @include_factory,
+        preprocessinator_line_marker_includes_extractor:
+          @preprocessinator_line_marker_includes_extractor,
+        tool_executor:          double('tool_executor'),
+        file_wrapper:           @file_wrapper,
+        yaml_wrapper:           @yaml_wrapper,
+        parsing_parcels:        real_parsing_parcels,
+        loginator:              @loginator,
+        reportinator:           @reportinator
+      }
+    )
+  end
+
+  # Helper: yield StringIO of content from file_wrapper.open
+  def stub_file_open(filepath, content)
+    allow(@file_wrapper).to receive(:open).with(filepath, 'rb').and_yield(StringIO.new(content))
+  end
+
+
+  # ===========================================================================
+  describe '#extract_user_includes_from_text' do
+  # ===========================================================================
+
+    let(:filepath) { '/src/module.c' }
+
+    context 'basic extraction' do
+
+      it 'extracts a simple user include' do
+        stub_file_open(filepath, "#include \"foo.h\"\n")
+        result = subject.extract_user_includes_from_text(name: 'test', filepath: filepath)
+        expect(result.map(&:filename)).to include('foo.h')
+      end
+
+      it 'extracts multiple user includes' do
+        content = "#include \"alpha.h\"\n#include \"beta.h\"\n"
+        stub_file_open(filepath, content)
+        result = subject.extract_user_includes_from_text(name: 'test', filepath: filepath)
+        expect(result.map(&:filename)).to contain_exactly('alpha.h', 'beta.h')
+      end
+
+      it 'does not extract system includes' do
+        stub_file_open(filepath, "#include <stdio.h>\n")
+        result = subject.extract_user_includes_from_text(name: 'test', filepath: filepath)
+        expect(result).to be_empty
+      end
+
+      it 'ignores includes inside line comments' do
+        stub_file_open(filepath, "// #include \"commented_out.h\"\n")
+        result = subject.extract_user_includes_from_text(name: 'test', filepath: filepath)
+        expect(result).to be_empty
+      end
+
+      it 'ignores includes inside block comments' do
+        content = "/* #include \"in_block.h\" */\n#include \"real.h\"\n"
+        stub_file_open(filepath, content)
+        result = subject.extract_user_includes_from_text(name: 'test', filepath: filepath)
+        expect(result.map(&:filename)).to contain_exactly('real.h')
+      end
+
+    end
+
+
+    context 'with defines: [] (no macros defined)' do
+
+      it 'skips include inside #ifdef block when no defines provided' do
+        content = <<~C
+          #include "always.h"
+          #ifdef FEATURE_A
+          #include "conditional.h"
+          #endif
+        C
+        stub_file_open(filepath, content)
+        result = subject.extract_user_includes_from_text(name: 'test', filepath: filepath, defines: [])
+        expect(result.map(&:filename)).to contain_exactly('always.h')
+      end
+
+      it 'includes the #else branch when #ifdef undefined' do
+        content = <<~C
+          #ifdef UNDEFINED
+          #include "a.h"
+          #else
+          #include "b.h"
+          #endif
+        C
+        stub_file_open(filepath, content)
+        result = subject.extract_user_includes_from_text(name: 'test', filepath: filepath, defines: [])
+        expect(result.map(&:filename)).to contain_exactly('b.h')
+      end
+
+    end
+
+
+    context 'with active defines' do
+
+      it 'includes the #ifdef branch when macro is defined' do
+        content = <<~C
+          #ifdef FEATURE_A
+          #include "feature_a.h"
+          #else
+          #include "feature_b.h"
+          #endif
+        C
+        stub_file_open(filepath, content)
+        result = subject.extract_user_includes_from_text(
+          name: 'test', filepath: filepath, defines: ['FEATURE_A']
+        )
+        expect(result.map(&:filename)).to contain_exactly('feature_a.h')
+      end
+
+      it 'skips the #else branch when #ifdef macro is defined' do
+        content = <<~C
+          #ifdef FEATURE_A
+          #include "yes.h"
+          #else
+          #include "no.h"
+          #endif
+        C
+        stub_file_open(filepath, content)
+        result = subject.extract_user_includes_from_text(
+          name: 'test', filepath: filepath, defines: ['FEATURE_A']
+        )
+        expect(result.map(&:filename)).to contain_exactly('yes.h')
+        expect(result.map(&:filename)).not_to include('no.h')
+      end
+
+      it 'handles nested #ifdef correctly' do
+        content = <<~C
+          #ifdef OUTER
+          #include "outer.h"
+          #ifdef INNER
+          #include "inner.h"
+          #endif
+          #endif
+        C
+        stub_file_open(filepath, content)
+        result = subject.extract_user_includes_from_text(
+          name: 'test', filepath: filepath, defines: ['OUTER']
+        )
+        # INNER not defined, so inner.h should be excluded
+        expect(result.map(&:filename)).to contain_exactly('outer.h')
+      end
+
+      it 'handles -D prefix in defines list' do
+        content = <<~C
+          #ifdef FEATURE
+          #include "feature.h"
+          #endif
+        C
+        stub_file_open(filepath, content)
+        result = subject.extract_user_includes_from_text(
+          name: 'test', filepath: filepath, defines: ['-DFEATURE']
+        )
+        expect(result.map(&:filename)).to contain_exactly('feature.h')
+      end
+
+      it 'handles defines with =value suffix' do
+        content = <<~C
+          #ifdef VERSION
+          #include "version.h"
+          #endif
+        C
+        stub_file_open(filepath, content)
+        result = subject.extract_user_includes_from_text(
+          name: 'test', filepath: filepath, defines: ['VERSION=3']
+        )
+        expect(result.map(&:filename)).to contain_exactly('version.h')
+      end
+
+    end
+
+
+    context 'encoding safety' do
+
+      it 'does not raise on non-ASCII UTF-8 characters in comments adjacent to includes' do
+        content = "/* © 2024 Résumé Corp. */\n#include \"safe.h\"\n"
+        stub_file_open(filepath, content)
+        expect {
+          result = subject.extract_user_includes_from_text(name: 'test', filepath: filepath)
+          expect(result.map(&:filename)).to contain_exactly('safe.h')
+        }.not_to raise_error
+      end
+
+      it 'does not raise on non-ASCII near a conditional directive' do
+        content = <<~C
+          /* Ünïcödé header © 2024 */
+          #ifdef FEATURE  /* naïve check */
+          #include "feature.h"
+          #endif
+        C
+        stub_file_open(filepath, content)
+        expect {
+          result = subject.extract_user_includes_from_text(
+            name: 'test', filepath: filepath, defines: ['FEATURE']
+          )
+          expect(result.map(&:filename)).to contain_exactly('feature.h')
+        }.not_to raise_error
+      end
+
+    end
+
+  end
+
+
+  # ===========================================================================
+  describe '#extract_system_includes_from_text' do
+  # ===========================================================================
+
+    let(:filepath) { '/src/module.c' }
+
+    context 'basic extraction' do
+
+      it 'extracts a simple system include' do
+        stub_file_open(filepath, "#include <stdio.h>\n")
+        result = subject.extract_system_includes_from_text(name: 'test', filepath: filepath)
+        expect(result.map(&:filename)).to include('stdio.h')
+      end
+
+      it 'does not extract user includes' do
+        stub_file_open(filepath, "#include \"user.h\"\n")
+        result = subject.extract_system_includes_from_text(name: 'test', filepath: filepath)
+        expect(result).to be_empty
+      end
+
+    end
+
+
+    context 'with conditional filtering' do
+
+      it 'skips system include in inactive #ifdef block' do
+        content = <<~C
+          #include <always.h>
+          #ifdef PLATFORM_A
+          #include <platform_a.h>
+          #endif
+        C
+        stub_file_open(filepath, content)
+        result = subject.extract_system_includes_from_text(
+          name: 'test', filepath: filepath, defines: []
+        )
+        expect(result.map(&:filename)).to contain_exactly('always.h')
+      end
+
+      it 'includes system include in active #ifdef block' do
+        content = <<~C
+          #ifdef USE_STDLIB
+          #include <stdlib.h>
+          #endif
+        C
+        stub_file_open(filepath, content)
+        result = subject.extract_system_includes_from_text(
+          name: 'test', filepath: filepath, defines: ['USE_STDLIB']
+        )
+        expect(result.map(&:filename)).to contain_exactly('stdlib.h')
+      end
+
+      it 'handles #ifndef correctly for system includes' do
+        content = <<~C
+          #ifndef NO_STDLIB
+          #include <stdlib.h>
+          #endif
+        C
+        stub_file_open(filepath, content)
+        # NO_STDLIB is NOT defined, so #ifndef is active → should include
+        result = subject.extract_system_includes_from_text(
+          name: 'test', filepath: filepath, defines: []
+        )
+        expect(result.map(&:filename)).to contain_exactly('stdlib.h')
+      end
+
+    end
+
+
+    context 'encoding safety' do
+
+      it 'does not raise on non-ASCII UTF-8 characters near system includes' do
+        content = "/* Résumé header © */\n#include <system.h>\n"
+        stub_file_open(filepath, content)
+        expect {
+          result = subject.extract_system_includes_from_text(name: 'test', filepath: filepath)
+          expect(result.map(&:filename)).to contain_exactly('system.h')
+        }.not_to raise_error
+      end
+
+    end
+
+  end
+
+end