ceedling 1.1.9 → 1.2.0

data/lib/ceedling/preprocess/preprocessinator_reconstructor.rb

@@ -8,6 +8,7 @@
 require 'ceedling/constants'
 require 'ceedling/encodinator'
 require 'ceedling/parsing_parcels'
+require 'ceedling/exceptions'
 
 class PreprocessinatorReconstructor
 
@@ -105,14 +106,25 @@ class PreprocessinatorReconstructor
   # then delegates to `compact_from_expansion` with the resulting IO objects.
   def compact_file_from_expansion(input_filepath:, source_filepath:, output_filepath:)
     # Binary mode on both ends: GCC output under non-C locale contains non-ASCII
-    # bytes (localized markers; per-line clean_encoding in _scan_expansion_for_file
-    # handles content), and the compacted output is read again downstream by code
-    # that depends on its line count being exact. Windows text mode would rewrite
-    # "\n" to "\r\n" on write, which this content must not be subject to.
-    @file_wrapper.open( input_filepath, 'rb' ) do |input|
-      @file_wrapper.open( output_filepath, 'wb' ) do |output|
-        compact_from_expansion( input: input, filepath: source_filepath, output: output )
+    # bytes (localized markers; the whole-buffer clean_encoding in
+    # _scan_expansion_for_file handles content), and the compacted output is
+    # read again downstream by code that depends on its line count being exact.
+    # Windows text mode would rewrite "\n" to "\r\n" on write, which this
+    # content must not be subject to.
+    # `input_filepath` is this same build's own gcc expansion output -- open_with_retry
+    # rides out the file briefly not yet being visible right after the shell-out exits.
+    # `output_filepath` is a fresh write, not a read of something just produced, so it
+    # stays a plain open. Both opens stay nested (compact_from_expansion streams straight
+    # from input to output rather than buffering) so one rescue wraps the pair, same as
+    # strip_file's own single rescue around its one file operation.
+    begin
+      @file_wrapper.open_with_retry( input_filepath, 'rb' ) do |input|
+        @file_wrapper.open( output_filepath, 'wb' ) do |output|
+          compact_from_expansion( input: input, filepath: source_filepath, output: output )
+        end
       end
+    rescue => e
+      raise CeedlingException.new("Failed to compact expansion output for '#{input_filepath}' ⏩️ #{e}")
     end
   end
 
@@ -188,7 +200,7 @@ class PreprocessinatorReconstructor
       # directive to, and dropping it silently is correct: an orphaned directive is inert.
       index = nil
       contents[cursor..-1].each_with_index do |line, offset|
-        if line =~ function_regex
+        if line.match?(function_regex)
           index = cursor + offset
           break
         end
@@ -307,20 +319,28 @@ class PreprocessinatorReconstructor
     # Yields pending_line (and any pending blank lines) then clears the buffer
     flush = lambda do
       unless pending_line.nil?
-        block.call( pending_line )
-        pending_blank_count.times { block.call( '' ) }
+        yield( pending_line )
+        pending_blank_count.times { yield( '' ) }
         pending_line  = nil
         pending_blank_count = 0
       end
     end
 
-    # Use `each_line()` instead of `readlines()` (chomp removes newlines).
-    # `each_line()` processes the IO buffer one line at a time instead of ingesting lines in an array.
-    # At large buffer sizes needed for potentially lengthy preprocessor output this is far more memory efficient and faster.
-    input.each_line( chomp:true ) do |line|
+    # Clean the whole buffer once rather than line-by-line: clean_encoding's cost
+    # (a double ASCII/UTF-8 transcode) scales with call count as much as with
+    # content size, and GCC's expansion output can run to many times the original
+    # source's line count -- one whole-buffer clean produces byte-for-byte
+    # identical per-line content to cleaning after each_line's split (CRLF is
+    # still normalized before chomp ever sees it; invalid byte sequences are
+    # replaced independently of where a line boundary happens to fall either
+    # way). Trades the prior line-at-a-time memory streaming for far fewer,
+    # larger encode() calls -- worthwhile for realistic single-file expansion
+    # output sizes.
+    content = input.read.clean_encoding
 
-      # Clean up any oddball characters in an otherwise ASCII document
-      line = line.clean_encoding
+    # Use `each_line()` instead of `readlines()` (chomp removes newlines).
+    # `each_line()` processes the buffer one line at a time instead of ingesting lines in an array.
+    content.each_line( chomp:true ) do |line|
 
       # Handle expansion extraction if the line is not a preprocessor directive
       if extract and not line =~ directive
@@ -352,13 +372,14 @@ class PreprocessinatorReconstructor
         extract = false
       end
 
-      # Enter extract mode if the line is a preprocessor line marker with filepath of interest
+      # Enter extract mode if the line is a preprocessor line marker with filepath of interest.
+      # Only its own markers move the line counts. Another file's line number carried back
+      # would make the next line here read as a continuation of the one before it.
       matches = line.match( line_marker )
-      if matches and matches.size() > 2
+      if matches and matches.size() > 2 and extraction_filepath == File.expand_path( matches[2].strip() )
         last_line_num = line_num
         line_num = (matches[1].to_i - 1)
-        fp = File.expand_path( matches[2].strip() )
-        extract = true if extraction_filepath == fp
+        extract = true
       end
     end
 

data/lib/ceedling/quote_include_isolator.rb

@@ -0,0 +1,129 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+require 'ceedling/constants'
+
+# Stages files away from their neighbors so a quoted #include cannot reach one.
+#
+# C's `#include "..."` checks the including file's own directory before any -I search
+# path. A file staged alone in a fresh directory has no neighbors there, so its quoted
+# includes fall through to the search paths. Mocks and Partials substitute a header only
+# by search-path order, so Ceedling stages a file whenever a real header beside it would
+# otherwise win (see test_invoker/HEADER_COLLISIONS.md).
+#
+# Callers decide when isolation applies and which search paths follow it. This class
+# owns staging, release, and mapping a copy's path back to its original. It keeps no
+# state between calls, so one instance serves every thread.
+class QuoteIncludeIsolator
+
+  constructor :file_wrapper, :loginator
+
+  # One staged directory and the originals copied into it, keyed original => copy.
+  Isolation = Struct.new( :dir, :copies ) do
+    def copy_of(original)
+      copies.fetch( original )
+    end
+
+    # Replaces every copy's path in `text` with its original's.
+    #
+    # gcc writes a space in a dependency path as `\ `, so the escaped form is replaced
+    # too. Paths take on `text`'s own encoding so binary file content stays comparable.
+    def restore_paths(text)
+      copies.reduce( text ) do |restored, (original, copy)|
+        restored = replace( restored, make_escaped( copy ), make_escaped( original ) )
+        replace( restored, copy, original )
+      end
+    end
+
+    private
+
+    def make_escaped(path)
+      path.gsub( ' ' ) { '\\ ' }
+    end
+
+    # A block replacement keeps backslashes in a Windows path literal.
+    def replace(text, from, to)
+      text.gsub( from.dup.force_encoding( text.encoding ) ) { to.dup.force_encoding( text.encoding ) }
+    end
+  end
+
+  # Copies each of `files` alone into one fresh directory nested inside `parent`.
+  #
+  # A copy is named by basename alone so the directory holds nothing but what was staged.
+  # `preserve_location` opens each copy with a `#line` directive naming its original.
+  # Diagnostics, `__FILE__`, debug info and coverage data then report the original file
+  # at its original line numbers. The caller releases the result.
+  def isolate(parent:, files:, preserve_location: false)
+    dir    = @file_wrapper.mkdir_tmp( nil, parent )
+    copies = files.to_h { |file| [file, stage_copy( file, dir, preserve_location )] }
+
+    return Isolation.new( dir, copies )
+  end
+
+  # Stages `files` for the duration of the block alone.
+  def within(parent:, files:, preserve_location: false)
+    isolation = isolate( parent: parent, files: files, preserve_location: preserve_location )
+    yield isolation
+  ensure
+    release( isolation.dir ) if isolation
+  end
+
+  def release(dir)
+    @loginator.log( "Removing isolated directory '#{dir}'", Verbosity::DEBUG )
+    @file_wrapper.rm_rf( dir )
+  end
+
+  # Rewrites a dependency file so it names each original rather than its copy.
+  #
+  # A compiler records the file it was handed, which for an isolated compile is the copy.
+  # The copy disappears on release, so a dependency list still naming it would read as a
+  # vanished antecedent on the next build. Bytes are preserved, line endings included.
+  def restore_dependencies(isolation, filepath)
+    return unless @file_wrapper.exist_with_retry?( filepath )
+
+    content  = @file_wrapper.read_binary( filepath )
+    restored = isolation.restore_paths( content )
+
+    @file_wrapper.write( filepath, restored, 'wb' ) unless restored == content
+  end
+
+  # Whether `file` quote-includes a header named `basename`.
+  #
+  # This is the mechanism that lets `file` reach a real header beside it. A path prefix
+  # ahead of the name still matches. The scan is literal text, with no macro expansion
+  # and no conditional evaluation, so a computed #include can be missed and one behind a
+  # false condition can match. Either miss only changes whether a rare case is isolated.
+  # It never invents a substitution risk where none exists.
+  def includes_by_name?(file, basename)
+    return false unless @file_wrapper.exist?( file )
+
+    content = @file_wrapper.read( file )
+    content.match?( /#include\s*"(?:[^"]*\/)?#{Regexp.escape( basename )}"/ )
+  end
+
+  private
+
+  def stage_copy(file, dir, preserve_location)
+    copy = File.join( dir, File.basename( file ) )
+
+    if preserve_location
+      @file_wrapper.write( copy, line_directive( file ) + @file_wrapper.read_binary( file ), 'wb' )
+    else
+      @file_wrapper.cp( file, copy )
+    end
+
+    @loginator.log( "Staged isolated copy: '#{file}' -> '#{copy}'", Verbosity::DEBUG )
+    copy
+  end
+
+  # A C string literal needs its backslashes and quotes escaped, as in a Windows path.
+  def line_directive(file)
+    escaped = file.gsub( '\\' ) { '\\\\' }.gsub( '"' ) { '\\"' }
+    "#line 1 \"#{escaped}\"\n".b
+  end
+
+end

data/lib/ceedling/rake_app/rake_task_registry.rb

@@ -43,13 +43,13 @@
 class RakeTaskRegistry
 
   # Semantic tag constants — used as keys in the namespace_tags registry
-  TAG_TEST    = :test
-  TAG_RELEASE = :release
-  TAG_BUILD   = :build
+  TAG_TEST    = :test    unless const_defined?(:TAG_TEST, false)
+  TAG_RELEASE = :release unless const_defined?(:TAG_RELEASE, false)
+  TAG_BUILD   = :build   unless const_defined?(:TAG_BUILD, false)
 
   # Composite tag sets — applied as a group when registering a domain
-  TAGS_TEST    = [TAG_TEST,    TAG_BUILD].freeze
-  TAGS_RELEASE = [TAG_RELEASE, TAG_BUILD].freeze
+  TAGS_TEST    = [TAG_TEST,    TAG_BUILD].freeze unless const_defined?(:TAGS_TEST, false)
+  TAGS_RELEASE = [TAG_RELEASE, TAG_BUILD].freeze unless const_defined?(:TAGS_RELEASE, false)
 
   # Marker regexes — a line matching any marker signals the enclosing namespace
   # belongs to the associated domain.
@@ -58,10 +58,10 @@ class RakeTaskRegistry
   #   @ceedling[:test_invoker].setup_and_invoke(
   #
   # MARKER_RELEASE_TASKS matches any call of the form:
-  #   @ceedling[:release_invoker].setup_and_invoke_objects(
+  #   @ceedling[:release_invoker].setup_and_invoke(
 
-  MARKER_TEST_TASKS_SETUP_AND_INVOKE = /\[\s*:test_invoker\s*\]\.setup_and_invoke/
-  MARKER_RELEASE_TASKS               = /\[\s*:release_invoker\s*\]\.setup_and_invoke_objects/
+  MARKER_TEST_TASKS_SETUP_AND_INVOKE = /\[\s*:test_invoker\s*\]\.setup_and_invoke/ unless const_defined?(:MARKER_TEST_TASKS_SETUP_AND_INVOKE, false)
+  MARKER_RELEASE_TASKS               = /\[\s*:release_invoker\s*\]\.setup_and_invoke/ unless const_defined?(:MARKER_RELEASE_TASKS, false)
 
   def initialize
     # Maps root namespace string → Array<Symbol> of semantic tags
@@ -189,7 +189,7 @@ class RakeTaskRegistry
         namespace_name =
           if raw.start_with?( ':' )
             raw[1..]                        # :symbol → 'symbol'
-          elsif raw =~ /^[A-Z_]+$/
+          elsif raw.match?(/^[A-Z_]+$/)
             begin
               Object.const_get( raw ).to_s  # CONSTANT → resolve at runtime
             rescue NameError

data/lib/ceedling/rake_app/rake_wrapper.rb

@@ -7,7 +7,6 @@
 
 require 'rubygems'
 require 'rake'
-require 'ceedling/makefile' # our replacement for rake's make-style dependency loader
 
 include Rake::DSL if defined?(Rake::DSL)
 
@@ -17,10 +16,6 @@ end
 
 class RakeWrapper
 
-  def initialize
-    @makefile_loader = Rake::MakefileLoader.new # use our custom replacement noted above
-  end
-
   def [](task)
     return Rake::Task[task]
   end
@@ -29,12 +24,4 @@ class RakeWrapper
     return Rake::Task.tasks
   end
 
-  def create_file_task(file_task, dependencies)
-    file(file_task => dependencies)
-  end
-
-  def load_dependencies(dependencies_path)
-    @makefile_loader.load(dependencies_path)
-  end
-
 end

data/lib/ceedling/rake_app/rakefile_component_resolver.rb

@@ -5,23 +5,35 @@
 #   SPDX-License-Identifier: MIT
 # =========================================================================
 
+require 'ceedling/constants'
+
 # Resolves the ordered list of .rake files Ceedling will load for a given project
 # configuration. Callable from both bin/ (early, before do_setup) and lib/ (within
 # ConfiguratorPlugins). Config must be in structured (pre-flatten) format.
 module RakefileComponentResolver
   module_function
 
-  STOCK_RAKE_FILES = %w[
-    tasks_base.rake
-    tasks_filesystem.rake
-    tasks_tests.rake
-    rules_tests.rake
-  ].freeze
+  RAKEFILES_DIR = 'rakefiles' unless const_defined?(:RAKEFILES_DIR, false)
+
+  # Every .rake file in lib/ceedling/rakefiles/<subdir>, sorted for deterministic,
+  # platform-independent ordering -- stock/release Rakefiles are discovered by role
+  # subdirectory rather than named individually, so adding or removing one there
+  # never requires updating a list anywhere else.
+  def gather_rakefiles(ceedling_lib_path, subdir)
+    Dir.glob( File.join(ceedling_lib_path, RAKEFILES_DIR, subdir, '*.rake') ).sort
+  end
+
+  def base_rakefiles(ceedling_lib_path)
+    gather_rakefiles(ceedling_lib_path, 'base')
+  end
+
+  def test_rakefiles(ceedling_lib_path)
+    gather_rakefiles(ceedling_lib_path, 'tests')
+  end
 
-  RELEASE_RAKE_FILES = %w[
-    rules_release.rake
-    tasks_release.rake
-  ].freeze
+  def release_rakefiles(ceedling_lib_path)
+    gather_rakefiles(ceedling_lib_path, 'release')
+  end
 
   # Returns ordered plugin search paths: user-configured paths first, built-in Ceedling
   # plugins path last. This ordering lets user plugins shadow built-in plugins of the
@@ -40,10 +52,10 @@ module RakefileComponentResolver
   #   - Conditional stock files (rules_release, tasks_release if release_build is enabled)
   #   - Plugin .rake files (first matching <root>/<plugin>/<plugin>.rake across load_paths)
   def resolve(config, ceedling_lib_path, ceedling_plugins_path)
-    paths = STOCK_RAKE_FILES.map { |f| File.join(ceedling_lib_path, f) }
+    paths = base_rakefiles(ceedling_lib_path) + test_rakefiles(ceedling_lib_path)
 
     if config.dig(:project, :release_build)
-      RELEASE_RAKE_FILES.each { |f| paths << File.join(ceedling_lib_path, f) }
+      paths.concat( release_rakefiles(ceedling_lib_path) )
     end
 
     paths.concat(

data/lib/ceedling/rakefile.rb

@@ -16,6 +16,7 @@ Dir.glob(File.join(CEEDLING_APPCFG[:ceedling_lib_path], '**/')).each do |dir|
 end
 
 require 'rake'
+require 'rake_patches'
 
 # Let's make sure we remember the task descriptions in case we need them
 Rake::TaskManager.record_task_metadata = true
@@ -33,7 +34,7 @@ def log_runtime(run, start_time_s, end_time_s, enabled)
 
   return if duration.empty?
 
-  @ceedling[:loginator].log( "\nCeedling #{run} completed in #{duration}", Verbosity::NORMAL)
+  @ceedling[:loginator].log( "\nCeedling #{run} completed in #{duration}\n\n", Verbosity::NORMAL)
 end
 
 start_time = nil # Outside scope of exception handling

data/lib/ceedling/{tasks_base.rake → rakefiles/base/tasks_base.rake}

@@ -23,7 +23,7 @@ task :debug do
 end
 
 # non advertised sanity checking task
-task :sanity_checks, :level do |t, args|
+task :sanity_checks, :level do |_t, args|
   check_level = args.level.to_i
   @ceedling[:configurator].sanity_checks = check_level
 end

data/lib/ceedling/{tasks_filesystem.rake → rakefiles/base/tasks_filesystem.rake}

@@ -22,6 +22,9 @@ CLOBBER.include(File.join(PROJECT_BUILD_ARTIFACTS_ROOT, '**/*'))
 CLOBBER.include(File.join(PROJECT_BUILD_TESTS_ROOT, '**/*'))
 CLOBBER.include(File.join(PROJECT_BUILD_RELEASE_ROOT, '**/*'))
 CLOBBER.include(File.join(PROJECT_LOG_PATH, '**/*'))
+CLOBBER.include(File.join(PROJECT_BUILD_DEPENDENCIES_CACHE_PATH, '**/*'))
+# Rake's globs never match dotfiles, and each dependency cache is one
+CLOBBER.include(File.join(PROJECT_BUILD_DEPENDENCIES_CACHE_PATH, ".*.#{Dependinator::CACHE_FILENAME}"))
 
 # just in case they're using git, let's make sure we allow them to preserved the build directory if desired.
 CLOBBER.exclude(File.join(TESTS_BASE_PATH), '**/.gitkeep')

data/lib/ceedling/rakefiles/release/rules_release.rake

@@ -0,0 +1,52 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+RELEASE_COMPILE_TASK_ROOT  = RELEASE_TASK_ROOT + 'compile:'  unless defined?(RELEASE_COMPILE_TASK_ROOT)
+RELEASE_ASSEMBLE_TASK_ROOT = RELEASE_TASK_ROOT + 'assemble:' unless defined?(RELEASE_ASSEMBLE_TASK_ROOT)
+
+# A single `namespace RELEASE_SYM do` level, not one nested inside another per
+# rule -- each rule's own pattern already fully qualifies its required
+# "release:compile:"/"release:assemble:" prefix (Rake matches a rule's regex
+# against the literal invoked task name regardless of how deeply its `rule()`
+# call is textually nested, so an inner `namespace :compile do` here would be
+# purely decorative), and RakeTaskRegistry's marker scan resolves a task's
+# semantic tags from its *nearest* enclosing namespace -- nesting one more
+# level than necessary would make it resolve "compile"/"assemble" rather than
+# "release" itself.
+namespace RELEASE_SYM do
+  # Use rules to increase efficiency for large projects (instead of iterating through all sources and creating defined tasks)
+
+  # Unadvertised Rake task to execute source file compilation in isolation.
+  # A source extension can be configured as more than one string, so each one escaped
+  # and joined into the pattern's alternation is what lets a task name ending in any of
+  # them match, rather than only the first/primary one.
+  release_source_extensions = EXTENSION_SOURCE.to_a.map { |ext| Regexp.escape(ext) }.join('|')
+  rule(/^#{RELEASE_COMPILE_TASK_ROOT}\S+(?:#{release_source_extensions}|#{Regexp.escape(EXTENSION_CORE_SOURCE)})$/ => [ # compile task names by regex
+      proc do |task_name|
+        source = task_name.sub(/#{RELEASE_COMPILE_TASK_ROOT}/, '')
+        @ceedling[:file_finder].find_source_file(source)
+      end
+  ]) do |compile|
+    @ceedling[:rake_wrapper][:prepare].invoke
+    @ceedling[:release_invoker].setup_and_invoke( files: [compile.source] )
+  end
+
+  # Unadvertised Rake task to execute source file assembly in isolation
+  if (RELEASE_BUILD_USE_ASSEMBLY)
+  release_assembly_extensions = EXTENSION_ASSEMBLY.to_a.map { |ext| Regexp.escape(ext) }.join('|')
+  rule(/^#{RELEASE_ASSEMBLE_TASK_ROOT}\S+(?:#{release_assembly_extensions})$/ => [ # assemble task names by regex
+      proc do |task_name|
+        source = task_name.sub(/#{RELEASE_ASSEMBLE_TASK_ROOT}/, '')
+        @ceedling[:file_finder].find_assembly_file(source)
+      end
+  ]) do |assemble|
+    @ceedling[:rake_wrapper][:prepare].invoke
+    @ceedling[:release_invoker].setup_and_invoke( files: [assemble.source] )
+  end
+  end
+
+end

data/lib/ceedling/{erb_wrapper.rb → rakefiles/release/tasks_release.rake}

@@ -5,12 +5,9 @@
 #   SPDX-License-Identifier: MIT
 # =========================================================================
 
-require 'erb'
+require 'ceedling/constants'
 
-class ErbWrapper
-  def generate_file(template, data, output_file)
-    File.open(output_file, "w") do |f|
-      f << ERB.new(template, trim_mode: "<>").result(binding)
-    end
-  end
-end
+desc "Build release target"
+task RELEASE_SYM => [:prepare] do
+  @ceedling[:release_invoker].setup_and_invoke()
+end

data/lib/ceedling/rakefiles/tests/rules_tests.rake

@@ -0,0 +1,43 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+namespace TEST_SYM do
+  # Use rules to increase efficiency for large projects (instead of iterating through all sources and creating defined tasks)
+  rule(/^#{TEST_TASK_ROOT}\S+$/ => [ # Test task names by regex
+      proc do |task_name|
+        # Yield clean test name => Strip the task string, remove Rake test task prefix, and remove any code file extension.
+        # Only one configured source extension can actually be present at the end of a given
+        # task name, so trying each in turn is safe -- chomp is a no-op for the ones that don't match.
+        # Whatever directory the invoker typed ahead of the name (e.g. `test:unit/test_foo.c`)
+        # is left exactly as given -- it's not decoration, it's what disambiguates one test
+        # from another same-named test elsewhere in the project.
+        test = task_name.strip().sub(/^#{TEST_TASK_ROOT}/, '')
+        EXTENSION_SOURCE.each { |ext| test = test.chomp( ext ) }
+
+        # Normalized to forward slashes so a directory the invoker typed with backslashes
+        # (a Windows-style task name run under a POSIX Ruby, e.g. WSL or Cygwin, where
+        # File.dirname/basename below don't treat '\' as a separator) still splits correctly.
+        test = test.tr( '\\', '/' )
+
+        # Ensure the test name's own basename begins with the test file prefix, without
+        # disturbing any directory the invoker supplied ahead of it.
+        dir  = File.dirname( test )
+        base = File.basename( test )
+        base = PROJECT_TEST_FILE_PREFIX + base if not (base.start_with?( PROJECT_TEST_FILE_PREFIX ))
+        test = (dir == '.') ? base : File.join( dir, base )
+
+        # Provide the filepath for the target test task back to the Rake task
+        @ceedling[:file_finder].find_test_file_from_name( test )
+      end
+  ]) do |test|
+    # Do essential Rake-based set up
+    @ceedling[:rake_wrapper][:prepare].invoke
+
+    # Execute the test task
+    @ceedling[:test_invoker].setup_and_invoke(tests: [test.source], options: [])
+  end
+end

data/lib/ceedling/rakefiles/tests/rules_tests_generate.rake

@@ -0,0 +1,80 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+require 'ceedling/constants'
+
+# A single `namespace GEN_SYM do` level, not one nested per gen: sub-namespace --
+# each rule's own pattern already fully qualifies its required "gen:mocks:"/
+# "gen:test_runner:" prefix (Rake matches a rule's regex against the literal
+# invoked task name regardless of how deeply its `rule()` call is textually
+# nested, so an inner `namespace :mocks do` here would be purely decorative),
+# and RakeTaskRegistry's marker scan resolves a task's semantic tags from its
+# *nearest* enclosing namespace -- nesting one level deeper than necessary
+# would make it resolve "mocks"/"test_runner" rather than "gen" itself. See
+# rules_release.rake for the identical reasoning applied to release: rules.
+namespace GEN_SYM do
+
+  # Use a rule to increase efficiency for large projects (instead of iterating through all sources and creating defined tasks)
+  rule(/^#{GENERATE_MOCKS_TASK_ROOT}\S+$/ => [ # Task names by regex
+      proc do |task_name|
+        # Yield clean test name => Strip the task string, remove Rake task prefix, and remove any code file extension.
+        # Only one configured source extension can actually be present at the end of a given
+        # task name, so trying each in turn is safe -- chomp is a no-op for the ones that don't match.
+        # Whatever directory the invoker typed ahead of the name (e.g. `gen:mocks:unit/foo.c`)
+        # is left exactly as given -- it's not decoration, it's what disambiguates one test
+        # from another same-named test elsewhere in the project.
+        test = task_name.strip().sub(/^#{GENERATE_MOCKS_TASK_ROOT}/, '')
+        EXTENSION_SOURCE.each { |ext| test = test.chomp( ext ) }
+
+        # Normalized to forward slashes so a directory the invoker typed with backslashes
+        # (a Windows-style task name run under a POSIX Ruby, e.g. WSL or Cygwin, where
+        # File.dirname/basename below don't treat '\' as a separator) still splits correctly.
+        test = test.tr( '\\', '/' )
+
+        # Ensure the test name's own basename begins with the test file prefix, without
+        # disturbing any directory the invoker supplied ahead of it.
+        dir  = File.dirname( test )
+        base = File.basename( test )
+        base = PROJECT_TEST_FILE_PREFIX + base if not (base.start_with?( PROJECT_TEST_FILE_PREFIX ))
+        test = (dir == '.') ? base : File.join( dir, base )
+
+        # Provide the filepath for the target test task back to the Rake task
+        @ceedling[:file_finder].find_test_file_from_name( test )
+      end
+  ]) do |test|
+    # Do essential Rake-based set up
+    @ceedling[:rake_wrapper][:prepare].invoke
+
+    # Generate just this one test's mocks
+    @ceedling[:test_invoker].setup_and_invoke(tests: [test.source], options: [:mocking])
+  end
+
+  # Use a rule to increase efficiency for large projects (instead of iterating through all sources and creating defined tasks)
+  rule(/^#{GENERATE_TEST_RUNNER_TASK_ROOT}\S+$/ => [ # Task names by regex
+      proc do |task_name|
+        # See gen:mocks's identical rule above for a full explanation of this resolution.
+        test = task_name.strip().sub(/^#{GENERATE_TEST_RUNNER_TASK_ROOT}/, '')
+        EXTENSION_SOURCE.each { |ext| test = test.chomp( ext ) }
+
+        test = test.tr( '\\', '/' )
+
+        dir  = File.dirname( test )
+        base = File.basename( test )
+        base = PROJECT_TEST_FILE_PREFIX + base if not (base.start_with?( PROJECT_TEST_FILE_PREFIX ))
+        test = (dir == '.') ? base : File.join( dir, base )
+
+        @ceedling[:file_finder].find_test_file_from_name( test )
+      end
+  ]) do |test|
+    # Do essential Rake-based set up
+    @ceedling[:rake_wrapper][:prepare].invoke
+
+    # Generate just this one test's mocks and runner
+    @ceedling[:test_invoker].setup_and_invoke(tests: [test.source], options: [:test_runner])
+  end
+
+end