ceedling 1.1.4 → 1.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d8c20196572fb2d9730237fb04f7ab5d18869180b185e14649d1212669b1fd3f
-  data.tar.gz: b363d61a395c3a788fbe4566196d2ce6f6c49e5a8b00423f49c4df3fc2e3f2e1
+  metadata.gz: a54ad80f099a4117063db064305062de3ef308e0d6a34f5285ad616540c21239
+  data.tar.gz: aad1cd6bf73dc6710908593a9ec0c493404f13c1ecce8d7f285c2cd537b41b7f
 SHA512:
-  metadata.gz: 1c30b50264e5a459a19c0fca20b57fdc1e2e3cc6282b504f5789c2cec47fd9dc11d49cd05c5ecb8e09c47c6e1bb9b7029d74ce7714249abc9e00456ead5d1002
-  data.tar.gz: a83eddeb44b9049e361f94ef0280809f157f304c96631ef75ee7341302a34faed50ed4e616d1744e220dccad496872e0c2282b8f7d5e6c4c1e58c5be28fddf32
+  metadata.gz: 0ee2a51402a1ca62a0e42f5c9c0b7cfb47871b4723fd33096ef22d90c0dc5ae7c7eb7944833e354a745c9d1123192ed6b92fb195537a8c9d69bd9c81e0330530
+  data.tar.gz: 2bfd96e070e2fa703f08e85587296690a930734a5eb409c709fd5bca2cd2875aa0b9eb8cb1dca9484852ab37ffc668f9d387fce1ed0c05fc90cd69507982dbcd

data/GIT_COMMIT_SHA

@@ -1 +1 @@
-e44173e
+57b6a98

data/README.md

@@ -1,7 +1,7 @@
 Ceedling ![CI](https://github.com/ThrowTheSwitch/Ceedling/workflows/CI/badge.svg)
 ========
 
-**Ceedling 1.1.4** is the latest and greatest.
+**Ceedling 1.1.5** is the latest and greatest.
 
 See [_Release Notes_][release-notes], [_Changelog_](docs/Changelog.md), 
 [_Breaking Changes_][breaking-changes], and [_Known Issues_][known-issues].

data/docs/Changelog.md

@@ -10,6 +10,17 @@ This changelog is complemented by three other documents:
 
 ---
 
+# [1.1.5] — 2026-08-19
+
+## 💪 Fixed
+
+### Partials
+
+- Fixed shared generated Partial types header filename being derived from the test's name rather than partialized module's own name. Two modules Partialized in the same test could silently overwrite each other's content.
+- [#1210](https://github.com/ThrowTheSwitch/Ceedling/issues/1210) Fixed macros missing from shared Partial types header file emitted when two Partials both depend on the same types and related in common.
+
+---
+
 # [1.1.4] — 2026-08-13
 
 ## 💪 Fixed

data/docs/mkdocs/configuration/reference/partials.md

@@ -14,24 +14,24 @@
 ## `:max_extraction_length`
 
 Notes:
+
 - The default should be sufficient for nearly all test builds. Modification should only be necessary on error.
 - This configuration option is only available in Ceedling 1.1.4+.
 
 Building a Partial requires Ceedling to extract each C construct — a
 variable declaration, a function, a macro, and so on — from your source
 files one at a time. Extraction reads a construct into a growing buffer
-until it finds that construct's natural end (a terminating `;`, a closing
+until it finds that construct’s natural end (a terminating `;`, a closing
 `}`, etc.). This setting bounds how large that buffer may grow before
-extraction fails outright, rather than continuing to search indefinitely
-into whatever else follows in the file.
+extraction fails outright.
 
-The value is a multiplier of 1000 characters, not a raw character count —
-`8000` means 8,000,000 characters. It must be a whole number no smaller
+The value is a multiplier of 1000 characters, not a raw character count. For example,
+`8000` means 8,000,000 characters (approx. 7.6MB). It must be a whole number no smaller
 than `10` (10,000 characters).
 
 Raise this value if Ceedling reports an extraction failure for a
-legitimately large single construct in your codebase — a sizable generated
-lookup table, for instance. There's ordinarily no reason to lower it.
+legitimately large single construct in your codebase (e.g. a sizable
+lookup table). Ordinarily, there’s no reason to lower it.
 
 **Default**: 5000 (5,000,000 characters)
 

data/lib/ceedling/generators/generator_partials.rb

@@ -82,8 +82,27 @@ class GeneratorPartials
       file << "#define #{guard}\n\n"
 
       anything_emitted = false
+      pending_macros = []
+
       c_module.element_sequence.each do |item|
-        next unless item.is_a?(CExtractorTypes::CStatement) && type_defining?(item, c_module)
+        next unless item.is_a?(CExtractorTypes::CStatement)
+
+        if c_module.macro_definitions.include?(item)
+          pending_macros << item
+          next
+        end
+
+        next unless type_defining?(item, c_module)
+
+        # A typedef/struct/enum moved here may depend on a macro (e.g. an array-size
+        # constant) that preceded it in the original source -- this header is #included
+        # before any macro generate_header later emits inline into the non-shared
+        # header, so that macro would otherwise be undefined here. Carrying it forward
+        # is safe: an identical #define may legally repeat, so generate_header's own
+        # unmodified inline copy causes no redefinition conflict.
+        pending_macros.each { |macro| file << macro.text << "\n" }
+        pending_macros.clear
+
         file << item.text << "\n"
         anything_emitted = true
       end

data/lib/ceedling/test_invoker/test_build_executor.rb

@@ -187,7 +187,9 @@ class TestBuildExecutor
       # their own includes lists), so a module tested and mocked in the same test file gets
       # exactly one C definition of each of its typedefs and aggregate types.
       types_header = @generator.generate_partial_types(
-        name:        name,
+        name:        config.module, # Module name, not test name -- two modules Partialed
+                                     # in the same test file must not collide on one
+                                     # shared types header filename
         c_module:    module_contents,
         output_path: testable.paths[:partials]
       )

data/lib/version.rb

@@ -15,7 +15,7 @@
 module Ceedling
   module Version
     # Convenience constants for gem building, etc.
-    GEM = '1.1.4'
+    GEM = '1.1.5'
     TAG = GEM
 
     # If run as a script print Ceedling's version to $stdout

data/site-local/configuration/reference/partials.html

@@ -4162,22 +4162,23 @@
 <a id="__codelineno-0-4" name="__codelineno-0-4" href="#__codelineno-0-4"></a><span class="w">  </span><span class="nt">:max_extraction_length</span><span class="p">:</span><span class="w"> </span><span class="l l-Scalar l-Scalar-Plain">8000</span>
 </code></pre></div>
 <h2 id="max_extraction_length"><code>:max_extraction_length</code></h2>
-<p>Notes:
-- The default should be sufficient for nearly all test builds. Modification should only be necessary on error.
-- This configuration option is only available in Ceedling 1.1.4+.</p>
+<p>Notes:</p>
+<ul>
+<li>The default should be sufficient for nearly all test builds. Modification should only be necessary on error.</li>
+<li>This configuration option is only available in Ceedling 1.1.4+.</li>
+</ul>
 <p>Building a Partial requires Ceedling to extract each C construct — a
 variable declaration, a function, a macro, and so on — from your source
 files one at a time. Extraction reads a construct into a growing buffer
-until it finds that construct's natural end (a terminating <code>;</code>, a closing
+until it finds that construct’s natural end (a terminating <code>;</code>, a closing
 <code>}</code>, etc.). This setting bounds how large that buffer may grow before
-extraction fails outright, rather than continuing to search indefinitely
-into whatever else follows in the file.</p>
-<p>The value is a multiplier of 1000 characters, not a raw character count —
-<code>8000</code> means 8,000,000 characters. It must be a whole number no smaller
+extraction fails outright.</p>
+<p>The value is a multiplier of 1000 characters, not a raw character count. For example,
+<code>8000</code> means 8,000,000 characters (approx. 7.6MB). It must be a whole number no smaller
 than <code>10</code> (10,000 characters).</p>
 <p>Raise this value if Ceedling reports an extraction failure for a
-legitimately large single construct in your codebase — a sizable generated
-lookup table, for instance. There's ordinarily no reason to lower it.</p>
+legitimately large single construct in your codebase (e.g. a sizable
+lookup table). Ordinarily, there’s no reason to lower it.</p>
 <p><strong>Default</strong>: 5000 (5,000,000 characters)</p>
 <p><br/><br/></p>
 

data/spec/units/generators/generator_partials_spec.rb

@@ -241,12 +241,13 @@ describe GeneratorPartials do
       expect(result).to be_nil
     end
 
-    it "writes only the typedefs and aggregate definitions, guarded and in element_sequence order, and returns the bare filename" do
+    it "writes the typedefs and aggregate definitions, guarded and in element_sequence order, carrying forward a macro that precedes one of them, and returns the bare filename" do
       file_contents = <<~CONTENTS
       #ifndef __CEEDLING_GENERATED_MY_MODULE_TYPES_H__
       #define __CEEDLING_GENERATED_MY_MODULE_TYPES_H__
 
       typedef uint8_t Byte;
+      #define FOO 1
       struct Config { int id; };
 
       #endif // __CEEDLING_GENERATED_MY_MODULE_TYPES_H__
@@ -267,13 +268,15 @@ describe GeneratorPartials do
         .with(expected_filepath, 'wb')
         .and_yield(buf)
 
-      # A macro and a variable sit between the two type-defining statements in
-      # element_sequence; only the typedef and the aggregate belong in the shared
-      # types header, in their original relative order, and neither the macro nor
-      # the variable (which stay behind for generate_header) appear here at all.
+      # A variable and a macro sit between the two type-defining statements in
+      # element_sequence. The variable (which stays behind for generate_header) is
+      # entirely absent here, but the macro precedes the aggregate and is carried
+      # forward immediately before it -- the aggregate's definition may depend on it
+      # (e.g. an array-size constant), and this header is #included before
+      # generate_header's own later, inline copy of that same macro would exist.
       typedef_stmt   = CExtractorTypes::CStatement.new(text: "typedef uint8_t Byte;", line_num: 1)
-      macro_stmt     = CExtractorTypes::CStatement.new(text: "#define FOO 1", line_num: 2)
-      var_decl       = make_var(name: 'counter', type: 'int', text: 'int counter;', line_num: 3)
+      var_decl       = make_var(name: 'counter', type: 'int', text: 'int counter;', line_num: 2)
+      macro_stmt     = CExtractorTypes::CStatement.new(text: "#define FOO 1", line_num: 3)
       aggregate_stmt = CExtractorTypes::CStatement.new(text: "struct Config { int id; };", line_num: 4)
 
       c_module = CExtractorTypes::CModule.new(
@@ -281,7 +284,7 @@ describe GeneratorPartials do
         macro_definitions:     [macro_stmt],
         variable_declarations: [var_decl],
         aggregate_definitions: [aggregate_stmt],
-        element_sequence:      [typedef_stmt, macro_stmt, var_decl, aggregate_stmt]
+        element_sequence:      [typedef_stmt, var_decl, macro_stmt, aggregate_stmt]
       )
 
       result = @generator.generate_types(
@@ -294,6 +297,106 @@ describe GeneratorPartials do
       expect(@file_wrapper).to have_received(:open).with(expected_filepath, 'wb')
       expect(result).to eq(header_filename)
     end
+
+    it "carries a macro forward directly before the single typedef it immediately precedes" do
+      output_path = '/path/to/output'
+      name = 'my_module'
+      header_filename = 'my_module_types.h'
+      expected_filepath = File.join(output_path, header_filename)
+
+      allow(@file_path_utils).to receive(:form_partial_types_header_filename).and_return(header_filename)
+
+      buf = StringIO.new()
+      allow(@file_wrapper).to receive(:open).and_yield(buf)
+
+      macro_stmt   = CExtractorTypes::CStatement.new(text: "#define LOCAL_CAPACITY 4", line_num: 1)
+      typedef_stmt = CExtractorTypes::CStatement.new(text: "typedef struct { int values[LOCAL_CAPACITY]; } Context;", line_num: 3)
+
+      c_module = CExtractorTypes::CModule.new(
+        type_definitions:  [typedef_stmt],
+        macro_definitions: [macro_stmt],
+        element_sequence:  [macro_stmt, typedef_stmt]
+      )
+
+      @generator.generate_types(name: name, c_module: c_module, output_path: output_path)
+
+      expect( buf.string ).to include( "#define LOCAL_CAPACITY 4\ntypedef struct { int values[LOCAL_CAPACITY]; } Context;\n" )
+    end
+
+    it "carries forward multiple macros preceding one type-defining item, in their own original relative order" do
+      output_path = '/path/to/output'
+      name = 'my_module'
+      header_filename = 'my_module_types.h'
+
+      allow(@file_path_utils).to receive(:form_partial_types_header_filename).and_return(header_filename)
+
+      buf = StringIO.new()
+      allow(@file_wrapper).to receive(:open).and_yield(buf)
+
+      macro_a      = CExtractorTypes::CStatement.new(text: "#define WIDTH 4", line_num: 1)
+      macro_b      = CExtractorTypes::CStatement.new(text: "#define HEIGHT 8", line_num: 2)
+      typedef_stmt = CExtractorTypes::CStatement.new(text: "typedef int Grid[WIDTH][HEIGHT];", line_num: 3)
+
+      c_module = CExtractorTypes::CModule.new(
+        type_definitions:  [typedef_stmt],
+        macro_definitions: [macro_a, macro_b],
+        element_sequence:  [macro_a, macro_b, typedef_stmt]
+      )
+
+      @generator.generate_types(name: name, c_module: c_module, output_path: output_path)
+
+      expect( buf.string ).to include( "#define WIDTH 4\n#define HEIGHT 8\ntypedef int Grid[WIDTH][HEIGHT];\n" )
+    end
+
+    it "carries a macro forward only once, before the first type-defining item it precedes, not before a later one too" do
+      output_path = '/path/to/output'
+      name = 'my_module'
+      header_filename = 'my_module_types.h'
+
+      allow(@file_path_utils).to receive(:form_partial_types_header_filename).and_return(header_filename)
+
+      buf = StringIO.new()
+      allow(@file_wrapper).to receive(:open).and_yield(buf)
+
+      macro_stmt     = CExtractorTypes::CStatement.new(text: "#define FOO 1", line_num: 1)
+      typedef_stmt   = CExtractorTypes::CStatement.new(text: "typedef int Foo;", line_num: 2)
+      aggregate_stmt = CExtractorTypes::CStatement.new(text: "struct Bar { int x; };", line_num: 3)
+
+      c_module = CExtractorTypes::CModule.new(
+        type_definitions:      [typedef_stmt],
+        macro_definitions:     [macro_stmt],
+        aggregate_definitions: [aggregate_stmt],
+        element_sequence:      [macro_stmt, typedef_stmt, aggregate_stmt]
+      )
+
+      @generator.generate_types(name: name, c_module: c_module, output_path: output_path)
+
+      expect( buf.string.scan("#define FOO 1").length ).to eq(1)
+    end
+
+    it "does not carry a macro into the shared header when it appears only after every type-defining item" do
+      output_path = '/path/to/output'
+      name = 'my_module'
+      header_filename = 'my_module_types.h'
+
+      allow(@file_path_utils).to receive(:form_partial_types_header_filename).and_return(header_filename)
+
+      buf = StringIO.new()
+      allow(@file_wrapper).to receive(:open).and_yield(buf)
+
+      typedef_stmt = CExtractorTypes::CStatement.new(text: "typedef int Foo;", line_num: 1)
+      macro_stmt   = CExtractorTypes::CStatement.new(text: "#define FOO 1", line_num: 2)
+
+      c_module = CExtractorTypes::CModule.new(
+        type_definitions:  [typedef_stmt],
+        macro_definitions: [macro_stmt],
+        element_sequence:  [typedef_stmt, macro_stmt]
+      )
+
+      @generator.generate_types(name: name, c_module: c_module, output_path: output_path)
+
+      expect( buf.string ).to_not include("#define FOO 1")
+    end
   end
 
   context "#generate_header (private method)" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ceedling
 version: !ruby/object:Gem::Version
-  version: 1.1.4
+  version: 1.1.5
 platform: ruby
 authors:
 - Mark VanderVoord
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-08-14 00:00:00.000000000 Z
+date: 2026-08-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake