ceedling 1.2.1 → 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/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
@@ -49,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/release_invoker/release_build_executor.rb

@@ -6,6 +6,7 @@
 # =========================================================================
 
 require 'ceedling/constants'
+require 'ceedling/filename_extension'
 require 'ceedling/release_invoker/release_invoker_types'
 
 # Does the actual work of a release build: compiling objects, linking the
@@ -24,7 +25,8 @@ class ReleaseBuildExecutor
     :file_finder,
     :file_wrapper,
     :file_path_utils,
-    :dependinator
+    :dependinator,
+    :library_resolver
   )
 
   def compile_objects(state)
@@ -44,17 +46,22 @@ class ReleaseBuildExecutor
   def link(state)
     objects, libraries = sort_objects_and_libraries( state.objects )
     lib_args  = convert_libraries_to_arguments( libraries )
-    lib_paths = get_library_paths_to_arguments()
+    lib_paths = @library_resolver.search_path_arguments()
+    library_files = @library_resolver.link_files( release_library_entries( libraries ) )
     target    = @configurator.project_release_build_target
 
+    # As with a test link, the object and library lists as meta relink an artifact that a
+    # dropped source or library would otherwise leave holding its code
     @dependinator.register(
       target,
-      files: objects,
-      meta:  { flags: state.link_flags, lib_args: lib_args, lib_paths: lib_paths, tools: [@configurator.tools_release_linker] }
+      files: objects + library_files,
+      meta:  { flags: state.link_flags, lib_args: lib_args, lib_paths: lib_paths, tools: [@configurator.tools_release_linker], objects: objects, libraries: library_files }
     )
     stale = @dependinator.stale?( target )
 
     if stale
+      # A target named by an absolute :output may sit in a directory no build made
+      @file_wrapper.mkdir( File.dirname( target ) )
       @generator.generate_executable_file(
         @configurator.tools_release_linker,
         RELEASE_SYM,
@@ -192,13 +199,7 @@ class ReleaseBuildExecutor
   end
 
   def convert_libraries_to_arguments(libraries)
-    args =
-      (libraries || []) +
-      ((defined? LIBRARIES_SYSTEM) ? LIBRARIES_SYSTEM : []) +
-      ((defined? LIBRARIES_RELEASE) ? LIBRARIES_RELEASE : [])
-
-    args.flatten!
-    args.compact!
+    args = release_library_entries( libraries )
 
     if (defined? LIBRARIES_FLAG)
       args.map! { |v| LIBRARIES_FLAG.gsub(/\$\{1\}/, v) }
@@ -207,12 +208,15 @@ class ReleaseBuildExecutor
     return args
   end
 
-  def get_library_paths_to_arguments()
-    paths = (defined? PATHS_LIBRARIES) ? (PATHS_LIBRARIES || []).clone : []
-    if (defined? LIBRARIES_PATH_FLAG)
-      paths.map! { |v| LIBRARIES_PATH_FLAG.gsub(/\$\{1\}/, v) }
-    end
-    return paths
+  # The :libraries entries a release links, whatever form each takes, beside the library
+  # files its object list names
+  def release_library_entries(libraries)
+    entries =
+      (libraries || []) +
+      ((defined? LIBRARIES_SYSTEM) ? LIBRARIES_SYSTEM : []) +
+      ((defined? LIBRARIES_RELEASE) ? LIBRARIES_RELEASE : [])
+
+    return entries.flatten.compact
   end
 
   # A release's object list can include precompiled libraries/archives
@@ -221,35 +225,20 @@ class ReleaseBuildExecutor
   # arguments rather than as ordinary link inputs, so they're split out here
   # by file extension before linking.
   def sort_objects_and_libraries(both)
-    # A library type may be named by several extensions at once (.a and .so, say), so its
-    # regex alternation is built from however many are configured -- one entry needs no
-    # alternation at all, several are joined into one. Enumerable is the test rather than
-    # Array specifically, since a library-type extension is a FilenameExtension by the time
-    # it reaches here, not a raw Array, even though both are iterable the same way.
-    extension = if ((defined? EXTENSION_SUBPROJECTS) && (defined? EXTENSION_LIBRARIES))
-      extension_libraries = if (EXTENSION_LIBRARIES.is_a? Enumerable)
-                              EXTENSION_LIBRARIES.to_a.join(")|(?:\\")
-                            else
-                              EXTENSION_LIBRARIES
-                            end
-      "(?:\\#{EXTENSION_SUBPROJECTS})|(?:\\#{extension_libraries})"
-    elsif (defined? EXTENSION_SUBPROJECTS)
-      "\\#{EXTENSION_SUBPROJECTS}"
-    elsif (defined? EXTENSION_LIBRARIES)
-      if (EXTENSION_LIBRARIES.is_a? Enumerable)
-        "(?:\\#{EXTENSION_LIBRARIES.to_a.join(")|(?:\\")})"
-      else
-        "\\#{EXTENSION_LIBRARIES}"
-      end
-    else
-      "\\.LIBRARY"
-    end
     # Compile once rather than once per entry in `both`
-    library_pattern = /.+#{extension}$/
+    library_pattern = /.+#{library_endings()}$/
     sorted_objects = both.group_by { |v| v.match?( library_pattern ) ? :libraries : :objects }
-    libraries = sorted_objects[:libraries] || []
-    objects   = sorted_objects[:objects]   || []
-    return objects, libraries
+    return (sorted_objects[:objects] || []), (sorted_objects[:libraries] || [])
+  end
+
+  # A library type may be named by several extensions at once (.a and .so, say), and a
+  # subproject's by its own
+  def library_endings
+    endings = []
+    endings << FilenameExtension.new( EXTENSION_SUBPROJECTS ).pattern if defined? EXTENSION_SUBPROJECTS
+    endings << FilenameExtension.new( EXTENSION_LIBRARIES ).pattern if defined? EXTENSION_LIBRARIES
+    endings << Regexp.escape( '.LIBRARY' ) if endings.empty?
+    return "(?:#{endings.join( '|' )})"
   end
 
   # States, in one line, how many targets a build step left untouched because nothing

data/lib/ceedling/release_invoker/release_build_planner.rb

@@ -34,15 +34,16 @@ class ReleaseBuildPlanner
   def plan(state, files: nil)
     tailor_release_tools()
 
-    sources =
+    # A link-only name is no source of its own. Placed apart from the sources, one naming
+    # the object a source builds to joins it rather than colliding with it.
+    sources, link_only =
       if files.nil?
-        @configurator.collection_release_build_input +
-          @configurator.collection_release_artifact_extra_link_objects
+        [@configurator.collection_release_build_input, @configurator.collection_release_artifact_extra_link_objects]
       else
-        files.dup
+        [files.dup, []]
       end
 
-    state.objects        = @file_path_utils.form_release_build_objects_filelist( sources )
+    state.objects        = release_objects( sources, link_only )
     state.compile_flags   = @flaginator.flag_down( context: RELEASE_SYM, operation: OPERATION_COMPILE_SYM )
     state.assemble_flags  = @flaginator.flag_down( context: RELEASE_SYM, operation: OPERATION_ASSEMBLE_SYM )
     state.link_flags      = @flaginator.flag_down( context: RELEASE_SYM, operation: OPERATION_LINK_SYM )
@@ -52,6 +53,13 @@ class ReleaseBuildPlanner
 
   private
 
+  def release_objects(sources, link_only)
+    objects = @file_path_utils.form_release_build_objects_filelist( sources ).to_a
+    return objects if link_only.empty?
+
+    return (objects + @file_path_utils.form_release_build_objects_filelist( link_only ).to_a).uniq
+  end
+
   # Shared libraries and static archives need compiler/linker argument tags
   # (-fPIC, -shared, or swapping the linker for `ar` outright) that a plain
   # executable target doesn't -- derived once per build from the release
@@ -73,7 +81,7 @@ class ReleaseBuildPlanner
     when '.a'
       compiler[:arguments] << '-fPIC' unless compiler[:arguments].include?('-fPIC')
       linker[:executable] = 'ar'
-      linker[:arguments]  = ['rcs', '${2}', '${1}']
+      linker[:arguments]  = ['rcs', '"${2}"', '"${1}"']
     end
   end