ceedling 0.9.0 → 1.0.1

data/lib/ceedling/preprocessinator_includes_handler.rb

@@ -0,0 +1,382 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+class PreprocessinatorIncludesHandler
+
+  constructor :configurator, :tool_executor, :test_context_extractor, :file_wrapper, :yaml_wrapper, :loginator, :reportinator
+
+  ##
+  ## Includes Extraction Overview
+  ## ============================
+  ##
+  ## BACKGROUND
+  ## --------
+  ## #include extraction is hard to do. In simple cases a regex approach suffices, but nested header files,
+  ## clever macros, and conditional preprocessing statements easily introduce high complexity.
+  ##
+  ## Unfortunately, there's no readily available cross-platform C parsing tool that provides a simple means 
+  ## to extract the #include statements directly embedded in a given file. Even the gcc preprocessor itself 
+  ## only comes close to providing this information externally.
+  ##
+  ## APPROACH
+  ## --------
+  ## (Full details including fallback options are in the extensive code comments among the methods below.)
+  ## 
+  ## Sadly, we can't preprocess a file with full search paths and defines and ask for the #include statements
+  ## embedded in a file. We get far more #includes than we want with no way to discern which are at the depth
+  ## of the file being processed.
+  ##
+  ## Instead, we try our best to use some educated guessing to get as close as possible to the desired list.
+  ##
+  ##   I. Try to extract shallow defines with no crawling out into other header files. This conservative approach
+  ##      gives us a reference point on possible directly included files. The results may be incomplete, though. 
+  ##      They also may mistakenly list #includes that should not be in the list--because of #ifndef defaults or
+  ##      because of system headers or #include <...> statements and differences among gcc implementations.
+  ##
+  ##  II. Extract a full list of #includes by spidering out into nested headers and processing all macros, etc.
+  ##      This is the greedy approach.
+  ##
+  ## III. Find #includes common to (I) and (II). The results of (I) should limit the potentially lengthy
+  ##      results of (II). The complete and accurate list of (II) should cut out any mistaken entries in (I).
+  ##
+  ##  IV. I–III are not foolproof. A purely greedy approach or a purely conservative approach will cause symbol 
+  ##      conflicts, missing symbols, etc. The blended and balanced approach should come quite close to an 
+  ##      accurate list of shallow includes. Edge cases and gaps will cause trouble. Other Ceedling features 
+  ##      should provide the tools to intervene. 
+  ##
+
+  def extract_includes(filepath:, test:, flags:, include_paths:, defines:, deep: false)
+    msg = @reportinator.generate_module_progress(
+      operation: "Extracting #include statements via preprocessor from",
+      module_name: test,
+      filename: File.basename(filepath)
+      )
+    @loginator.log(msg, Verbosity::NORMAL)
+
+    # Extract shallow includes with preprocessor and fallback regex
+    shallow = extract_shallow_includes(
+      test:     test,
+      filepath: filepath,
+      flags:    flags,
+      defines:  defines
+      )
+
+    # Extract nested includes but optionally act in fallback mode
+    nested = extract_nested_includes(
+      filepath:      filepath,
+      include_paths: include_paths,
+      flags:         flags,
+      defines:       defines,
+      # If no shallow results, fall back to only depth 1 results of nested discovery
+      shallow:       shallow.empty?
+      )
+
+    # Combine shallow and nested include knowledge of mocks
+    mocks = combine_mocks(shallow, nested)
+
+    # Redefine shallow and nested results without any mocks
+    shallow = remove_mocks( shallow )
+    nested  = remove_mocks( nested )
+
+    # Return
+    #  - Includes common to shallow and nested results, with paths from nested
+    #  - Add mocks back in (may be empty if mocking not enabled)
+    return common_includes(shallow:shallow, nested:nested, deep:deep) + mocks
+  end
+
+  # Write to disk a yaml representation of a list of includes
+  def write_includes_list(filepath, list)
+    @yaml_wrapper.dump(filepath, list)
+  end
+
+  ### Private ###
+  private
+
+  def extract_shallow_includes(test:, filepath:, flags:, defines:)
+    # Shallow includes extraction, first attempt with preprocessor
+    success, shallow = 
+      extract_shallow_includes_preprocessor(
+        test:     test,
+        filepath: filepath,
+        flags:    flags,
+        defines:  defines
+        )
+
+    # Shallow includes extraction, second attempt with file read + regex
+    if not success
+      shallow = extract_shallow_includes_regex(
+        test:     test,
+        filepath: filepath,
+        flags:    flags,
+        defines:  defines
+        )
+    end
+
+    return shallow
+  end
+
+  def extract_shallow_includes_preprocessor(test:, filepath:, flags:, defines:)
+    ##
+    ## Preprocessor Make Rule Handling
+    ## ===============================
+    ##
+    ## Creation:
+    ##  - This output is created with the -MM -MG -MP command line options.
+    ##  - No search paths are used towards extracting only the #include statements of the file.
+    ##    The intent is to minimize the list of .h -> .c module matches to, in turn, minimize
+    ##    unnecessary compilation when extracting includes from a test file.
+    ##  - Note: This approach can have gaps with complex macros / conditional statements.
+    ##          Gaps can be minimized with proper defines in the project file.
+    ##          However, needed / complex macros located in other header files can still gum 
+    ##          up the works.
+    ##
+    ## Format:
+    ##  - First line is .o file followed by colon and dependencies (on one or more lines).
+    ##  - "Phony" make rules follow that conveniently list each #include, one per line.
+    ##
+    ## Notes:
+    ##  - Many errors can occur but may not necessarily prevent usable results.
+    ##  - A file with no includes will create the first line with self-referential .h file path.
+    ##  - Make rule formation assumes any files not found in a search path will be generated.
+    ##    - Since we're not using search paths, the preprocessor largely assumes all #include 
+    ##      files are generated (and include no paths).
+    ##    - The exception is #include files that exist in the same directory as the file
+    ##      being processed.
+    ##
+    ## Approach:
+    ##  1. Disable exceptions for tool execution as errors are likely.
+    ##    - We may still have usable output.
+    ##    - We do not want to stop execution on fatal error; instead use a fallback method.
+    ##  2. The only true error is no make rule present--check for this first.
+    ##    - A make rule may be present but not depedencies if the file has no #includes.
+    ##  3. Extract includes from "phony" make rules that follow opening rule line.
+    ##    - These may be .h or .c files.
+    ## 
+    ## Example output follows
+    ## -----------------------------------------------------------------------------------------
+    ## os.o: ../../src/app/task/os/os.h fstd_types.h FreeRTOS.h queue.h
+    ## fstd_types.h:
+    ## FreeRTOS.h:
+    ## queue.h:
+    ## ../../src/app/task/os/os.h:72:21: error: no include path in which to search for stdbool.h
+    ##    72 | #include <stdbool.h>
+    ##       |                     ^
+    ## ../../src/app/task/os/os.h:73:20: error: no include path in which to search for stdint.h
+    ##    73 | #include <stdint.h>
+    ##       |                    ^
+    ##
+
+    # Matcher for the first line of the make rule output
+    make_rule_matcher = /^\S+\.o:\s+.+$/  # <characters>.o: <characters>
+    
+    # Matcher for the “phony“ make rule output lines for each #include dependency (.h, .c, etc.)
+    # Capture file name before the colon
+    include_matcher   = /^(\S+\.\S+):\s*$/ # <characters>.<extension>:
+
+    command = 
+      @tool_executor.build_command_line(
+        @configurator.tools_test_shallow_includes_preprocessor,
+        flags,
+        filepath,
+        defines
+        )
+
+    # Assume possible errors so we have best shot at extracting results from preprocessing.
+    # Full code compilation will catch any breaking code errors
+    command[:options][:boom] = false
+    shell_result = @tool_executor.exec( command )
+
+    make_rules = shell_result[:output]
+
+    # Do not check exit code for success. In some error conditions we still get usable output.
+    # Look for the first line of the make rule output.
+    if not make_rules =~ make_rule_matcher
+      msg = "Preprocessor #include extraction failed: #{shell_result[:output]}"
+      @loginator.log(msg, Verbosity::DEBUG)
+
+      return false, []
+    end
+
+    includes = []
+
+    # Extract the #include dependencies from the "phony" make rules, one per line
+    includes = make_rules.scan( include_matcher )
+    includes.flatten! # Regex results can be nested arrays becuase of paren captures
+
+    return true, includes.uniq
+  end
+
+  def extract_shallow_includes_regex(test:, filepath:, flags:, defines:)
+    msg = @reportinator.generate_module_progress(
+      operation: "Using fallback regex #include extraction for",
+      module_name: test,
+      filename: File.basename( filepath )
+      )
+    @loginator.log(msg, Verbosity::NORMAL)
+
+    # Use abilities of @test_context_extractor to extract the #includes via regex on the file
+    includes = []
+    @file_wrapper.open( filepath, 'r' ) do |file|
+      includes = @test_context_extractor.extract_includes( file )
+    end
+
+    return includes
+  end
+
+  def extract_nested_includes(filepath:, include_paths:, flags:, defines:, shallow:false)
+    ##
+    ## Preprocessor Header File Listing Handling
+    ## =========================================
+    ##
+    ## Creation:
+    ##  - This output is created with the -MM -MG -H command line options.
+    ##    - -MM -MG generates unused make rule that significantly reduces overall output.
+    ##    - -H creates the header file output listing we actually want.
+    ##  - Search paths are provided towards fully preprocessing all macros / conditionals and
+    ##    symbols. (This produces a rich list of #includes far greater than we need.)
+    ##
+    ## Format (ignoring throwaway make rule):
+    ##  - Each included filepath is listed per line.
+    ##  - The depth of the #include nesting is signified by precending '.'s.
+    ##  - Files directly #include'd in the file being preprocessed are at depth 1 ('.')
+    ##
+    ## Notes:
+    ##  - Because search paths and defines are provided, error-free execution is assumed.
+    ##    If the preprocessor fails, issues exist that will cause full compilation to fail.
+    ##  - Unfortuantely, because of ordering and nesting effects, a file directly #include'd may
+    ##    not be listed at depth 1 ('.'). Instead, it may end up listed at greater depth beneath 
+    ##    another #include'd file if both files reference it. That is, there is no way
+    ##    to give the preprocessor full context and ask for only the files directly 
+    ##    #include'd in the file being processed.
+    ##  - The preprocessor outputs the -H #include listing to STDERR. ToolExecutor does this
+    ##    by default in creating the shell result output.
+    ##  - Since we're using search paths, all #included files will include paths. Depending on
+    ##    circumstances, this could yield a list with generated mocks with full build paths.
+    ##
+    ## Approach:
+    ##  - Match on each listing line a filepath preceeded by its depth
+    ##  - One mode of using this preprocessor approach is as a fallback / double-check method 
+    ##    if the simpler, earler shallow preprocessing produces no #include results. When used
+    ##    this way we match only #include'd files at depth 1 ('.'), hoping we extract an
+    ##    appropriate, usable list of #includes.
+    ## 
+    ## Example output follows
+    ## -----------------------------------------------------------------------------------------
+    ## . build/vendor/unity/src/unity.h
+    ## .. build/vendor/unity/src/unity_internals.h
+    ## . src/Types.h
+    ## . src/Model.h
+    ## . src/TimerModel.h
+    ## .. src/Testing.h
+    ## TestModel.o: test/TestModel.c build/vendor/unity/src/unity.h \
+    ##   build/vendor/unity/src/unity_internals.h setjmp.h math.h stddef.h \
+    ##   stdint.h limits.h stdio.h src/Types.h src/Model.h src/TimerModel.h \
+    ##   src/Testing.h MockTaskScheduler.h MockTemperatureFilter.h
+    ##
+
+    command = 
+      @tool_executor.build_command_line(
+        @configurator.tools_test_nested_includes_preprocessor,
+        flags,
+        filepath,
+        include_paths,
+        defines
+      )
+
+    # Let the preprocessor do as much as possible
+    # We'll extract nothing if a catastrophic error, but we'll see it in debug logging
+    # Any real problems will be flagged by actual compilation step
+    command[:options][:boom] = false
+
+    shell_result = @tool_executor.exec( command )
+
+    list = shell_result[:output]
+
+    includes = []
+
+    # Extract entries from #include listing
+    if shallow
+      # First level of includes in preprocessor output
+      includes = list.scan(/^\. (.+$)\s*$/)  # . <filepath>
+    else
+      # All levels of includes in preprocessor output
+      includes = list.scan(/^\.+ (.+$)\s*$/) # ... <filepath>
+    end
+
+    includes.flatten! # Regex results can be nested arrays becuase of paren captures
+
+    return includes.uniq
+  end
+
+  def combine_mocks(*lists)
+    # Handle mocks
+    #  - Ensure no build filepaths in mock listings
+    #  - Do not return mocks if mocking is disabled
+    mocks = []
+
+    # Bail out early if mocks are not enabled
+    return [] if !@configurator.project_use_mocks
+
+    # Use some greediness to ensure we get all possible mocks
+    lists.each { |list| mocks |= extract_mocks( list ) }      
+
+    # If generated mocks are in the build directory, the preprocessor will have found them.
+    # This leads to duplicated mocks -- the shallow list with no paths and the nested list with paths.
+    # Remove mocks with any path (the path will be the build directory); preserve just the shallow list.
+    mocks.reject! {|mock| File.dirname( mock ) != '.' }
+
+    return mocks
+  end
+
+  # Return a list of mock .h files with no paths
+  def extract_mocks(includes)
+    return includes.select { |include| File.basename(include).start_with?( @configurator.cmock_mock_prefix ) }
+  end
+
+  # Return list of includes with any mocks removed
+  def remove_mocks(includes)
+    return includes.reject { |include| File.basename(include).start_with?( @configurator.cmock_mock_prefix ) }
+  end
+
+  # Return includes common in both lists with the full paths of the nested list
+  def common_includes(shallow:, nested:, deep: false)
+    return shallow if nested.empty?
+    return nested if shallow.empty?
+
+    # Notes:
+    #  - We want to preserve filepaths whenever possible. Other areas of Ceedling use or discard the 
+    #    filepath as needed.
+    #  - We generally do not have filepaths in the shallow list--except when the #include is in the 
+    #    same directory as the file being processed
+
+    # Approach
+    #  1. Create hashed lists of shallow and nested for easier matching 
+    #  2. Perform appropriate mix of paths
+    #    a. A union if performing a deep include list
+    #    b. An intersection if performing a shallow include list
+    #  3. Pick the "fullest" path from the lists (assumes nested list has deeper paths)
+
+    # Hash list for Shallow Search
+    _shallow = {}
+    shallow.each { |item| _shallow[ File.basename(item) ] = item }
+
+    # Hash list for Nested Search
+    _nested = {}
+    nested.each {|item|  _nested[ File.basename(item) ] = item }
+
+    # Determine the filenames to include in our list
+    basenames = if deep
+      ( _nested.keys.to_set.union( _shallow.keys.to_set ) )
+    else
+      ( _nested.keys.to_set.intersection( _shallow.keys.to_set ) )
+    end
+
+    # Iterate through the basenames and return the fullest version of each
+    return basenames.map {|v| _nested[v] || _shallow[v] }
+  end
+
+end

data/lib/ceedling/rake_utils.rb

@@ -0,0 +1,23 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-25 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

data/lib/ceedling/rake_wrapper.rb

@@ -0,0 +1,40 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+require 'rubygems'
+require 'rake'
+require 'ceedling/makefile' # our replacement for rake's make-style dependency loader
+
+include Rake::DSL if defined?(Rake::DSL)
+
+class Rake::Task
+  attr_reader :already_invoked
+end
+
+class RakeWrapper
+
+  def initialize
+    @makefile_loader = Rake::MakefileLoader.new # use our custom replacement noted above
+  end
+
+  def [](task)
+    return Rake::Task[task]
+  end
+
+  def task_list
+    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/rakefile.rb

@@ -0,0 +1,145 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+require 'fileutils'
+
+# Add Unity and CMock's Ruby code paths to $LOAD_PATH for runner generation and mocking
+$LOAD_PATH.unshift( File.join( CEEDLING_APPCFG[:ceedling_vendor_path], 'unity/auto') )
+$LOAD_PATH.unshift( File.join( CEEDLING_APPCFG[:ceedling_vendor_path], 'cmock/lib') )
+
+require 'rake'
+
+# Let's make sure we remember the task descriptions in case we need them
+Rake::TaskManager.record_task_metadata = true
+
+require 'ceedling/system_wrapper'
+require 'ceedling/reportinator'
+
+# Operation duration logging
+def log_runtime(run, start_time_s, end_time_s, enabled)
+  return if !enabled
+  return if !defined?(PROJECT_VERBOSITY)
+  return if (PROJECT_VERBOSITY < Verbosity::NORMAL)
+
+  duration = Reportinator.generate_duration( start_time_s: start_time_s, end_time_s: end_time_s )
+
+  return if duration.empty?
+
+  @ceedling[:loginator].log() # Blank line
+  @ceedling[:loginator].log( "Ceedling #{run} completed in #{duration}", Verbosity::NORMAL)
+end
+
+start_time = nil # Outside scope of exception handling
+
+# Top-level exception handling for any otherwise un-handled exceptions, particularly around startup
+begin
+  # Redefine start_time with actual timestamp before set up begins
+  start_time = SystemWrapper.time_stopwatch_s()
+
+  # Construct all objects
+  #  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] )
+  objects_filepath = File.join( CEEDLING_APPCFG[:ceedling_lib_path], 'objects.yml' )
+  
+  # Create object hash and dependency injection context
+  @ceedling = {} # Empty hash to be redefined if all goes well
+  @ceedling = DIY::Context.from_yaml( File.read( objects_filepath ) )
+
+  # Inject objects already insatantiated from bin/ bootloader before building the rest
+  CEEDLING_HANDOFF_OBJECTS.each_pair {|name,obj| @ceedling.set_object( name.to_s, obj )}
+
+  # Build Ceedling application's objects
+  @ceedling.build_everything()
+
+  # Simplify load path after construction
+  $LOAD_PATH.delete( CEEDLING_APPCFG[:ceedling_lib_path] )
+
+  # One-stop shopping for all our setup and such after construction
+  @ceedling[:setupinator].ceedling = @ceedling
+  @ceedling[:setupinator].do_setup( CEEDLING_APPCFG )
+
+  setup_done = SystemWrapper.time_stopwatch_s()
+  log_runtime( 'set up', start_time, setup_done, CEEDLING_APPCFG.build_tasks? )
+
+  # Configure high-level verbosity
+  unless defined?(PROJECT_DEBUG) and PROJECT_DEBUG
+    # Configure Ruby's default reporting for Thread exceptions.
+    # In Ceedling's case thread scenarios will fall into these buckets:
+    #  1. Jobs shut down cleanly
+    #  2. Jobs shut down at garbage collected after a build step terminates with an error
+    #
+    # Since Ceedling is not a daemon, server app, or something to run continuously,
+    # we can safely disable forced exception reporting.
+    Thread.report_on_exception = false
+
+    # Tell Rake to shut up by default unless we're in DEBUG
+    verbose(false)
+    Rake.application.options.silent = true
+
+    # Remove all Rake backtrace
+    Rake.application.options.suppress_backtrace_pattern = /.*/
+  end
+
+  # Reset start_time before operations begins
+  start_time = SystemWrapper.time_stopwatch_s()
+
+  # Tell all our plugins we're about to do something
+  @ceedling[:plugin_manager].pre_build if CEEDLING_APPCFG.build_tasks?
+
+  # load rakefile component files (*.rake)
+  PROJECT_RAKEFILE_COMPONENT_FILES.each { |component| load(component) }
+rescue StandardError => ex
+  boom_handler( @ceedling[:loginator], ex )
+  exit(1)
+end
+
+def test_failures_handler()
+  # $stdout test reporting plugins store test failures
+  exit(1) if @ceedling[:plugin_manager].plugins_failed? && !CEEDLING_APPCFG.tests_graceful_fail?
+end
+
+# End block always executed following rake run
+END {
+  $stdout.flush unless $stdout.nil?
+  $stderr.flush unless $stderr.nil?
+
+  # Only perform these final steps if we got here without runtime exceptions or errors
+  if @ceedling[:application].build_succeeded?
+    # Tell all our plugins the build is done and process results
+    begin
+      if CEEDLING_APPCFG.build_tasks?
+        @ceedling[:plugin_manager].post_build
+        @ceedling[:plugin_manager].print_plugin_failures
+      end
+      ops_done = SystemWrapper.time_stopwatch_s()
+      log_runtime( 'operations', start_time, ops_done, CEEDLING_APPCFG.build_tasks? )
+      test_failures_handler() if (@ceedling[:task_invoker].test_invoked? || @ceedling[:task_invoker].invoked?(/^gcov:/))
+    rescue => ex
+      ops_done = SystemWrapper.time_stopwatch_s()
+      log_runtime( 'operations', start_time, ops_done, CEEDLING_APPCFG.build_tasks? )
+      boom_handler( @ceedling[:loginator], ex )
+      @ceedling[:loginator].wrapup
+      exit(1)
+    end
+
+    @ceedling[:loginator].wrapup
+    exit(0)
+  else
+    msg = "Ceedling could not complete operations because of errors"
+    @ceedling[:loginator].log( msg, Verbosity::ERRORS, LogLabels::TITLE )
+    begin
+      @ceedling[:plugin_manager].post_error if CEEDLING_APPCFG.build_tasks?
+    rescue => ex
+      boom_handler( @ceedling[:loginator], ex)
+    ensure
+      @ceedling[:loginator].wrapup
+      exit(1)
+    end
+  end
+}

data/lib/ceedling/release_invoker.rb

@@ -0,0 +1,68 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+require 'ceedling/constants'
+
+
+class ReleaseInvoker
+
+  constructor :configurator, :release_invoker_helper, :dependinator, :task_invoker, :file_path_utils, :file_wrapper
+
+
+  def setup_and_invoke_objects( files )
+    objects = @file_path_utils.form_release_build_objects_filelist( files )
+    @task_invoker.invoke_release_objects( objects )
+    return objects
+  end
+
+  def artifactinate( *files )
+    files.flatten.each do |file|
+      @file_wrapper.cp( file, @configurator.project_release_artifacts_path ) if @file_wrapper.exist?( file )
+    end
+  end
+
+  def convert_libraries_to_arguments(libraries)
+    args = ((libraries || []) + ((defined? LIBRARIES_SYSTEM) ? LIBRARIES_SYSTEM : [])).flatten
+    if (defined? LIBRARIES_FLAG)
+      args.map! {|v| LIBRARIES_FLAG.gsub(/\$\{1\}/, v) }
+    end
+    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
+  end
+
+  def sort_objects_and_libraries(both)
+    extension = if ((defined? EXTENSION_SUBPROJECTS) && (defined? EXTENSION_LIBRARIES))
+      extension_libraries = if (EXTENSION_LIBRARIES.class == Array)
+                              EXTENSION_LIBRARIES.join(")|(?:\\")
+                            else
+                              EXTENSION_LIBRARIES
+                            end
+      "(?:\\#{EXTENSION_SUBPROJECTS})|(?:\\#{extension_libraries})"
+    elsif (defined? EXTENSION_SUBPROJECTS)
+      "\\#{EXTENSION_SUBPROJECTS}"
+    elsif (defined? EXTENSION_LIBRARIES)
+      if (EXTENSION_LIBRARIES.class == Array)
+        "(?:\\#{EXTENSION_LIBRARIES.join(")|(?:\\")})"
+      else
+        "\\#{EXTENSION_LIBRARIES}"
+      end
+    else
+      "\\.LIBRARY"
+    end
+    sorted_objects = both.group_by {|v| v.match(/.+#{extension}$/) ? :libraries : :objects }
+    libraries = sorted_objects[:libraries] || []
+    objects   = sorted_objects[:objects]   || []
+    return objects, libraries
+  end
+end

data/lib/ceedling/release_invoker_helper.rb

@@ -0,0 +1,12 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+class ReleaseInvokerHelper
+
+  constructor :configurator, :dependinator, :task_invoker
+
+end