ceedling 1.0.0 → 1.1.0

data/lib/ceedling/preprocess/preprocessinator_reconstructor.rb

@@ -0,0 +1,398 @@
+# =========================================================================
+#   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'
+require 'ceedling/encodinator'
+require 'ceedling/parsing_parcels'
+
+class PreprocessinatorReconstructor 
+ 
+  constructor :parsing_parcels
+
+  ##
+  ## Preprocessor Expansion Output Handling
+  ## ======================================
+  ## 
+  ## Preprocessing expands macros, eliminates comments, strips out #ifdef code, etc.
+  ## However, it also expands in place each #include'd file. So, we must extract 
+  ## only the lines of the file that belong to the file originally preprocessed.
+  ## 
+  ## We do this by examininig each line and ping-ponging between extracting and
+  ## ignoring text based on preprocessor statements referencing the file we're
+  ## seeking to reassemble.
+  ##
+  ## Note that the same text handling approach applies to full preprocessor 
+  ## expansion as directives only expansion.
+  ## 
+  ## Example preprocessed expansion output
+  ## --------------------------------------
+  ## 
+  ## # 14 "test/TestUsartModel.c" 2
+  ## 
+  ## void setUp(void)
+  ## {
+  ## }
+  ## 
+  ## void tearDown(void)
+  ## {
+  ## }
+  ## 
+  ## void testUsartModelInit(void)
+  ## {
+  ##   TemperatureFilter_Init_CMockExpect(26);
+  ## 
+  ##   UsartModel_Init();
+  ## }
+  ## # 55 "test/TestUsartModel.c"
+  ## void testGetBaudRateRegisterSettingShouldReturnAppropriateBaudRateRegisterSetting(void)
+  ## {
+  ##   uint8 dummyRegisterSetting = 17;
+  ##   UsartModel_CalculateBaudRateRegisterSetting_CMockExpectAndReturn(58, 48054857, 115200, dummyRegisterSetting);
+  ## 
+  ##   UnityAssertEqualNumber((UNITY_INT)(UNITY_UINT8 )((dummyRegisterSetting)), (UNITY_INT)(UNITY_UINT8 )((UsartModel_GetBaudRateRegisterSetting())), (((void*)0)), (UNITY_UINT)(60), UNITY_DISPLAY_STYLE_UINT8);
+  ## }
+  ## 
+  ## void testIgnore(void)
+  ## {
+  ##   UnityIgnore( (((void*)0)), (UNITY_UINT)(65));
+  ## }
+  ## # 75 "test/TestUsartModel.c"
+  ## void testGetFormattedTemperatureFormatsTemperatureFromCalculatorAppropriately(void)
+  ## {
+  ##   TemperatureFilter_GetTemperatureInCelcius_CMockExpectAndReturn(77, 25.0f);
+  ##   UnityAssertEqualString((const char*)(("25.0 C\n")), (const char*)((UsartModel_GetFormattedTemperature())), (((void*)0)), (UNITY_UINT)(78));
+  ## }
+  ## 
+  ## void testShouldReturnErrorMessageUponInvalidTemperatureValue(void)
+  ## {
+  ##   TemperatureFilter_GetTemperatureInCelcius_CMockExpectAndReturn(83, -__builtin_huge_valf());
+  ##   UnityAssertEqualString((const char*)(("Temperature sensor failure!\n")), (const char*)((UsartModel_GetFormattedTemperature())), (((void*)0)), (UNITY_UINT)(84));
+  ## }
+  ## 
+  ## void testShouldReturnWakeupMessage(void)
+  ## {
+  ##   UnityAssertEqualString((const char*)(("It's Awesome Time!\n")), (const char*)((UsartModel_GetWakeupMessage())), (((void*)0)), (UNITY_UINT)(89));
+  ## }
+
+  # `input` must have the interface of IO -- StringIO for testing or File in typical use
+  def extract_file_as_array_from_expansion(input, filepath)
+    lines = []
+    _scan_expansion_for_file(input, filepath) { |line| lines << line }
+    return lines
+  end
+
+
+  # Simple variation of preceding that returns file contents as single string
+  def extract_file_as_string_from_expansion(input, filepath)
+    return extract_file_as_array_from_expansion(input, filepath).join( "\n" )
+  end
+
+
+  # Writes only C code from `input` preprocessor expansion belonging to `filepath`
+  # to `output` IO object incrementally (one logical line at a time) without building
+  # an intermediate array. `output` must respond to `puts` (e.g. File or StringIO).
+  def compact_from_expansion(input:, filepath:, output:)
+    _scan_expansion_for_file(input, filepath) { |line| output.puts(line) }
+  end
+
+
+  # File-based convenience wrapper around `compact_from_expansion`.
+  # Opens `input_filepath` for reading and `output_filepath` for writing,
+  # then delegates to `compact_from_expansion` with the resulting IO objects.
+  def compact_file_from_expansion(input_filepath:, source_filepath:, output_filepath:)
+    # Open input in binary mode: GCC output under non-C locale contains non-ASCII bytes
+    # (localized markers). Per-line clean_encoding in _scan_expansion_for_file handles content.
+    File.open( input_filepath, 'rb' ) do |input|
+      File.open( output_filepath, 'w' ) do |output|
+        compact_from_expansion( input: input, filepath: source_filepath, output: output )
+      end
+    end
+  end
+
+
+  # Extract all test directive macros as a list from a file as string
+  def extract_test_directive_macro_calls(file_contents)
+    # Look for TEST_SOURCE_FILE("...") and TEST_INCLUDE_PATH("...") in a string (i.e. a file's contents as a string)
+
+    regexes = [
+      /(#{PATTERNS::TEST_SOURCE_FILE})/,
+      /(#{PATTERNS::TEST_INCLUDE_PATH})/
+    ]
+
+    return extract_tokens_by_regex_list( file_contents, *regexes ).map(&:first)
+  end
+
+
+  # Extract TEST_CASE()/TEST_RANGE()/TEST_MATRIX() calls paired with the name of the test
+  # function each stack of calls immediately precedes.
+  #
+  # Unlike `extract_test_directive_macro_calls` above, this cannot be built on top of
+  # `extract_tokens_by_regex_list()`. That helper (via `@parsing_parcels.code_lines`) hands
+  # the regex one physical/continuation-joined line at a time, so a pattern spanning
+  # "TEST_CASE(...)\nvoid test_Foo(" could never match -- and that split-across-two-lines
+  # layout is the overwhelmingly common real-world case (each macro call is a line of its
+  # own, the function signature is the next line down). So we scan the whole string in one
+  # pass instead, letting `PATTERNS::TEST_CASE_DIRECTIVE`'s `/m` flag see across line breaks.
+  #
+  # `file_contents` is expected to already have had comments stripped and #if/#ifdef/#include
+  # directives (and their line markers) resolved away -- true of both callers in
+  # PreprocessinatorFileAssembler#collect_test_file_contents: the non-fallback path reads
+  # the directives-only GCC output (already comment-stripped in place by
+  # PreprocessinatorCommentStripper before this ever runs, and already stripped of line
+  # markers by `_scan_expansion_for_file` above), and the fallback path reads text already
+  # run through `@parsing_parcels.code_lines` (which strips comments) plus conditional
+  # filtering. So there's nothing here to confuse the adjacency test between a macro call
+  # and the function signature that follows it.
+  def extract_test_case_directives(file_contents)
+    pairs = []
+
+    file_contents.scan( PATTERNS::TEST_CASE_DIRECTIVE ) do |directive, function|
+      pairs << { function: function, directive: directive.strip.split( "\n" ).map( &:rstrip ) }
+    end
+
+    return pairs
+  end
+
+
+  # Reinsert TEST_CASE()/TEST_RANGE()/TEST_MATRIX() calls (extracted above from a
+  # macro-preserving preprocessor pass) into `contents` (built from a *fully expanded*
+  # preprocessor pass, where these macros -- real Unity macros that `#define` to nothing --
+  # have already vanished without a trace) immediately ahead of the matching test function's
+  # line. `contents` is a scanning artifact only (never compiled), so reinserting this raw,
+  # unexpanded macro text back into it is safe: Unity's own runner generator is the only
+  # consumer, and it only cares that the text is there, immediately before the function.
+  #
+  # A single cursor walks `contents` forward as each directive is placed, rather than
+  # independently searching the whole array per directive. Two reasons: it mirrors the
+  # existing precedent for this exact original-order correlation problem elsewhere in
+  # Ceedling (GeneratorTestRunner#parse_test_file's line-number remap, and Unity's own
+  # find_tests() line-number lookup), and it avoids ever misattributing a directive to an
+  # earlier stray match of the same function name (e.g. a forward declaration) instead of
+  # the real definition that follows it in file order.
+  def splice_test_case_directives(contents:, directives:)
+    cursor = 0
+
+    directives.each do |pair|
+      function_regex = /^\s*void\s+#{Regexp.escape(pair[:function])}\s*\(/
+
+      # Search forward from the cursor only. If the function isn't found -- e.g. it was
+      # compiled out by an inactive #ifdef branch, resolved identically in both the source
+      # this directive came from and in `contents` itself -- there's nothing to attach the
+      # 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
+          index = cursor + offset
+          break
+        end
+      end
+      next if index.nil?
+
+      contents.insert( index, *pair[:directive] )
+
+      # Advance past the directive lines just inserted and the function line itself so the
+      # next directive's search starts after this one, preserving file order.
+      cursor = index + pair[:directive].size + 1
+    end
+
+    return contents
+  end
+
+
+  # Extract all pragmas as a list from a file as string
+  def extract_pragmas(file_contents)
+    return extract_multiline_directives( file_contents, 'pragma' )
+  end
+
+
+  # Find include guard in file contents as string
+  def extract_include_guard(file_contents)
+    # Look for first occurrence of #ifndef <sring> followed by #define <string>
+    regex = /#\s*ifndef\s+(\w+)(?:\s*\n)+\s*#\s*define\s+(\w+)/
+    matches = file_contents.match( regex )
+
+    # Return if no match results
+    return nil if matches.nil?
+
+    # Return if match results are not expected size
+    return nil if matches.size != 3
+
+    # Return if #ifndef <string> does not match #define <string>
+    return nil if matches[1] != matches[2]
+
+    # Return string in common
+    return matches[1]
+  end
+
+
+  # Extract all macro definitions as a list from a file as string
+  def extract_macro_defs(file_contents, include_guard)
+    macro_definitions = extract_multiline_directives( file_contents, 'define' )
+
+    # Remove an include guard if provided
+    macro_definitions.reject! {|macro| macro.include?( include_guard ) } if !include_guard.nil?
+
+    return macro_definitions
+  end
+
+  ### Private ###
+
+  private
+
+  ##
+  ## Iterate through all lines and alternate between extract and ignore modes.
+  ## All lines between a '#' line containing the filepath to extract (a line marker) and the next '#' line should be extracted.
+  ##
+  ## GCC preprocessor output line marker format: `# <linenum> "<filename>" <flags>`
+  ##
+  ## Documentation on line markers in GCC preprocessor output:
+  ##  https://gcc.gnu.org/onlinedocs/gcc-3.0.2/cpp_9.html
+  ##
+  ## Notes:
+  ##  1. Successive blocks can all be from the same source text file without a different, intervening '#' line.
+  ##     Multiple back-to-back blocks could all begin with '# 99 "path/file.c"'.
+  ##  2. The first line of the file could start a text block we care about.
+  ##  3. End of file could end a text block.
+  ##  4. Usually, the first line marker contains no trailing flag.
+  ##  5. Different preprocessors conforming to the GCC output standard may use different trailiing flags.
+  ##  6. Our simple ping-pong-between-line-markers extraction technique does not require decoding flags.
+  ##
+  ## Yields one complete logical line at a time to the given block.
+  ## A single `pending_line` buffer is held to allow aggregation of preprocessor-wrapped
+  ## expansions (multiple physical lines at the same logical line number) before yielding.
+  ##
+  def _scan_expansion_for_file(input, filepath, &block)
+    # Expand filepath under inspection to ensure proper match
+    extraction_filepath = File.expand_path( filepath )
+    # Preprocessor directive blocks generally take the form of '# <digits> <text> [optional digits]'
+    directive   = /^# \d+ \"/
+    # Line markers have the specific form of '# <digits> "path/filename.ext" [optional digits]' (see above)
+    line_marker = /^#\s(\d+)\s\"(.+)\"/
+    # Boolean to ping pong between line-by-line extract/ignore
+    extract = false
+
+    line_num      = 0
+    last_line_num = 0
+
+    # Buffer for the last logical line (may still receive aggregated content)
+    pending_line  = nil
+    # Whether a blank line should follow pending_line when flushed
+    pending_blank = false
+
+    # Yields pending_line (and optional trailing blank) then clears the buffer
+    flush = lambda do
+      unless pending_line.nil?
+        block.call( pending_line )
+        block.call( '' ) if pending_blank
+        pending_line  = nil
+        pending_blank = false
+      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 up any oddball characters in an otherwise ASCII document
+      line = line.clean_encoding
+
+      # Handle expansion extraction if the line is not a preprocessor directive
+      if extract and not line =~ directive
+        line_num += 1
+
+        # Strip a line so we can omit useless blank lines
+        _line = line.strip()
+
+        # Skip processing blank lines, but mark a pending blank unless we already have one
+        if _line.empty?
+          pending_blank = true if !pending_line.nil? && !pending_line.empty?
+          next
+        end
+
+        # If the linemarker line number hasn't advanced, aggregate the expanded line into pending
+        if (last_line_num == line_num) and !pending_line.nil?
+          # Append the stripped line to the pending line
+          # Include a space in the concatenation unless it's a semicolon or pending_line is blank
+          pending_line = (_line == ';' or pending_line.empty?) ? (pending_line + _line) : (pending_line + ' ' + _line)
+        else
+          # Flush previous pending line before starting a new one
+          flush.call()
+          # Collect a left-whitespace-preserved version of the line
+          pending_line = line.rstrip()
+        end
+
+      # Otherwise the line contained a preprocessor directive; drop out of extract mode
+      else
+        extract = false
+      end
+
+      # Enter extract mode if the line is a preprocessor line marker with filepath of interest
+      matches = line.match( line_marker )
+      if matches and matches.size() > 2
+        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
+      end
+    end
+
+    # Yield any remaining buffered line at end of input
+    flush.call()
+  end
+
+
+  def extract_multiline_directives(file_contents, directive)
+    results = []
+
+    # Output from the GCC preprocessor directives-only mode is the intended input to be processed here.
+    # The GCC preprpocessor smooshes multiline directives into a single line.
+    # We process both single and multiline directives here in case this is ever not true or we need
+    # to extract directives from files that have not been preprocessed.
+
+    # This regex captures any single or multiline preprocessor directive definition:
+    #  - Looks for any string that begins with '#<directive>' ('#' and '<directive>' may be separated by spaces per C spec).
+    #  - Captures all text (non-greedily) after '#<directive>' on a first line through 0 or more line continuations up to a final newline.
+    #  - Line continuations comprise a final '\' on a given line followed by whitespace & newline, wrapping to the next
+    #    line up to a final '\' on that next line.
+    regex = /(#\s*#{directive}[^\n]*)\n/
+
+    tokens = extract_tokens_by_regex_list( file_contents, regex )
+
+    tokens.each do |token|
+      # Get the full text string from `scan() results` and split it at any newlines
+      lines = token[0].split( "\n" )
+      # Lop off any trailing whitespace (mostly to simplify unit testing)
+      lines.map! {|line| line.rstrip()}
+
+      # If the result of splitting is just a single string, add it to the results array as a single string
+      if lines.size == 1
+        results << lines[0]
+      # Otherwise, add the array of split strings to the results as a sub-array
+      else
+        results << lines
+      end
+    end
+
+    return results
+  end
+
+
+  def extract_tokens_by_regex_list(file_contents, *regexes)
+    tokens = []
+
+    # For each regex provided, extract all matches from the source string
+    regexes.each do |regex|
+      @parsing_parcels.code_lines( file_contents ) do |line|
+        tokens += line.scan( regex )
+      end
+    end
+
+    return tokens
+  end
+
+end

data/lib/ceedling/rake_app/rake_invocation_tracker.rb

@@ -0,0 +1,39 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+class RakeInvocationTracker
+
+  constructor :rake_task_registry, :rake_utils
+
+  # Post-execution lookup: returns true if any registered test namespace was invoked.
+  def test_build_invoked?
+    namespaces = @rake_task_registry.namespaces_for_tag( RakeTaskRegistry::TAG_TEST )
+    return false if namespaces.empty?
+    pattern = /^(#{namespaces.map { |ns| Regexp.escape(ns) }.join('|')})(:|$)/
+    @rake_utils.task_invoked?( pattern )
+  end
+
+  # Post-execution lookup: returns true if a `test` task was invoked.
+  # Note: This can include tasks that, in turn, invoke test tasks.
+  def test_task_invoked?
+    @rake_utils.task_invoked?( /^test(:|$)/ )
+  end
+
+  # Post-execution lookup: returns true if any registered release namespace was invoked.
+  def release_build_invoked?
+    namespaces = @rake_task_registry.namespaces_for_tag( RakeTaskRegistry::TAG_RELEASE )
+    return false if namespaces.empty?
+    pattern = /^(#{namespaces.map { |ns| Regexp.escape(ns) }.join('|')})(:|$)/
+    @rake_utils.task_invoked?( pattern )
+  end
+
+  # Post-execution lookup: returns true if the matching the given regex was invoked.
+  def invoked?(regex)
+    return @rake_utils.task_invoked?(regex)
+  end
+
+end

data/lib/ceedling/rake_app/rake_task_registry.rb

@@ -0,0 +1,210 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+# Tracks which Rake task namespaces are associated with which semantic tags
+# (:test, :release, :build) so bin/ CLI code and other components can ask, e.g.
+# "does invoking this task run tests?" without waiting for Rake to load
+# .rake files and build real task objects.
+#
+# The unit of registration is the root namespace (e.g. 'test', 'gcov'), not the
+# full task name. This handles all Rake task name forms uniformly:
+#   - Explicitly named tasks  (test:all)
+#   - Rule-synthesized tasks  (test:foo_file)
+#   - Bare top-level aliases  (test)
+# All share the same root namespace and are therefore all covered once that
+# namespace is registered.
+#
+# Namespaces are discovered by scanning .rake files as text for marker regexes
+# (see register_tasks) rather than via Rake's task inspection API, because Rake
+# tasks don't exist as objects until their .rake files are loaded. Namespace
+# identification is needed before loading .rake files, so bin/ CLI code and 
+# other components can determine whether the user's requested tasks include tests
+# or other build domains.
+#
+# Registration happens in two passes over the Ceedling lifecycle:
+#
+#   Pass 1 — Early, from bin/cli_helper.rb before .rake files are loaded.
+#     constants.rb is already required, so stock constants (TEST_SYM, RELEASE_SYM,
+#     UTILS_SYM) resolve correctly via Object.const_get. Plugin-specific constants
+#     (GCOV_SYM, VALGRIND_SYM, BULLSEYE_SYM, etc.) are defined in plugin lib/ files
+#     that have not been loaded yet, causing Object.const_get to raise NameError.
+#
+#   Pass 2 — After .rake files are loaded in rakefile.rb.
+#     All plugin lib/ paths have been added to $LOAD_PATH and all constants are
+#     defined. Object.const_get succeeds. The registry is cleared and rebuilt.
+#
+# Unresolvable constants (NameError in Pass 1) are handled by the _SYM convention
+# fallback in find_enclosing_namespace.
+
+class RakeTaskRegistry
+
+  # Semantic tag constants — used as keys in the namespace_tags registry
+  TAG_TEST    = :test
+  TAG_RELEASE = :release
+  TAG_BUILD   = :build
+
+  # 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
+
+  # Marker regexes — a line matching any marker signals the enclosing namespace
+  # belongs to the associated domain.
+  #
+  # MARKER_TEST_TASKS_SETUP_AND_INVOKE matches any call of the form:
+  #   @ceedling[:test_invoker].setup_and_invoke(
+  #
+  # MARKER_RELEASE_TASKS matches any call of the form:
+  #   @ceedling[:release_invoker].setup_and_invoke_objects(
+
+  MARKER_TEST_TASKS_SETUP_AND_INVOKE = /\[\s*:test_invoker\s*\]\.setup_and_invoke/
+  MARKER_RELEASE_TASKS               = /\[\s*:release_invoker\s*\]\.setup_and_invoke_objects/
+
+  def initialize
+    # Maps root namespace string → Array<Symbol> of semantic tags
+    # e.g. { 'test' => [:test, :build], 'gcov' => [:test, :build], 'release' => [:release, :build] }
+    @namespace_tags = {}
+  end
+
+  # Returns all tags associated with a task name.
+  # Any task form maps to its root namespace:
+  #   'test:all'      → root 'test'
+  #   'test:foo_file' → root 'test'  (rule-synthesized tasks handled for free)
+  #   'test'          → root 'test'  (bare alias handled for free)
+  #   'gcov:all'      → root 'gcov'
+  def tags_for(task_name)
+    root = task_name.split(':').first
+    @namespace_tags[root] || []
+  end
+
+  # Returns true if the task is associated with the given tag.
+  def task_is?(task_name, tag)
+    tags_for( task_name ).include?( tag )
+  end
+
+  # Returns all registered namespace strings that carry the given tag.
+  # Used by RakeInvocationTracker to build dynamic regex patterns for invocation checks.
+  def namespaces_for_tag(tag)
+    @namespace_tags.select { |_, tags| tags.include?( tag ) }.keys
+  end
+
+  # Directly register a namespace string with one or more tags.
+  # Merges with any existing tags — does not overwrite prior registrations.
+  # Example: register_namespace( 'plugin', *TAGS_TEST )
+  def register_namespace(namespace, *tags)
+    @namespace_tags[namespace] ||= []
+    tags.each do |tag|
+      @namespace_tags[namespace] << tag unless @namespace_tags[namespace].include?( tag )
+    end
+  end
+
+  # Scans .rake files as text to identify Rake namespaces that call certain marker
+  # code, registering each namespace's root with the given tags.
+  #
+  # Algorithm per file:
+  #   1. Skip the file if no marker regex matches the full content (fast pre-check).
+  #   2. For each line matching any marker, search backwards to find the
+  #      enclosing `namespace` declaration.
+  #   3. Resolve the namespace identifier to a string (see find_enclosing_namespace).
+  #   4. Register the namespace string with the provided tags.
+  #
+  # Called once per pass (see class comment) — Pass 2 clears and rebuilds the
+  # registry so it doesn't accumulate stale Pass 1 entries.
+  def register_tasks(rakefile_paths, markers:, tags:)
+    rakefile_paths.each do |filepath|
+      begin
+        # Force valid UTF-8: transcode BOM-prefixed files correctly and replace
+        # any invalid/undefined byte sequences so regex matching below can't
+        # raise on files containing arbitrary unicode content.
+        content = File.read( filepath, encoding: 'bom|utf-8', invalid: :replace, undef: :replace, replace: '' )
+      rescue
+        next  # Skip unreadable files without failing
+      end
+
+      next unless markers.any? { |m| content.match?( m ) }
+
+      lines = content.lines
+
+      lines.each_with_index do |line, idx|
+        next unless markers.any? { |m| line.match?( m ) }
+
+        namespace_name = find_enclosing_namespace( lines, idx )
+        next if namespace_name.nil?
+
+        @namespace_tags[namespace_name] ||= []
+        tags.each do |tag|
+          @namespace_tags[namespace_name] << tag unless @namespace_tags[namespace_name].include?( tag )
+        end
+      end
+    end
+  end
+
+  # Clears all test-tagged namespaces and re-scans for test pipeline invocations.
+  # The delete_if ensures Pass 2 replaces Pass 1 results cleanly without
+  # disturbing release-tagged entries registered independently.
+  def register_test_tasks(rakefile_paths)
+    @namespace_tags.delete_if { |_, tags| tags.include?( TAG_TEST ) }
+    register_tasks(
+      rakefile_paths, 
+      markers: [
+        MARKER_TEST_TASKS_SETUP_AND_INVOKE,
+        ],
+      tags: TAGS_TEST
+    )
+  end
+
+  # Clears all release-tagged namespaces and re-scans for release pipeline invocations.
+  def register_release_tasks(rakefile_paths)
+    @namespace_tags.delete_if { |_, tags| tags.include?( TAG_RELEASE ) }
+    register_tasks( rakefile_paths, markers: [MARKER_RELEASE_TASKS], tags: TAGS_RELEASE )
+  end
+
+  private
+
+  # Searches backwards from from_idx to find the enclosing `namespace` declaration.
+  # Returns the resolved namespace string, or nil if no namespace is found.
+  #
+  # Namespace identifier resolution:
+  #   :symbol  → strip leading ':' → 'symbol'
+  #   "string" → strip surrounding quotes
+  #   CONSTANT → Object.const_get → .to_s
+  #
+  # Handling constants-as-symbols in namespace declarations (e.g. `namespace GCOV_SYM do`):
+  # Plugin constants not yet loaded in Pass 1 raise NameError. Ceedling plugin constants
+  # follow the naming convention NAME_SYM where NAME is the Rake namespace string
+  # (e.g. GCOV_SYM → 'gcov', VALGRIND_SYM → 'valgrind', BULLSEYE_SYM → 'bullseye').
+  # The rescue block strips '_SYM' and downcases to infer the correct namespace name.
+  # Constants that don't follow this convention fall back to raw.downcase.
+  def find_enclosing_namespace(lines, from_idx)
+    namespace_name = nil
+
+    (from_idx - 1).downto(0) do |i|
+      stripped = lines[i].strip
+
+      if namespace_name.nil? && (m = stripped.match( /\Anamespace\s+(.+?)\s+do/ ))
+        raw = m[1].strip
+        namespace_name =
+          if raw.start_with?( ':' )
+            raw[1..]                        # :symbol → 'symbol'
+          elsif raw =~ /^[A-Z_]+$/
+            begin
+              Object.const_get( raw ).to_s  # CONSTANT → resolve at runtime
+            rescue NameError
+              # Plugin constant not yet loaded (Pass 1 only).
+              # Convention: NAME_SYM constants use NAME as the namespace string.
+              raw.end_with?( '_SYM' ) ? raw.delete_suffix( '_SYM' ).downcase : raw.downcase
+            end
+          else
+            raw.delete( "'\"" )             # 'string' or "string" → strip quotes
+          end
+        break
+      end
+    end
+
+    namespace_name
+  end
+
+end

data/lib/ceedling/rake_app/rake_utils.rb

@@ -0,0 +1,23 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+class RakeUtils
+  
+  constructor :rake_wrapper
+
+  def task_invoked?(task_regex)
+    task_invoked = false
+    @rake_wrapper.task_list.each do |task|
+      if ((task.already_invoked) and (task.to_s =~ task_regex))
+        task_invoked = true
+        break
+      end
+    end
+    return task_invoked
+  end
+
+end