ceedling 1.2.0 → 1.2.2

data/lib/ceedling/installation.rb

@@ -0,0 +1,92 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+require 'rbconfig'
+
+# One Ceedling installation, identified by its root directory. Its version is read
+# from its own files, never from the constants of whichever installation loaded first.
+#
+# An application loaded by an older launcher reaches this file through require_relative
+# with someone else's code already loaded, so it depends on nothing else in lib/.
+class Installation
+
+  VERSION_FILE = File.join( 'lib', 'version.rb' )
+  BUILTIN_MIXINS_DIR = File.join( 'vendor', 'unity', 'test', 'targets' )
+
+  attr_reader :root
+
+  def self.windows?
+    return (RbConfig::CONFIG['host_os'] =~ /mswin|mingw|msys|ucrt/i) ? true : false
+  end
+
+  def initialize(root)
+    @root = File.expand_path( root )
+  end
+
+  def bin_path
+    return File.join( @root, 'bin', 'ceedling' )
+  end
+
+  def rakefile_path
+    return File.join( @root, 'lib', 'ceedling', 'rakefile.rb' )
+  end
+
+  # The version tag, or nil when this installation's lib/version.rb is missing or unreadable
+  def version
+    @version = read_version() unless defined?( @version )
+    return @version
+  end
+
+  # True when this installation's launcher validates a built-in mixin directory the
+  # installation does not hold. `--local` vendoring left it out from 1.1.0 through 1.2.1,
+  # so such a copy fails on its own and only ever ran inside another launcher's process.
+  def missing_builtin_mixins?
+    mixins_filepath = File.join( @root, 'bin', 'mixins.rb' )
+    return false if !File.exist?( mixins_filepath )
+    return false if !File.read( mixins_filepath ).include?( 'BUILTIN_MIXIN_LOAD_PATHS' )
+
+    return !File.directory?( File.join( @root, BUILTIN_MIXINS_DIR ) )
+  end
+
+  # Symlinks resolve, and Windows paths compare without case
+  def ==(other)
+    return false unless other.is_a?( Installation )
+    return Installation.windows? ? identity.casecmp?( other.identity ) : (identity == other.identity)
+  end
+
+  # "Ceedling 1.2.0", or without the version when it cannot be read
+  def name(noun='Ceedling')
+    return [noun, version()].compact.join( ' ' )
+  end
+
+  # "Ceedling 1.2.0 at /path/", or without the version when it cannot be read
+  def describe(noun='Ceedling')
+    return "#{name( noun )} at #{@root}/"
+  end
+
+  protected
+
+  def identity
+    return File.realpath( @root )
+  rescue SystemCallError
+    return @root
+  end
+
+  private
+
+  # lib/version.rb defines Ceedling::Version. Evaluated within an anonymous module, its
+  # constants land beneath that module instead of reopening the loaded ::Ceedling.
+  def read_version
+    filepath = File.join( @root, VERSION_FILE )
+    sandbox = Module.new
+    sandbox.module_eval( File.read( filepath ), filepath )
+    return sandbox.const_get( :Ceedling, false ).const_get( :Version, false ).const_get( :TAG, false )
+  rescue StandardError, ScriptError
+    return nil
+  end
+
+end

data/lib/ceedling/library_resolver.rb

@@ -0,0 +1,99 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+# Finds the library files a link's :libraries entries name, so a link can depend on their
+# contents. Which file a toolchain links is its own choice, so every candidate that exists
+# is found. A library only the toolchain's own search paths hold is not found, and a link
+# never depends on a file that doesn't exist, which would read as changed on every build.
+class LibraryResolver
+
+  # Library extensions toolchains search for beyond a project's own :extension ↳ :libraries
+  TOOLCHAIN_EXTENSIONS = ['.a', '.so', '.dylib', '.tbd', '.dll.a', '.lib'].freeze
+
+  constructor :file_wrapper, :file_path_collection_utils
+
+  def setup
+    @lock        = Mutex.new
+    @directories = {}
+  end
+
+  # entries:      :libraries entries, each a bare name, an `-l:` filename, or a path
+  # search_paths: :paths ↳ :libraries, decorated and globbed as configured
+  # files:        library files known exactly, as a plugin knows those it builds
+  def resolve(entries:, search_paths:, files: [])
+    return resolve_within( entries, @file_path_collection_utils.collect_paths( search_paths ), files )
+  end
+
+  # The library files a link with these :libraries entries depends on: those the entries
+  # resolve to on :paths ↳ :libraries, and those plugins publish in LIBRARIES_LINK_FILES
+  def link_files(entries)
+    return resolve_within( entries, search_directories(), ((defined? LIBRARIES_LINK_FILES) ? LIBRARIES_LINK_FILES : nil) || [] )
+  end
+
+  # A link's library search path arguments: each directory of search_directories in
+  # :libraries ↳ :path_flag
+  def search_path_arguments
+    directories = search_directories()
+    return directories unless defined?( LIBRARIES_PATH_FLAG )
+
+    return directories.map { |directory| LIBRARIES_PATH_FLAG.gsub( '${1}' ) { directory } }
+  end
+
+  # The directories :paths ↳ :libraries names, decorated and globbed as configured, with
+  # those plugins add once configuration is done. Collected once for a set of paths, since
+  # every link asks.
+  def search_directories
+    paths = ((defined? PATHS_LIBRARIES) ? PATHS_LIBRARIES : nil) || []
+    return @lock.synchronize { @directories[paths.dup] ||= @file_path_collection_utils.collect_paths( paths ) }
+  end
+
+  private
+
+  def resolve_within(entries, directories, files)
+    candidates = Array( entries ).flatten.compact.flat_map { |entry| candidates_for( entry.to_s, directories ) }
+    candidates += Array( files )
+
+    found = candidates.map { |path| @file_path_collection_utils.shortest_path_from_working( File.expand_path( path ) ) }
+    return found.select { |path| library_file?( path ) }.uniq
+  end
+
+  # An `-l:` entry names its exact filename, a path names itself, and a bare name names every
+  # library filename a toolchain makes of it
+  def candidates_for(entry, directories)
+    return within( directories, entry.delete_prefix( ':' ) ) if entry.start_with?( ':' )
+    return [entry] if absolute?( entry )
+    return [entry] + within( directories, entry ) if path?( entry )
+
+    return within( directories, *library_filenames( entry ) )
+  end
+
+  def within(directories, *names)
+    return directories.product( names ).map { |directory, name| File.join( directory, name ) }
+  end
+
+  def library_filenames(name)
+    return ["lib#{name}", name].product( extensions ).map( &:join )
+  end
+
+  # A path, or a filename with a library extension, rather than a name the linker expands
+  def path?(entry)
+    return entry.match?( %r{[/\\]} ) || extensions.any? { |extension| entry.end_with?( extension ) }
+  end
+
+  def absolute?(entry)
+    return File.expand_path( entry ) == entry || entry.match?( %r{\A[A-Za-z]:[/\\]} )
+  end
+
+  def extensions
+    @extensions ||= ((defined?( EXTENSION_LIBRARIES ) ? EXTENSION_LIBRARIES.to_a : []) + TOOLCHAIN_EXTENSIONS).uniq
+  end
+
+  def library_file?(path)
+    return @file_wrapper.exist?( path ) && !@file_wrapper.directory?( path )
+  end
+
+end

data/lib/ceedling/objects.yml

@@ -87,6 +87,7 @@ configurator_setup:
   compose:
     - configurator_builder
     - configurator_validator
+    - configurator_paths_validator
     - loginator
     - reportinator
     - file_wrapper
@@ -101,11 +102,17 @@ configurator_plugins:
 configurator_validator:
   compose:
     - config_walkinator
-    - file_wrapper
     - loginator
     - reportinator
     - tool_validator
 
+configurator_paths_validator:
+  compose:
+    - config_walkinator
+    - file_wrapper
+    - loginator
+    - reportinator
+
 configurator_builder:
   compose:
     - file_path_collection_utils
@@ -148,6 +155,10 @@ plugin_reportinator_helper:
 
 verbosinator:
 
+build_log_writer:
+  compose:
+    - file_wrapper
+
 file_finder:
   compose:
     - configurator
@@ -247,7 +258,7 @@ generator_test_results_backtrace:
      - generator_test_results
      - generator_helper
      - file_path_utils
-     - file_wrapper
+     - build_log_writer
      - loginator
 
 generator_test_results_sanity_checker:
@@ -402,6 +413,7 @@ test_invoker:
     - loginator
     - verbosinator
     - test_pipeline_manager
+    - include_pathinator
 
 test_pipeline_manager:
   compose:
@@ -434,6 +446,7 @@ test_build_setup:
     - dependinator
     - test_search_paths
     - mock_locator
+    - test_source_file_directive_resolver
 
 test_includes_extractinator:
   compose:
@@ -559,6 +572,8 @@ test_build_executor:
     - gcc_dependency_parser
     - quote_include_isolator
     - generator_helper
+    - library_resolver
+    - mock_locator
 
 partials_manager:
   compose:
@@ -603,6 +618,12 @@ release_build_executor:
     - file_wrapper
     - file_path_utils
     - dependinator
+    - library_resolver
+
+library_resolver:
+  compose:
+    - file_wrapper
+    - file_path_collection_utils
 
 gcc_dependency_parser:
 

data/lib/ceedling/partials/partializer.rb

@@ -14,7 +14,7 @@ require 'ceedling/c_extractor/c_extractor'
 require 'ceedling/c_extractor/c_extractor_constants'
 require 'ceedling/c_extractor/c_extractor_types'
 require 'ceedling/constants'
-require 'ceedling/path_mirror'
+require 'ceedling/filesystem/path_mirror'
 require 'ceedling/encodinator'
 
 class Partializer
@@ -124,7 +124,7 @@ class Partializer
   def _find_module_source(_module, header_filepath)
     return @file_finder.find_source_file(_module, :ignore) if _names_directory?(_module)
 
-    subdir = header_filepath.nil? ? '' : PathMirror.relative_subdir(header_filepath, _header_roots)
+    subdir = header_filepath.nil? ? '' : PathMirror.relative_subdir_from_clean_roots( header_filepath, _header_roots )
 
     unless subdir.empty?
       found = @file_finder.find_source_file(File.join(subdir, _module), :ignore)
@@ -135,9 +135,9 @@ class Partializer
   end
 
   # Roots a header can sit beneath, which is what its mirrored directory is measured
-  # against. The same three the project-wide header collection is built from.
+  # against: those the project-wide header collection is built from, spelled canonically.
   def _header_roots
-    @configurator.paths_test + @configurator.paths_support + @configurator.paths_include
+    @configurator.collection_mirror_roots_headers
   end
 
   # Either separator counts. The qualifier validation already rejects a backslash-rooted

data/lib/ceedling/partials/partializer_config.rb

@@ -9,6 +9,7 @@ require 'stringio'
 require 'strscan'
 require 'ceedling/partials/partials'
 require 'ceedling/exceptions'
+require 'ceedling/filesystem/project_paths'
 require 'ceedling/c_extractor/c_extractor_preprocessing'
 require 'ceedling/encodinator'
 
@@ -259,7 +260,8 @@ class PartializerConfig
     _validate_qualifier!( dir, macro_name )
     _validate_module!( params[1], macro_name, dir: dir )
 
-    File.join( dir, params[1] )
+    # A `.` segment names nothing, so `./drv` and `drv` name one module
+    File.join( *ProjectPaths.segments( dir ), params[1] )
   end
 
   # The module argument names one file's stem and nothing more. The preprocessor emits it

data/lib/ceedling/plugins/report_log_writer_plugin.rb

@@ -27,12 +27,10 @@ class ReportLogWriterPlugin < Plugin
 
   private
 
-  # Ensures <build root>/artifacts/<context>/ exists and returns the full
-  # filepath for `filename` inside it.
+  # Returns the filepath for `filename` beneath <build root>/artifacts/<context>/, with its
+  # directory made. A filename named for a test carries the test's subdirectories.
   def artifact_filepath(context, filename)
-    path = File.join(PROJECT_BUILD_ARTIFACTS_ROOT, context.to_s)
-    @file_wrapper.mkdir(path)
-    File.join(path, filename)
+    @file_wrapper.mkdir_for( File.join(PROJECT_BUILD_ARTIFACTS_ROOT, context.to_s, filename) )
   end
 
   # Logs a heading, then either reports `empty_message` or runs the

data/lib/ceedling/preprocess/preprocessinator_file_assembler.rb

@@ -6,7 +6,7 @@
 # =========================================================================
 
 require 'rake' # for ext() method
-require 'ceedling/file_wrapper'
+require 'ceedling/filesystem/file_wrapper'
 require 'ceedling/encodinator'
 require 'ceedling/preprocess/c_preprocessor_conditionals'
 

data/lib/ceedling/preprocess/preprocessinator_includes_handler.rb

@@ -6,7 +6,7 @@
 # =========================================================================
 
 require 'ceedling/includes/includes'
-require 'ceedling/path_matcher'
+require 'ceedling/filesystem/path_matcher'
 require 'ceedling/preprocess/preprocessinator_bare_includes_extractor'
 require 'ceedling/preprocess/preprocessinator_line_marker_includes_extractor'
 require 'ceedling/preprocess/c_preprocessor_conditionals'

data/lib/ceedling/preprocess/preprocessinator_line_marker_includes_extractor.rb

@@ -6,7 +6,7 @@
 # =========================================================================
 
 require 'ceedling/exceptions'
-require 'ceedling/path_matcher'
+require 'ceedling/filesystem/path_matcher'
 require 'set'
 require 'stringio'
 

data/lib/ceedling/rake_app/rakefile_component_resolver.rb

@@ -6,6 +6,7 @@
 # =========================================================================
 
 require 'ceedling/constants'
+require 'ceedling/filesystem/project_paths'
 
 # 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
@@ -39,8 +40,11 @@ module RakefileComponentResolver
   # plugins path last. This ordering lets user plugins shadow built-in plugins of the
   # same name. Used by both resolve() (bin/ CLI scope) and Configurator#prepare_plugins_load_paths
   # (application scope) so both scopes search plugins in the same priority order.
-  def prepare_plugin_load_paths(config, ceedling_plugins_path)
-    load_paths = Array( config.dig(:plugins, :load_paths) ).dup
+  #
+  # `expand` applies inline Ruby string expansion to each configured path, and each is then
+  # standardized as every other configured path is, so both scopes read them alike.
+  def prepare_plugin_load_paths(config, ceedling_plugins_path, expand: ->(path) { path })
+    load_paths = Array( config.dig(:plugins, :load_paths) ).compact.map { |path| ProjectPaths.standardize( expand.call( path ) ) }
     load_paths << ceedling_plugins_path
     load_paths.compact!
     load_paths.uniq!
@@ -51,7 +55,7 @@ module RakefileComponentResolver
   #   - Stock files (always)
   #   - 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)
+  def resolve(config, ceedling_lib_path, ceedling_plugins_path, expand: ->(path) { path })
     paths = base_rakefiles(ceedling_lib_path) + test_rakefiles(ceedling_lib_path)
 
     if config.dig(:project, :release_build)
@@ -59,7 +63,7 @@ module RakefileComponentResolver
     end
 
     paths.concat(
-      plugin_rake_files( config, prepare_plugin_load_paths(config, ceedling_plugins_path) )
+      plugin_rake_files( config, prepare_plugin_load_paths(config, ceedling_plugins_path, expand: expand) )
     )
 
     return paths
@@ -70,20 +74,9 @@ module RakefileComponentResolver
   # Uses File.exist? directly (no DI needed) — same check as ConfiguratorPlugins#find_rake_plugins.
   # Array() wraps nil gracefully so missing config keys don't raise.
   def plugin_rake_files(config, load_paths)
-    enabled = Array( config.dig(:plugins, :enabled) )
-    results = []
-
-    enabled.each do |plugin|
-      load_paths.each do |load_path|
-        candidate = File.join(load_path, plugin, "#{plugin}.rake")
-        if File.exist?(candidate)
-          results << candidate
-          break
-        end
-      end
+    return Array( config.dig(:plugins, :enabled) ).filter_map do |plugin|
+      load_paths.lazy.map { |load_path| File.join(load_path, plugin, "#{plugin}.rake") }.find { |candidate| File.exist?(candidate) }
     end
-
-    results
   end
 
 end

data/lib/ceedling/rake_app/test_task_name.rb

@@ -0,0 +1,29 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+# Turns a per-file test task's name (test:, gen:mocks:, gcov:, valgrind:, and the rest) into
+# the test name file lookup needs. A directory typed ahead of the name tells same-named tests
+# apart, so it is kept, and only the file name gets the test file prefix.
+module TestTaskName
+
+  def self.test_name(task_name, root:, extensions: EXTENSION_SOURCE, prefix: PROJECT_TEST_FILE_PREFIX)
+    test = task_name.strip.delete_prefix( root )
+
+    # At most one configured extension ends the name, so trying each in turn is safe
+    extensions.each { |ext| test = test.chomp( ext ) }
+
+    # A Windows-style name under a POSIX Ruby (WSL, Cygwin) has backslashes File won't split on
+    test = test.tr( '\\', '/' )
+
+    dir  = File.dirname( test )
+    base = File.basename( test )
+    base = prefix + base unless base.start_with?( prefix )
+
+    return (dir == '.') ? base : File.join( dir, base )
+  end
+
+end

data/lib/ceedling/rakefile.rb

@@ -5,6 +5,18 @@
 #   SPDX-License-Identifier: MIT
 # =========================================================================
 
+# A launcher before 1.2.2 loads this application into its own process, where its code
+# mixes with this installation's. Before anything else loads, restart in this
+# installation's own process. require_relative, because such a launcher's load path
+# cannot reach files newer than itself.
+require_relative 'handoff'
+Handoff.complete_in_process(
+  app_root: File.expand_path( File.join( __dir__, '..', '..' ) ),
+  app_cfg: CEEDLING_APPCFG,
+  handoff_objects: CEEDLING_HANDOFF_OBJECTS,
+  env: ENV
+)
+
 require 'fileutils'
 
 # Add Unity and CMock's Ruby code paths to $LOAD_PATH for runner generation and mocking
@@ -23,6 +35,7 @@ Rake::TaskManager.record_task_metadata = true
 
 require 'ceedling/system_wrapper'
 require 'ceedling/reportinator'
+require 'ceedling/rake_app/test_task_name'
 
 # Operation duration logging
 def log_runtime(run, start_time_s, end_time_s, enabled)
@@ -48,7 +61,9 @@ begin
   #  1. Add full path to $LOAD_PATH to simplify objects.yml
   #  2. Perform object construction + dependency injection
   #  3. Remove full path from $LOAD_PATH
-  $LOAD_PATH.unshift( CEEDLING_APPCFG[:ceedling_lib_path] )
+  # The full path comes last, behind its subdirectories, so a file an older Ceedling left
+  # directly in lib/ceedling/ never stands in for one that has moved below it
+  $LOAD_PATH.push( CEEDLING_APPCFG[:ceedling_lib_path] )
   objects_filepath = File.join( CEEDLING_APPCFG[:ceedling_lib_path], 'objects.yml' )
   
   # Create object hash and dependency injection context

data/lib/ceedling/rakefiles/base/tasks_base.rake

@@ -6,7 +6,7 @@
 # =========================================================================
 
 require 'ceedling/constants'
-require 'ceedling/file_path_utils'
+require 'ceedling/filesystem/file_path_utils'
 
 # Set Rake verbosity using global constant verbosity set before Rake is loaded
 if !!defined?(PROJECT_VERBOSITY)

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

@@ -21,11 +21,9 @@ 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
+  # A source extension can be configured as more than one string, so a task name ending in
+  # any of them matches, rather than only the first/primary one.
+  rule(/^#{RELEASE_COMPILE_TASK_ROOT}\S+(?:#{EXTENSION_SOURCE.pattern}|#{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)
@@ -37,8 +35,7 @@ namespace RELEASE_SYM do
 
   # 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
+  rule(/^#{RELEASE_ASSEMBLE_TASK_ROOT}\S+#{EXTENSION_ASSEMBLY.pattern}$/ => [ # assemble task names by regex
       proc do |task_name|
         source = task_name.sub(/#{RELEASE_ASSEMBLE_TASK_ROOT}/, '')
         @ceedling[:file_finder].find_assembly_file(source)

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

@@ -9,26 +9,9 @@ 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 )
+        # Any directory typed ahead of the name (e.g. `test:unit/test_foo.c`) is kept, since it
+        # tells one test from a same-named test elsewhere. See TestTaskName.
+        test = TestTaskName.test_name( task_name, root: TEST_TASK_ROOT )
 
         # Provide the filepath for the target test task back to the Rake task
         @ceedling[:file_finder].find_test_file_from_name( test )

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

@@ -21,26 +21,9 @@ 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 )
+        # Any directory typed ahead of the name (e.g. `gen:mocks:unit/foo.c`) is kept, since it
+        # tells one test from a same-named test elsewhere. See TestTaskName.
+        test = TestTaskName.test_name( task_name, root: GENERATE_MOCKS_TASK_ROOT )
 
         # Provide the filepath for the target test task back to the Rake task
         @ceedling[:file_finder].find_test_file_from_name( test )
@@ -56,16 +39,7 @@ 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_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 )
+        test = TestTaskName.test_name( task_name, root: GENERATE_TEST_RUNNER_TASK_ROOT )
 
         @ceedling[:file_finder].find_test_file_from_name( test )
       end