ceedling 1.0.1 → 1.1.0

data/lib/ceedling/{configurator.rb → config/configurator.rb}

@@ -1,7 +1,7 @@
 # =========================================================================
 #   Ceedling - Test-Centered Build System for C
 #   ThrowTheSwitch.org
-#   Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
 #   SPDX-License-Identifier: MIT
 # =========================================================================
 
@@ -9,6 +9,8 @@ require 'ceedling/defaults'
 require 'ceedling/constants'
 require 'ceedling/file_path_utils'
 require 'ceedling/exceptions'
+require 'ceedling/rake_app/rakefile_component_resolver'
+require 'ceedling/config/config_matchinator'
 require 'deep_merge'
 
 class Configurator
@@ -16,7 +18,7 @@ class Configurator
   attr_reader :project_config_hash, :programmatic_plugins, :rake_plugins
   attr_accessor :project_logging, :sanity_checks, :include_test_case, :exclude_test_case
 
-  constructor :configurator_setup, :configurator_builder, :configurator_plugins, :config_walkinator, :yaml_wrapper, :system_wrapper, :loginator, :reportinator
+  constructor :configurator_setup, :configurator_builder, :configurator_plugins, :config_walkinator, :yaml_wrapper, :system_wrapper, :loginator, :reportinator, :ruby_expandinator
 
   def setup()
     # Cmock config reference to provide to CMock for mock generation
@@ -67,10 +69,91 @@ class Configurator
   end
 
 
+  def set_partials_derived_config(config)
+    return if !config[:project][:use_partials]
+
+    # If partials enabled, enable mocking
+    config[:project][:use_mocks] = true
+    @loginator.log( " > Enabled mocking." )
+
+    # If partials enabled, enable full test preprocessing
+    config[:project][:use_test_preprocessor] = :all
+    @loginator.log( " > Enabled preprocessing." )
+
+    # If partials enabled and CMock's `:treat_inlines` is enabled, quietly disable.
+    # Enabling Partials and this feature causes extra processing for Ceedling and CMock that is never used.
+    if config[:cmock][:treat_inlines] == :include
+      config[:cmock][:treat_inlines] = :exclude
+      @loginator.log( "Reverted :cmock ↳ :treat_inlines to :exclude because this CMock feature is superseded by Partials.", Verbosity::COMPLAIN, LogLabels::NOTICE )
+    end
+
+    # If partials enabled, inject partials name prefix symbol to all test compilation.
+    # Handle both the simple list and matcher hash config formats.
+    _partials_prefix_symbol = "CEEDLING_PARTIALS_PREFIX=#{PARTIAL_FILENAME_PREFIX}"
+    ConfigMatchinator.append_matcher_entries( config[:defines][:test], _partials_prefix_symbol )
+  end
+
+
+  def resolve_directives_only_preprocessing(config, tool_executor)
+    # Nothing to probe if preprocessing is disabled
+    preprocessing = config[:project][:use_test_preprocessor]
+    config[:test_build][:preprocess_directives_only_available] = false
+    return if preprocessing == :none
+
+    # When forced fallback is enabled, skip the probe and mark directives-only unavailable
+    if config[:test_build][:preprocess_force_fallback]
+      @loginator.log(
+        "Forcing fallback text-based preprocessing in place of directives-only (:test_build ↳ :preprocess_force_fallback is enabled).",
+        Verbosity::COMPLAIN,
+        LogLabels::NOTICE
+      )
+      return
+    end
+
+    # Probe whether the configured C preprocessor supports -fdirectives-only.
+    # Use the Unity header as it is always-available, self-contained, no include paths needed.
+    # Output goes to stdout (no -o flag) to avoid platform-specific null device paths.
+    probe_filepath = File.join( CEEDLING_VENDOR, UNITY_LIB_PATH, UNITY_H_FILE )
+
+    # Minimal subset of the directives-only preprocessor tool: no defines, no include paths,
+    # no output file. Sufficient to detect `-fdirectives-only` support via warning or exit code.
+    probe_tool = {
+      executable: config[:tools][:test_file_directives_only_preprocessor][:executable],
+      name:       'directives_only_probe',
+      arguments:  [
+        '-E',
+        '-fdirectives-only',
+        '-x c',
+        "\"${1}\""
+      ]
+    }
+
+    command = tool_executor.build_command_line( probe_tool, [], probe_filepath )
+    # Exception if something goes wrong; we want to detect errors here
+    command[:options][:boom] = false
+    results = tool_executor.exec( command )
+
+    # Clang and some older GCC emit a warning (not an error) when -fdirectives-only is unsupported
+    warning_detected = results[:output].match?( /warning[^\n]+-fdirectives-only/ )
+
+    if warning_detected || results[:exit_code] != 0
+      @loginator.log(
+        "Preprocessor lacks -fdirectives-only support ➡️ Ceedling will use text-based fallback for preprocessing.",
+        Verbosity::COMPLAIN,
+        LogLabels::NOTICE
+      )
+      # :preprocess_directives_only_available already set to false above
+    else
+      config[:test_build][:preprocess_directives_only_available] = true
+    end
+  end
+
+
   # The default tools (eg. DEFAULT_TOOLS_TEST) are merged into default config hash
   def merge_tools_defaults(config, default_config)
-    msg = @reportinator.generate_progress( 'Collecting default tool configurations' )
-    @loginator.log( msg, Verbosity::OBNOXIOUS )
+    @loginator.lazy( Verbosity::OBNOXIOUS ) do 
+      @reportinator.generate_progress( 'Collecting default tool configurations' )
+    end
 
     # config[:project] is guaranteed to exist / validated to exist but may not include elements referenced below
     # config[:test_build] and config[:release_build] are optional in a user project configuration
@@ -116,8 +199,9 @@ class Configurator
     # Cmock has its own internal defaults handling, but we need to set these specific values
     # so they're guaranteed values and present for the Ceedling environment to access
 
-    msg = @reportinator.generate_progress( 'Collecting CMock defaults' )
-    @loginator.log( msg, Verbosity::OBNOXIOUS )
+    @loginator.lazy( Verbosity::OBNOXIOUS ) do 
+      @reportinator.generate_progress( 'Collecting CMock defaults' )
+    end
 
     # Begin populating defaults with CMock defaults as set by Ceedling
     default_cmock = default_config[:cmock]
@@ -131,14 +215,16 @@ class Configurator
   def prepare_plugins_load_paths(plugins_load_path, config)
     # Plugins must be loaded before generic path evaluation & magic that happen later.
     # So, perform path magic here as discrete step.
+    # (String replacement and standardization require DI objects not available in bin/ scope.)
     config[:plugins][:load_paths].each do |path|
-      path.replace( @system_wrapper.module_eval( path ) ) if (path =~ PATTERNS::RUBY_STRING_REPLACEMENT)
-      FilePathUtils::standardize( path )
+      path.replace( @ruby_expandinator.expand( path, source: ":plugins ↳ :load_paths" ) )
+      FilePathUtils::standardize_in_place( path )
     end
 
-    # Add Ceedling's plugins path as load path so built-in plugins can be found
-    config[:plugins][:load_paths] << plugins_load_path
-    config[:plugins][:load_paths].uniq!
+    # Delegate list construction to the shared helper (user paths first, built-in last).
+    # This mirrors what RakefileComponentResolver.resolve() does in the bin/ CLI scope,
+    # ensuring both scopes search plugins in the same priority order.
+    config[:plugins][:load_paths] = RakefileComponentResolver.prepare_plugin_load_paths( config, plugins_load_path )
 
     return @configurator_plugins.process_aux_load_paths( config )
   end
@@ -153,29 +239,40 @@ class Configurator
 
 
     if !plugin_hash_defaults.empty?
-      msg = @reportinator.generate_progress( 'Collecting Plugin YAML defaults' )
-      @loginator.log( msg, Verbosity::OBNOXIOUS )
+      @loginator.lazy( Verbosity::OBNOXIOUS ) do 
+        @reportinator.generate_progress( 'Collecting Plugin YAML defaults' )
+      end
     end
 
     # Load base configuration values (defaults) from YAML
     plugin_yml_defaults.each do |plugin, defaults|
-      _defaults = @yaml_wrapper.load( defaults )
+      _defaults = begin
+        @yaml_wrapper.load( defaults )
+      rescue YamlLoadException => e
+        raise YamlLoadException.new(
+          reason: e.reason, source: e.source, original_error: e.original_error,
+          message: "Could not load default configuration for plugin '#{plugin}' ⏩️ #{e.message}"
+        )
+      end
 
-      msg = " - #{plugin} >> " + _defaults.to_s()
-      @loginator.log( msg, Verbosity::DEBUG )
+      @loginator.lazy( Verbosity::DEBUG ) do
+        " - #{plugin} >> " + _defaults.to_s()
+      end
 
       default_config.deep_merge( _defaults )
     end
 
     if !plugin_hash_defaults.empty?
-      msg = @reportinator.generate_progress( 'Collecting Plugin Ruby hash defaults' )
-      @loginator.log( msg, Verbosity::OBNOXIOUS )
+      @loginator.lazy( Verbosity::OBNOXIOUS ) do 
+        @reportinator.generate_progress( 'Collecting Plugin Ruby hash defaults' )
+      end
     end
 
     # Load base configuration values (defaults) as hash from Ruby
     plugin_hash_defaults.each do |plugin, defaults|
-      msg = " - #{plugin} >> " + defaults.to_s()
-      @loginator.log( msg, Verbosity::DEBUG )
+      @loginator.lazy( Verbosity::DEBUG ) do 
+        " - #{plugin} >> " + defaults.to_s()
+      end
 
       default_config.deep_merge( defaults )
     end
@@ -187,24 +284,29 @@ class Configurator
     config.deep_merge( runtime_config )
   end
 
+  
   def populate_with_defaults( config_hash, defaults_hash )
-    msg = @reportinator.generate_progress( 'Populating project configuration with collected default values' )
-    @loginator.log( msg, Verbosity::OBNOXIOUS )    
+    @loginator.lazy( Verbosity::OBNOXIOUS ) do 
+      @reportinator.generate_progress( 'Populating project configuration with collected default values' )
+    end
 
     @configurator_builder.populate_with_defaults( config_hash, defaults_hash )
   end
 
 
   def populate_unity_config(config)
-    msg = @reportinator.generate_progress( 'Processing Unity configuration' )
-    @loginator.log( msg, Verbosity::OBNOXIOUS )
+    @loginator.lazy( Verbosity::OBNOXIOUS ) do 
+      @reportinator.generate_progress( 'Processing Unity configuration' )
+    end
 
     if config[:unity][:use_param_tests]
       config[:unity][:defines] << 'UNITY_SUPPORT_TEST_CASES'
       config[:unity][:defines] << 'UNITY_SUPPORT_VARIADIC_MACROS'
     end
 
-    @loginator.log( "Unity configuration >> #{config[:unity]}", Verbosity::DEBUG )    
+    @loginator.lazy( Verbosity::DEBUG ) do 
+      "Unity configuration >> #{config[:unity]}"
+    end
   end
 
 
@@ -216,12 +318,15 @@ class Configurator
 
     # Do no more prep if we're not using mocks
     if !config[:project][:use_mocks]
-      @loginator.log( "CMock configuration >> #{cmock}", Verbosity::DEBUG )
+      @loginator.lazy( Verbosity::DEBUG ) do 
+        "CMock configuration >> #{cmock}"
+      end
       return
     end
 
-    msg = @reportinator.generate_progress( 'Processing CMock configuration' )
-    @loginator.log( msg, Verbosity::OBNOXIOUS )
+    @loginator.lazy( Verbosity::OBNOXIOUS ) do
+      @reportinator.generate_progress( 'Processing CMock configuration' )
+    end
 
     # Plugins housekeeping
     cmock[:plugins].map! { |plugin| plugin.to_sym() }
@@ -237,19 +342,28 @@ class Configurator
 
     cmock[:includes].uniq!
 
-    @loginator.log( "CMock configuration >> #{cmock}", Verbosity::DEBUG )
+    # Add mocking prefix symbol for all test compilation
+    cmock[:defines] << "CMOCK_MOCK_PREFIX=#{cmock[:mock_prefix]}"
+
+    @loginator.lazy( Verbosity::DEBUG ) do
+      "CMock configuration >> #{cmock}"
+    end
   end
 
 
   def populate_test_runner_generation_config(config)
-    msg = @reportinator.generate_progress( 'Populating test runner generation settings' )
-    @loginator.log( msg, Verbosity::OBNOXIOUS )    
+    @loginator.lazy( Verbosity::OBNOXIOUS ) do
+      @reportinator.generate_progress( 'Populating test runner generation settings' )
+    end    
 
     use_backtrace = config[:project][:use_backtrace]
 
     # Force command line argument option for any backtrace option
     if use_backtrace != :none
-      config[:test_runner][:cmdline_args] = true
+      if config[:test_runner][:cmdline_args] == false
+        config[:test_runner][:cmdline_args] = true
+        @loginator.log( "Enabled :test_runner ↳ :cmdline_args because :project ↳ :use_backtrace is enabled.", Verbosity::COMPLAIN, LogLabels::NOTICE )
+      end
     end
 
     # Copy CMock options used by test runner generation
@@ -263,20 +377,25 @@ class Configurator
 
     @runner_config = config[:test_runner]
 
-    @loginator.log( "Test Runner configuration >> #{config[:test_runner]}", Verbosity::DEBUG )
+    @loginator.lazy( Verbosity::DEBUG ) do
+      "Test Runner configuration >> #{config[:test_runner]}"
+    end
   end
 
 
   def populate_exceptions_config(config)
     # Automagically set exception handling if CMock is configured for it
     if config[:cmock][:plugins] && config[:cmock][:plugins].include?(:cexception)
-      msg = @reportinator.generate_progress( 'Enabling CException use based on CMock plugins settings' )
-      @loginator.log( msg, Verbosity::OBNOXIOUS )    
+      @loginator.lazy( Verbosity::OBNOXIOUS ) do
+        @reportinator.generate_progress( 'Enabling CException use based on CMock plugins settings' )
+      end   
 
       config[:project][:use_exceptions] = true
     end
 
-    @loginator.log( "CException configuration >> #{config[:cexception]}", Verbosity::DEBUG )
+    @loginator.lazy( Verbosity::DEBUG ) do
+      "CException configuration >> #{config[:cexception]}"
+    end
   end
 
 
@@ -300,8 +419,9 @@ class Configurator
   #    - Handle needed defaults
   #  - Configure test runner from backtrace configuration
   def populate_tools_config(config)
-    msg = @reportinator.generate_progress( 'Populating tool definition settings and expanding any string replacements' )
-    @loginator.log( msg, Verbosity::OBNOXIOUS )
+    @loginator.lazy( Verbosity::OBNOXIOUS ) do
+      @reportinator.generate_progress( 'Populating tool definition settings and expanding any string replacements' )
+    end
 
     config[:tools].each_key do |name|
       tool = config[:tools][name]
@@ -330,17 +450,15 @@ class Configurator
   #   :arguments: [...]
   #   :executable: '...'
   def populate_tools_shortcuts(config)
-    msg = @reportinator.generate_progress( 'Processing tool definition shortcuts' )
-    @loginator.log( msg, Verbosity::OBNOXIOUS )
+    @loginator.lazy( Verbosity::OBNOXIOUS ) do
+      @reportinator.generate_progress( 'Processing tool definition shortcuts' )
+    end
 
     prefix = 'tools_'
     config[:tools].each do |name, tool|
       # Lookup shortcut tool definition (:tools_<name>)
       shortcut = (prefix + name.to_s).to_sym
 
-      # Logging message to be built up
-      msg = ''
-
       # Try to lookup the executable from user config
       executable, _  = @config_walkinator.fetch_value(shortcut, :executable, 
                          hash:config
@@ -352,52 +470,63 @@ class Configurator
                          default: []
                        )
 
-      # If either tool definition modification is happening, start building the logging message
-      if !args_to_add.empty? or !executable.nil?
-        msg += " > #{name}\n" 
-      end
-
-      # Log the executable and redefine the tool config
+      # Redefine the tool config
       if !executable.nil?
-        msg += "   executable: \"#{executable}\"\n"
         tool[:executable] = executable
       end
 
-      # Log the arguments and add to the tool config
+      # Add to the tool config
       if !args_to_add.empty?
-        msg += "   arguments: " + args_to_add.map{|arg| "\"#{arg}\""}.join( ', ' ) + "\n"
         tool[:arguments].concat( args_to_add )
       end
 
       # Log
-      @loginator.log( msg, Verbosity::DEBUG ) if !msg.empty?
+      if !args_to_add.empty? or !executable.nil?
+        @loginator.lazy( Verbosity::DEBUG ) do 
+          msg = " > #{name}\n"
+
+          if !executable.nil?
+            msg += "   executable: \"#{executable}\"\n"
+          end
+
+          if !args_to_add.empty?
+            msg += "   arguments: " + args_to_add.map{|arg| "\"#{arg}\""}.join( ', ' ) + "\n"
+          end
+
+          msg
+        end
+      end
     end
   end
 
 
   def discover_plugins(paths_hash, config)
-    msg = @reportinator.generate_progress( 'Discovering all plugins' )
-    @loginator.log( msg, Verbosity::OBNOXIOUS )
+    @loginator.lazy( Verbosity::OBNOXIOUS ) do
+      @reportinator.generate_progress( 'Discovering all plugins' )
+    end
 
     # Rake-based plugins
     @rake_plugins = @configurator_plugins.find_rake_plugins( config, paths_hash )
     if !@configurator_plugins.rake_plugins.empty?
-      msg = " > Rake plugins: " + @configurator_plugins.rake_plugins.map{|p| p[:plugin]}.join( ', ' )
-      @loginator.log( msg, Verbosity::DEBUG )
+      @loginator.lazy( Verbosity::DEBUG ) do
+        " > Rake plugins: " + @configurator_plugins.rake_plugins.map{|p| p[:plugin]}.join( ', ' )
+      end
     end
 
     # Ruby `Plugin` subclass programmatic plugins
     @programmatic_plugins = @configurator_plugins.find_programmatic_plugins( config, paths_hash )
     if !@configurator_plugins.programmatic_plugins.empty?
-      msg = " > Programmatic plugins: " + @configurator_plugins.programmatic_plugins.map{|p| p[:plugin]}.join( ', ' )
-      @loginator.log( msg, Verbosity::DEBUG )
+      @loginator.lazy( Verbosity::DEBUG ) do
+        " > Programmatic plugins: " + @configurator_plugins.programmatic_plugins.map{|p| p[:plugin]}.join( ', ' )
+      end
     end
     
     # Config plugins
-    config_plugins = @configurator_plugins.find_config_plugins( config, paths_hash )
+    @configurator_plugins.find_config_plugins( config, paths_hash )
     if !@configurator_plugins.config_plugins.empty?
-      msg = " > Config plugins: " + @configurator_plugins.config_plugins.map{|p| p[:plugin]}.join( ', ' )
-      @loginator.log( msg, Verbosity::DEBUG )
+      @loginator.lazy( Verbosity::DEBUG ) do
+        " > Config plugins: " + @configurator_plugins.config_plugins.map{|p| p[:plugin]}.join( ', ' )
+      end
     end
   end
 
@@ -416,11 +545,21 @@ class Configurator
 
     # Merge plugin configuration values (like Ceedling project file)
     @configurator_plugins.config_plugins.each do |hash|
-      _config = @yaml_wrapper.load( hash[:path] )
+      _config = begin
+        @yaml_wrapper.load( hash[:path] )
+      rescue YamlLoadException => e
+        raise YamlLoadException.new(
+          reason: e.reason, source: e.source, original_error: e.original_error,
+          message: "Could not load configuration from plugin '#{hash[:plugin]}' ⏩️ #{e.message}"
+        )
+      end
 
-      msg = @reportinator.generate_progress( "Merging configuration from plugin #{hash[:plugin]}" )
-      @loginator.log( msg, Verbosity::OBNOXIOUS )
-      @loginator.log( _config.to_s, Verbosity::DEBUG )
+      @loginator.lazy( Verbosity::OBNOXIOUS ) do
+        @reportinator.generate_progress( "Merging configuration from plugin #{hash[:plugin]}" )
+      end
+      @loginator.lazy( Verbosity::DEBUG ) do 
+        _config.to_s
+      end
 
       # Special handling for plugin paths
       if (_config.include?( :paths ))
@@ -440,8 +579,9 @@ class Configurator
   def eval_environment_variables(config)
     return if config[:environment].nil?
 
-    msg = @reportinator.generate_progress( 'Processing environment variables' )
-    @loginator.log( msg, Verbosity::OBNOXIOUS )
+    @loginator.lazy( Verbosity::OBNOXIOUS ) do
+      @reportinator.generate_progress( 'Processing environment variables' )
+    end
 
     config[:environment].each do |hash|
       key   = hash.keys[0] # Get first (should be only) environment variable entry
@@ -460,8 +600,8 @@ class Configurator
       # Process value array
       items.each do |item|
         # Process each item for Ruby string replacement
-        if item.is_a? String and item =~ PATTERNS::RUBY_STRING_REPLACEMENT
-          item.replace( @system_wrapper.module_eval( item ) )
+        if item.is_a? String
+          item.replace( @ruby_expandinator.expand( item, source: ":environment ↳ #{key}" ) )
         end
       end
 
@@ -472,7 +612,9 @@ class Configurator
 
       # Set the environment variable for our session
       @system_wrapper.env_set( key.to_s.upcase, hash[key] )
-      @loginator.log( " - #{key.to_s.upcase}: \"#{hash[key]}\"", Verbosity::DEBUG )
+      @loginator.lazy( Verbosity::DEBUG ) do 
+        " - #{key.to_s.upcase}: \"#{hash[key]}\""
+      end
     end
   end
 
@@ -481,76 +623,96 @@ class Configurator
   def eval_paths(config)
     # :plugins ↳ :load_paths already handled
 
-    msg = @reportinator.generate_progress( 'Processing path entries and expanding any string replacements' )
-    @loginator.log( msg, Verbosity::OBNOXIOUS )
+    @loginator.lazy( Verbosity::OBNOXIOUS ) do
+      @reportinator.generate_progress( 'Processing path entries and expanding any string replacements' )
+    end
 
-    eval_path_entries( config[:project][:build_root] )
-    eval_path_entries( config[:release_build][:artifacts] )
+    eval_path_entries( config[:project][:build_root], source: ":project ↳ :build_root" )
+    eval_path_entries( config[:release_build][:artifacts], source: ":release_build ↳ :artifacts" )
 
     config[:paths].each_pair do |entry, paths|
       # :paths sub-entries (e.g. :test) could be a single string -> make array
       reform_path_entries_as_lists( config[:paths], entry, paths )
-      eval_path_entries( paths )
+      eval_path_entries( paths, source: ":paths ↳ #{entry}" )
     end
 
     config[:files].each_pair do |entry, files|
       # :files sub-entries (e.g. :test) could be a single string -> make array
       reform_path_entries_as_lists( config[:files], entry, files )
-      eval_path_entries( files )
+      eval_path_entries( files, source: ":files ↳ #{entry}" )
     end
 
     # All other paths at secondary hash key level processed by convention (`_path`):
     # ex. :toplevel ↳ :foo_path & :toplevel ↳ :bar_paths are evaluated
-    config.each_pair { |_, child| eval_path_entries( collect_path_list( child ) ) }
+    config.each_pair { |key, child| eval_path_entries( collect_path_list( child ), source: ":#{key} ↳ a *_path/*_paths entry" ) }
   end
 
 
   # Handle any Ruby string replacement for :flags string arrays
   def eval_flags(config)
-    msg = @reportinator.generate_progress( 'Expanding any string replacements in :flags entries' )
-    @loginator.log( msg, Verbosity::OBNOXIOUS )
+    @loginator.lazy( Verbosity::OBNOXIOUS ) do
+      @reportinator.generate_progress( 'Expanding any string replacements in :flags entries' )
+    end
 
     # Descend down to array of command line flags strings regardless of depth in config block
-    traverse_hash_eval_string_arrays( config[:flags] )
+    traverse_hash_eval_string_arrays( config[:flags], source: ":flags" )
   end
 
 
   # Handle any Ruby string replacement for :defines string arrays
   def eval_defines(config)
-    msg = @reportinator.generate_progress( 'Expanding any string replacements in :defines entries' )
-    @loginator.log( msg, Verbosity::OBNOXIOUS )
+    @loginator.lazy( Verbosity::OBNOXIOUS ) do
+      @reportinator.generate_progress( 'Expanding any string replacements in :defines entries' )
+    end
 
     # Descend down to array of #define strings regardless of depth in config block
-    traverse_hash_eval_string_arrays( config[:defines] )
+    traverse_hash_eval_string_arrays( config[:defines], source: ":defines" )
   end
 
 
   def standardize_paths(config)
-    msg = @reportinator.generate_progress( 'Standardizing all paths' )
-    @loginator.log( msg, Verbosity::OBNOXIOUS )
+    @loginator.lazy( Verbosity::OBNOXIOUS ) do
+      @reportinator.generate_progress( 'Standardizing all paths' )
+    end
 
-    # Individual paths that don't follow `_path` convention processed here
-    paths = [
-      config[:project][:build_root],
-      config[:release_build][:artifacts]
-    ]
+    # :project ↳ :build_root and :release_build ↳ :artifacts are individual paths
+    # that don't follow the _path/_paths key convention — handle them explicitly.
+    # :release_build may be absent in minimal configs; guard prevents NoMethodError.
+    paths = [config[:project][:build_root]]
+    if config[:release_build]
+      paths << config[:release_build][:artifacts]
+    else
+      @loginator.log(
+        ":release_build section absent from config ➡️ skipping :artifacts path standardization.",
+        Verbosity::COMPLAIN,
+        LogLabels::NOTICE
+      )
+    end
 
-    paths.flatten.each { |path| FilePathUtils::standardize( path ) }
+    paths.flatten.each { |path| FilePathUtils::standardize_in_place( path ) }
 
     config[:paths].each_pair do |collection, paths|
-      # Ensure that list is an array (i.e. handle case of list being a single string,
-      # or a multidimensional array)
-      config[:paths][collection] = [paths].flatten.map{|path| FilePathUtils::standardize( path )}
+      # Flatten to handle single strings or nested arrays; reject nils (non-String passthrough
+      # from standardize) and empty strings left after stripping whitespace-only entries.
+      config[:paths][collection] = [paths].flatten
+        .map    { |path| FilePathUtils::standardize_in_place( path ) }
+        .reject { |path| path.nil? || (path.is_a?( String ) && path.empty?) }
     end
 
-    config[:files].each_pair { |_, files| files.each{ |path| FilePathUtils::standardize( path ) } }
+    config[:files].each_pair do |collection, files|
+      # Same sanitization as :paths — replace array to remove any nil or empty entries
+      # produced by standardize on non-String or whitespace-only values.
+      config[:files][collection] = [files].flatten
+        .map    { |path| FilePathUtils::standardize_in_place( path ) }
+        .reject { |path| path.nil? || (path.is_a?( String ) && path.empty?) }
+    end
 
-    config[:tools].each_pair { |_, config| FilePathUtils::standardize( config[:executable] ) if (config.include? :executable) }
+    config[:tools].each_pair { |_, config| FilePathUtils::standardize_in_place( config[:executable] ) if (config.include? :executable) }
 
     # All other paths at secondary hash key level processed by convention (`_path`):
     # ex. :toplevel ↳ :foo_path & :toplevel ↳ :bar_paths are standardized
     config.each_pair do |_, child|
-      collect_path_list( child ).each { |path| FilePathUtils::standardize( path ) }
+      collect_path_list( child ).each { |path| FilePathUtils::standardize_in_place( path ) }
     end
   end
 
@@ -585,7 +747,6 @@ class Configurator
     blotter &= @configurator_setup.validate_defines( config )
     blotter &= @configurator_setup.validate_flags( config )
     blotter &= @configurator_setup.validate_test_preprocessor( config )
-    blotter &= @configurator_setup.validate_deep_preprocessor( config )
     blotter &= @configurator_setup.validate_backtrace( config )
     blotter &= @configurator_setup.validate_threads( config )
     blotter &= @configurator_setup.validate_plugins( config )
@@ -630,7 +791,7 @@ class Configurator
 
     # Ensure element already exists
     if not @project_config_hash.include?(elem)
-      error = "Could not rederine #{elem} in configurator--element does not exist"
+      error = "Could not redefine #{elem} in configurator ⏩️ Element does not exist"
       raise CeedlingException.new(error)
     end
 
@@ -666,8 +827,9 @@ class Configurator
 
   def insert_rake_plugins(plugins)
     plugins.each do |hash|
-      msg = @reportinator.generate_progress( "Adding plugin #{hash[:plugin]} to Rake load list" )
-      @loginator.log( msg, Verbosity::OBNOXIOUS )
+      @loginator.lazy( Verbosity::OBNOXIOUS ) do
+        @reportinator.generate_progress( "Adding plugin #{hash[:plugin]} to Rake load list" )
+      end
 
       @project_config_hash[:project_rakefile_component_files] << hash[:path]
     end
@@ -695,7 +857,7 @@ class Configurator
   end
 
 
-  def eval_path_entries( container )
+  def eval_path_entries( container, source: )
     paths = []
 
     case(container)
@@ -706,14 +868,14 @@ class Configurator
     end
 
     paths.each do |path|
-      path.replace( @system_wrapper.module_eval( path ) ) if (path =~ PATTERNS::RUBY_STRING_REPLACEMENT)
+      path.replace( @ruby_expandinator.expand( path, source: source ) )
     end
   end
 
 
   # Traverse configuration tree recursively to find terminal leaf nodes that are a list of strings;
   # expand in place any string with the Ruby string replacement pattern.
-  def traverse_hash_eval_string_arrays(config)
+  def traverse_hash_eval_string_arrays(config, source:)
     case config
 
     when Array
@@ -721,13 +883,13 @@ class Configurator
       if config.all? { |item| item.is_a?( String ) }
         # Expand in place each string item in the array
         config.each do |item|
-          item.replace( @system_wrapper.module_eval( item ) ) if (item =~ PATTERNS::RUBY_STRING_REPLACEMENT)
+          item.replace( @ruby_expandinator.expand( item, source: source ) )
         end
       end
 
     when Hash
       # Recurse
-      config.each_value { |value| traverse_hash_eval_string_arrays( value ) }
+      config.each_value { |value| traverse_hash_eval_string_arrays( value, source: source ) }
     end
   end