ceedling 1.1.10 → 1.2.1

data/lib/ceedling/preprocess/preprocessinator.rb

@@ -16,8 +16,8 @@ class Preprocessinator
     :preprocessinator_file_assembler,
     :preprocessinator_reconstructor,
     :file_path_utils,
-    :tool_executor,
     :file_wrapper,
+    :tool_executor,
     :plugin_manager,
     :configurator,
     :loginator,
@@ -37,8 +37,8 @@ class Preprocessinator
     @file_locks_mutex = Mutex.new
   end
 
-  # Extract bare includes (does not differentiate user/system) from a file.
-  # Called externally.
+  # Extract bare includes (does not differentiate user/system) from a file, or nil when
+  # the preprocessor failed. Called externally.
   def preprocess_bare_includes(filepath:, test:, search_paths:, flags:, defines:)
     # Pass-through
     return @includes_handler.extract_bare_includes(
@@ -50,154 +50,97 @@ class Preprocessinator
       )
   end
 
-  def generate_directives_only_output(filepath:, test:, flags:, include_paths:, vendor_paths:, defines:)
-    raw_preprocessed_filepath = 
-      @file_path_utils.form_preprocessed_file_raw_directives_only_filepath( filepath, test )
-
-    compacted_preprocessed_fileapth =
-      @file_path_utils.form_preprocessed_file_compacted_directives_only_filepath( filepath, test )
-
-    # Run GCC with directives-only preprocessor expansion
-    command = @tool_executor.build_command_line(
-      @configurator.tools_test_file_directives_only_preprocessor,
-      # Additional arguments
-      flags,
-      # Argument replacement
-      filepath,
-      raw_preprocessed_filepath,
-      defines,
-      (include_paths + vendor_paths)
-    )
-    command[:options][:boom] = false
-    results = @tool_executor.exec( command )
+  # A file run with -fdirectives-only, which evaluates #if and follows #includes while
+  # keeping macros and line markers. Gives the raw output's path, or nil when the
+  # preprocessor fails so the caller falls back for this file alone. `tool_args` are the
+  # run's flags:, include_paths:, vendor_paths:, and defines:.
+  def generate_directives_only_output(filepath:, test:, **tool_args)
+    raw    = ensure_output_dir( @file_path_utils.form_preprocessed_file_raw_directives_only_filepath( filepath, test ) )
+    result = run_preprocessor( @configurator.tools_test_file_directives_only_preprocessor, filepath, raw, **tool_args )
 
-    # Preprocessor did not succeed
-    if results[:exit_code] != 0
-      msg = "Failed to generate directive-only preprocessor output (fallback methods will be used) for #{filepath}"
-      @loginator.log( msg, Verbosity::OBNOXIOUS, LogLabels::ERROR )
-      return nil
+    if @tool_executor.failed?( result )
+      return log_failure( "Failed to generate directive-only preprocessor output (fallback methods will be used) for #{filepath}", Verbosity::OBNOXIOUS, LogLabels::ERROR )
     end
 
-    # Remove comments from directives-only file in filesystem.
-    # Directives-only output keeps our most essential details (include directives & macros) and handles #ifdefs, etc.
-    # However, it does not strip out comments.
-    @comment_stripper.strip_file( raw_preprocessed_filepath )
-
-    # Collect all code from between line markers into a clean file
-    @reconstructor.compact_file_from_expansion(
-      input_filepath: raw_preprocessed_filepath,
-      source_filepath: filepath,
-      output_filepath: compacted_preprocessed_fileapth
-    )
-
-    return raw_preprocessed_filepath
+    strip_and_compact( filepath, test, raw )
+    return raw
   end
 
-  # Extract user includes from a file using directives-only output (or text-only fallback).
-  # Called externally and internally by `preprocess_common`.
-  def preprocess_user_includes(name:, filepath:, directives_only_filepath:, fallback: false, defines: [])
-    includes = []
+  # Fallback's best-effort stand-in for directives-only output, from a preprocessor without
+  # -fdirectives-only: a plain expansion whose line markers still name every file it
+  # entered. Only those markers are read, so the expansion is neither stripped nor
+  # compacted. Gives its path, or nil when the preprocessor fails.
+  def generate_fallback_expansion_output(filepath:, test:, **tool_args)
+    output = ensure_output_dir( @file_path_utils.form_preprocessed_file_fallback_expansion_filepath( filepath, test ) )
+    result = run_preprocessor( @configurator.tools_test_file_full_preprocessor, filepath, output, **tool_args )
 
-    if !fallback
-      includes = @includes_handler.extract_user_includes_preprocess(
-        name:                   name,
-        filepath:               filepath,
-        preprocessed_filepath:  directives_only_filepath
-      )
-    else
-      includes = @includes_handler.extract_user_includes_from_text(
-        name:     name,
-        filepath: filepath,
-        defines:  defines
-      )
+    if @tool_executor.failed?( result )
+      return log_failure( "Failed to generate fallback preprocessor expansion (text-scan #includes will be used) for #{filepath}", Verbosity::OBNOXIOUS, LogLabels::ERROR )
     end
 
-    header = "Extracted user #includes from #{filepath}:"
-    @loginator.log_list( includes, header, Verbosity::DEBUG )
+    return output
+  end
 
-    return includes
+  # Extract user includes from a file using directives-only output (or text-only fallback).
+  # Called externally and internally by `preprocess_file_includes_common`.
+  def preprocess_user_includes(name:, filepath:, directives_only_filepath:, fallback: false, defines: [])
+    _preprocess_includes( :user, name: name, filepath: filepath,
+                          directives_only_filepath: directives_only_filepath,
+                          fallback: fallback, defines: defines )
   end
 
   # Extract system includes from a file using directives-only output (or text-only fallback).
-  # Called externally and internally by `preprocess_common`.
+  # Called externally and internally by `preprocess_file_includes_common`.
   def preprocess_system_includes(name:, filepath:, directives_only_filepath:, fallback: false, defines: [])
-    includes = []
-
-    if !fallback
-      includes = @includes_handler.extract_system_includes_preprocess(
-        name:                   name,
-        filepath:               filepath,
-        preprocessed_filepath:  directives_only_filepath
-      )
-    else
-      includes = @includes_handler.extract_system_includes_from_text(
-        name:     name,
-        filepath: filepath,
-        defines:  defines
-      )
-    end
-
-    header = "Extracted system #includes from #{filepath}:"
-    @loginator.log_list( includes, header, Verbosity::DEBUG )
-
-    return includes
+    _preprocess_includes( :system, name: name, filepath: filepath,
+                          directives_only_filepath: directives_only_filepath,
+                          fallback: fallback, defines: defines )
   end
 
+  # Persists `includes` under a cache file keyed by `test`/`filepath` so
+  # `load_includes_list` can recall it later. Independent callers share this
+  # pair of methods against different `filepath`s, each already knowing its
+  # target is stale before writing here:
+  #  - Stage 4's first pass (TestBareIncludesExtractinator), for a test file's own
+  #    bare-includes list.
+  #  - `preprocess_file_includes_common` below, for a mocked header's or a
+  #    Partial header/source file's includes -- called from stage 9 and
+  #    stages 6/7 (test_build_executor.rb) respectively, both of which
+  #    register their own DependencyTracker target and only call in once
+  #    they've determined it stale.
+  # This method itself performs no freshness check of its own.
   def store_includes_list(test:, filepath:, includes:)
-    _filepath = @file_path_utils.form_preprocessed_includes_list_filepath( filepath, test )
-
-    # Get or create a mutex for this specific cache file
-    file_lock = @file_locks_mutex.synchronize do
-      @file_locks[_filepath] ||= Mutex.new
-    end
+    _filepath = ensure_output_dir(
+      @file_path_utils.form_preprocessed_includes_list_filepath( filepath, test )
+    )
 
-    file_lock.synchronize do
+    cache_file_lock( _filepath ).synchronize do
       @includes_handler.write_includes_list( _filepath, includes )
     end
   end
 
-  def cached_includes_list?(test:, filepath:)
+  # Recalls an includes list previously written by `store_includes_list`.
+  # Caller-gated the same way (see `store_includes_list` above): meaningful
+  # only once the caller has already established the target is not stale,
+  # since no freshness check is performed here.
+  def load_includes_list(test:, filepath:)
     _filepath = @file_path_utils.form_preprocessed_includes_list_filepath( filepath, test )
 
-    # Get or create a mutex for this specific cache file
-    file_lock = @file_locks_mutex.synchronize do
-      @file_locks[_filepath] ||= Mutex.new
-    end
-
-    file_lock.synchronize do
-      # If existing YAML file of includes is newer than the file we're processing, skip preprocessing
-      return @file_wrapper.newer?( _filepath, filepath )
-    end
-  end
-
-  def load_includes_list(test:, filepath:)
-    includes = []
+    cache_file_lock( _filepath ).synchronize do
+      msg = @reportinator.generate_module_progress(
+        operation: "Loading #include statement listing file for",
+        module_name: test,
+        filename: File.basename(filepath)
+        )
+      @loginator.log( msg, Verbosity::OBNOXIOUS )
 
-    _filepath = @file_path_utils.form_preprocessed_includes_list_filepath( filepath, test )
+      includes = @includes_handler.load_includes_list( _filepath )
 
-    # Get or create a mutex for this specific cache file
-    file_lock = @file_locks_mutex.synchronize do
-      @file_locks[_filepath] ||= Mutex.new
-    end
+      header = "Loaded existing #include list from #{_filepath}:"
+      @loginator.log_list( includes, header, Verbosity::DEBUG )
 
-    file_lock.synchronize do
-      # If existing YAML file of includes is newer than the file we're processing, skip preprocessing
-      if @file_wrapper.newer?( _filepath, filepath )
-        msg = @reportinator.generate_module_progress(
-          operation: "Loading #include statement listing file for",
-          module_name: test,
-          filename: File.basename(filepath)
-          )
-        @loginator.log( msg, Verbosity::OBNOXIOUS )
-      
-        includes = @includes_handler.load_includes_list( _filepath )
-
-        header = "Loaded existing #include list from #{_filepath}:"
-        @loginator.log_list( includes, header, Verbosity::DEBUG )
-      end
+      includes
     end
-
-    return !includes.empty?, includes
   end
 
   def preprocess_mockable_header_file(
@@ -243,7 +186,11 @@ class Preprocessinator
       defines:                   defines
     }
 
-    # Extract includes & log progress and details   
+    # Extract includes & log progress and details. stage_preprocess_mocks
+    # (test_build_executor.rb) only ever calls this method once it has
+    # already determined, via its own DependencyTracker target (antecedent +
+    # flags/defines/search_paths/extras meta), that this header's
+    # preprocessing is stale, so the extraction below always runs for real.
     includes = preprocess_file_includes_common( **arg_hash )
 
     header = "Discovered #includes for mockable header from #{filepath}:"
@@ -267,7 +214,7 @@ class Preprocessinator
     contents, extras, include_guard = @file_assembler.collect_mockable_header_file_contents( **arg_hash )
 
     arg_hash = {
-      filename:              File.basename( filepath ),
+      filepath:              @file_path_utils.preprocessed_file_subpath( filepath ),
       preprocessed_filepath: preprocessed_filepath,
       contents:              contents,
       extras:                extras,
@@ -332,7 +279,7 @@ class Preprocessinator
     extras = fallback ? @file_assembler.collect_macros_and_pragmas_fallback( source_filepath: filepath, defines: defines ) : []
 
     arg_hash = {
-      filename:              File.basename( filepath ),
+      filepath:              @file_path_utils.preprocessed_file_subpath( filepath ),
       preprocessed_filepath: preprocessed_filepath,
       contents:              contents,
       extras:                extras,
@@ -496,45 +443,98 @@ class Preprocessinator
   ### Private ###
   private
 
-  def _preprocess_partial_expand_macros(filepath:, test:, flags:, include_paths:, vendor_paths:, defines:)
-    msg = @reportinator.generate_module_progress(
-      operation: 'Full-preprocessing for expanded Partial signature extraction',
-      module_name: test,
-      filename: File.basename( filepath )
-    )
-    @loginator.log( msg )
+  # Runs a preprocessor `tool` over `filepath` into `output`. A file's own search paths
+  # come ahead of vendor paths, so a project header wins a name clash. `boom: false` keeps
+  # a failing run from raising: ToolExecutor#exec would otherwise stop the build before the
+  # caller could fall back in its own way.
+  def run_preprocessor(tool, filepath, output, flags:, include_paths:, vendor_paths:, defines:)
+    command = @tool_executor.build_command_line( tool, flags, filepath, output, defines, (include_paths + vendor_paths) )
+    command[:options][:boom] = false
+
+    return @tool_executor.exec( command )
+  end
 
-    full_expansion_filepath = @file_path_utils.form_preprocessed_file_full_expansion_filepath( filepath, test )
+  # Logs why a preprocessor run failed and gives the nil its caller returns
+  def log_failure(msg, *log_args)
+    @loginator.log( msg, *log_args )
+    return nil
+  end
 
-    command = @tool_executor.build_command_line(
-      @configurator.tools_test_file_full_preprocessor,
-      flags,
-      filepath,
-      full_expansion_filepath,
-      defines,
-      (include_paths + vendor_paths)
-    )
-    result = @tool_executor.exec( command )
+  # Directives-only output keeps comments, so they are stripped before the code between
+  # line markers is collected into a compacted file
+  def strip_and_compact(filepath, test, raw)
+    compacted = ensure_output_dir( @file_path_utils.form_preprocessed_file_compacted_directives_only_filepath( filepath, test ) )
 
-    if result[:exit_code] != 0
-      msg = "Failed to generate full expansion for Partial signature extraction (directives-only signatures will be used) for #{filepath}"
-      @loginator.log( msg, Verbosity::COMPLAIN )
-      return nil
+    @comment_stripper.strip_file( raw )
+    @reconstructor.compact_file_from_expansion( input_filepath: raw, source_filepath: filepath, output_filepath: compacted )
+  end
+
+  # Creates a preprocessed artifact's own directory and hands the path back, so a caller
+  # wraps it around the path it is already assigning. The directory may not exist yet: an
+  # artifact mirrors its source's own namespace, while a test's flat preprocess
+  # directories are created with the rest of its build paths, before any source is known.
+  # The preprocessor tools write their output directly and would otherwise fail.
+  def ensure_output_dir(filepath)
+    @file_wrapper.mkdir( File.dirname( filepath ) )
+    return filepath
+  end
+
+  # One Mutex per includes-cache file, so concurrent testables serialize on the exact
+  # file they touch and nothing more. The map itself is guarded by @file_locks_mutex.
+  def cache_file_lock(cache_filepath)
+    @file_locks_mutex.synchronize { @file_locks[cache_filepath] ||= Mutex.new }
+  end
+
+  # User and system include extraction differ only in which handler pair they call and
+  # one word in the debug log. `kind` is :user or :system; the accurate line-marker
+  # extraction runs unless `fallback`, in which case the original file's text is scanned.
+  def _preprocess_includes(kind, name:, filepath:, directives_only_filepath:, fallback:, defines:)
+    includes =
+      if fallback
+        @includes_handler.public_send(
+          "extract_#{kind}_includes_from_text",
+          name: name, filepath: filepath, defines: defines
+        )
+      else
+        @includes_handler.public_send(
+          "extract_#{kind}_includes_preprocess",
+          name: name, filepath: filepath, preprocessed_filepath: directives_only_filepath
+        )
+      end
+
+    @loginator.log_list( includes, "Extracted #{kind} #includes from #{filepath}:", Verbosity::DEBUG )
+    includes
+  end
+
+  # A Partial's file in full expansion, reassembled in place as plain code. Nil when the
+  # preprocessor fails, so its caller uses directives-only signatures instead.
+  def _preprocess_partial_expand_macros(filepath:, test:, **tool_args)
+    progress = { operation: 'Full-preprocessing for expanded Partial signature extraction', module_name: test, filename: File.basename( filepath ) }
+    @loginator.log( @reportinator.generate_module_progress( **progress ) )
+
+    output = ensure_output_dir( @file_path_utils.form_preprocessed_file_full_expansion_filepath( filepath, test ) )
+    result = run_preprocessor( @configurator.tools_test_file_full_preprocessor, filepath, output, **tool_args )
+
+    if @tool_executor.failed?( result )
+      return log_failure( "Failed to generate full expansion for Partial signature extraction (directives-only signatures will be used) for #{filepath}", Verbosity::COMPLAIN )
     end
 
-    contents = @file_assembler.collect_file_contents_from_full_expansion( source_filepath: filepath, test: test )
+    assemble_full_expansion( filepath, test, output )
+    return output
+  end
 
+  def assemble_full_expansion(filepath, test, output)
+    contents = @file_assembler.collect_file_contents_from_full_expansion( source_filepath: filepath, test: test )
     @file_assembler.assemble_preprocessed_code_file(
-      filename:              File.basename( filepath ),
-      preprocessed_filepath: full_expansion_filepath,
-      contents:              contents,
-      extras:                [],
-      includes:              []
+      filename: File.basename( filepath ), preprocessed_filepath: output, contents: contents, extras: [], includes: []
     )
-
-    return full_expansion_filepath
   end
 
+  # Extracts, reconciles, and persists a header or source file's user/system
+  # includes. Called only once a caller has already determined, via its own
+  # DependencyTracker target, that this exact file/test pair is stale --
+  # see `preprocess_mockable_header_file` above and stages 6/7 in
+  # test_build_executor.rb -- so the extraction below always runs for real.
   def preprocess_file_includes_common(
       test:,
       filepath:,
@@ -552,77 +552,113 @@ class Preprocessinator
     )
     @loginator.log( msg, Verbosity::OBNOXIOUS )
 
-    includes = []
-    success, includes = load_includes_list( test: test, filepath: filepath )
-
-    if !success
-      # Full preprocessing-based #include extraction with saving to YAML file
+    # Extract bare includes. The text scan below stands in for a failed run.
+    bare_includes = @includes_handler.extract_bare_includes(
+      filepath:      filepath,
+      test:          test,
+      flags:         flags,
+      search_paths:  vendor_paths,
+      defines:       defines
+    ) || []
 
-      # Extract bare includes
-      bare_includes = @includes_handler.extract_bare_includes(
-        filepath:      filepath,
-        test:          test,
-        flags:         flags,
-        search_paths:  vendor_paths,
-        defines:       defines
+    # Fallback has no directives-only output to resolve computed #includes from
+    bare_includes = supplement_with_text_includes( filepath: filepath, bare: bare_includes )
+    unless fallback
+      bare_includes = supplement_with_computed_includes(
+        filepath: filepath, bare: bare_includes, directives_only_filepath: directives_only_filepath
       )
+    end
 
-      # Supplement with a literal text scan of the original file's own #include
-      # lines -- the gcc-based bare pass above runs against an isolated copy that
-      # can never open another header, so a conditional #include whose guard
-      # depends on a macro defined by an *earlier #include in this same file*
-      # evaluates false there and silently drops out. Unioning in this text-based
-      # pass's result only ever adds candidates for Includes.reconcile below to
-      # match against the accurate directives-only pass -- it can't introduce a
-      # spurious entry on its own, since reconcile still requires the accurate
-      # pass to also report it.
-      #
-      # This supplements the gcc-based pass rather than replacing it: gcc can
-      # resolve an #include whose target is itself a macro (e.g. the
-      # MOCK_PARTIAL_ALL_MODULE()-style directives this project's own generated
-      # test files use), since a command-line -D define is visible even to the
-      # isolated copy -- a literal text scan has no filename there to find at
-      # all, since none exists until a real preprocessor expands the macro. The
-      # two passes catch different, non-overlapping failure modes; keeping both
-      # covers both.
-      bare_includes = (
-        bare_includes + @includes_handler.extract_bare_includes_from_text( filepath: filepath )
-      ).uniq( &:filename )
-
-      # Extract user includes
-      user_includes = preprocess_user_includes(
-        name:                     test,
-        filepath:                 filepath,
-        directives_only_filepath: directives_only_filepath,
-        fallback:                 fallback,
-        defines:                  defines
-      )
+    # Extract user includes
+    user_includes = preprocess_user_includes(
+      name:                     test,
+      filepath:                 filepath,
+      directives_only_filepath: directives_only_filepath,
+      fallback:                 fallback,
+      defines:                  defines
+    )
 
-      # Extract system includes
-      system_includes = preprocess_system_includes(
-        name:                     test,
-        filepath:                 filepath,
-        directives_only_filepath: directives_only_filepath,
-        fallback:                 fallback,
-        defines:                  defines
-      )
+    # Extract system includes
+    system_includes = preprocess_system_includes(
+      name:                     test,
+      filepath:                 filepath,
+      directives_only_filepath: directives_only_filepath,
+      fallback:                 fallback,
+      defines:                  defines
+    )
 
-      # Reconcile includes with overlapping information
-      includes = Includes.reconcile(
-        bare: bare_includes,
-        user: user_includes,
-        system: system_includes
-      )
+    includes = reconcile_includes(
+      bare: bare_includes, user: user_includes, system: system_includes, test_filepath: filepath
+    )
+
+    store_includes_list( filepath: filepath, test: test, includes: includes )
+
+    return includes
+  end
 
-      # Sanitize the final list and remove any includes that have been mocked
-      Includes.sanitize!(includes) do |include, all|
+  # A bare list with the file's own literal #include lines added. The gcc bare pass runs
+  # on an isolated copy that can never open another header, so an #include guarded by a
+  # macro another header defines evaluates false there and drops out. The text scan
+  # evaluates nothing and still lists it. Each added entry is only a candidate:
+  # reconciliation keeps it only if the accurate directives-only pass also reports it.
+  #
+  # A supplement, not a replacement: gcc resolves an #include whose target is a macro
+  # given on the command line, where a text scan finds no filename at all.
+  def supplement_with_text_includes(filepath:, bare:)
+    return union_includes( bare, @includes_handler.extract_bare_includes_from_text( filepath: filepath ) )
+  end
+
+  # A bare list with the #includes a macro names, as the preprocessor's line-marker output
+  # resolved them. Neither bare pass sees one whose macro comes from another header: the
+  # gcc pass can't open that header, and the text scan has no filename to find. The same
+  # reconciliation safety applies. Without line-marker output there is nothing to add.
+  def supplement_with_computed_includes(filepath:, bare:, directives_only_filepath:)
+    computed = @includes_handler.extract_computed_includes( filepath: filepath, directives_only_filepath: directives_only_filepath )
+    return union_includes( bare, computed )
+  end
+
+  # The user files a preprocessor's output entered, which that output depends on
+  def preprocessed_dependencies(preprocessed_filepath:)
+    return @includes_handler.extract_preprocessed_dependencies( preprocessed_filepath: preprocessed_filepath )
+  end
+
+  # The merge step every includes-reconciliation site shares: intersect a bare list
+  # against the accurate user/system lists, log a NOTICE on any genuinely ambiguous
+  # `#include` (more than one file on the search path satisfies it), and -- for the
+  # mockable-header/Partial path -- drop a header whose mock is also present.
+  # `preprocess_file_includes_common` above and stage 4's third pass
+  # (TestIncludesReconcilinator) build their own three lists and own their own caching;
+  # only this middle is common.
+  def reconcile_includes(bare:, user:, system:, test_filepath:, drop_mocked: true)
+    includes = Includes.reconcile(
+      bare: bare, user: user, system: system, test_filepath: test_filepath
+    ) do |bare_filepath, chosen, passed_over|
+      msg = "Multiple files satisfy #include '#{bare_filepath}' within #{test_filepath}; chose '#{chosen}' " \
+            "by search-path priority. Other candidates passed over: #{passed_over.join(', ')}. If this " \
+            "choice is wrong, add more path to that #include statement to select a different file -- or " \
+            "watch for a compilation error naming the real mismatch."
+      @loginator.log( msg, Verbosity::COMPLAIN, LogLabels::NOTICE )
+    end
+
+    if drop_mocked
+      Includes.sanitize!( includes ) do |include, all|
         all.include?( "#{@configurator.cmock_mock_prefix}#{include.filename}" )
       end
-    
-      store_includes_list( filepath: filepath, test: test, includes: includes )
     end
 
-    return includes
+    includes
   end
 
+  # Deduplicated by filepath, not filename: two entries sharing only a basename, such as
+  # "hw/config.h" and "app/config.h", are different files, and reconciliation tells them
+  # apart by their resolved paths (Includes.reconcile)
+  def union_includes(bare, more)
+    return (bare + more).uniq( &:filepath )
+  end
+
+  # These sit beside the orchestration that first used them, but each is self-contained.
+  # Stage 4's passes call the supplements, reconciliation, and dependency extraction, and
+  # the integration tier drives `preprocess_file_includes_common` against real GCC output.
+  public :preprocess_file_includes_common, :reconcile_includes, :supplement_with_text_includes, :supplement_with_computed_includes, :preprocessed_dependencies
+
 end

data/lib/ceedling/preprocess/preprocessinator_bare_includes_extractor.rb

@@ -50,20 +50,17 @@ require 'ceedling/includes/includes'
 class PreprocessinatorBareIncludesExtractor
 
     # Matcher for the first line of the make rule output
-    MAKE_RULE_MATCHER = /^\S+\.o:\s+.+$/  # <characters>.o: <characters>
-    
+    MAKE_RULE_MATCHER = /^\S+\.o:\s+.+$/ unless const_defined?(:MAKE_RULE_MATCHER, false)  # <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>:
+    INCLUDE_MATCHER = /^(\S+\.\S+):\s*$/ unless const_defined?(:INCLUDE_MATCHER, false) # <characters>.<extension>:
 
   def self.extract_includes(make_rules)
-    # 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
-    includes.uniq!
-
-    # Convert list of fileapth strings to list of bare Include objects
-    return includes.map { |_include| Include.new(_include) }
+    # One phony `<header>:` rule per #include dependency (.h, .c, ...). `scan` returns
+    # each single capture wrapped in its own array, hence the flatten; a header reached
+    # more than once (an include guard, say) is listed once.
+    make_rules.scan( INCLUDE_MATCHER ).flatten.uniq.map { |filepath| Include.new( filepath ) }
   end
 end
 

data/lib/ceedling/preprocess/preprocessinator_code_finder.rb

@@ -9,6 +9,8 @@ require 'stringio'
 
 class PreprocessinatorCodeFinder
 
+  constructor :file_wrapper
+
   LINE_MARKER_REGEX = /^#\s+(\d+)\s+"[^"]+"[^\n]*\n/ unless const_defined?(:LINE_MARKER_REGEX)
 
   # Regex-special-character-immune string
@@ -17,8 +19,10 @@ class PreprocessinatorCodeFinder
   # Open a GCC preprocessor output file and search it for code.
   # Returns the 1-indexed source line number of the match, or nil if not found.
   # Intended for production use where preprocessor output resides on disk.
-  def find_in_preprpocessed_file(filepath, code)
-    File.open( filepath, 'r' ) do |file|
+  def find_in_preprocessed_file(filepath, code)
+    # `filepath` is this same build's own gcc preprocessor output -- open_with_retry
+    # rides out the file briefly not yet being visible right after the shell-out exits.
+    @file_wrapper.open_with_retry( filepath, 'r' ) do |file|
       return find_in_preprocessed_content( io: file, search: code )
     end
   end
@@ -27,7 +31,7 @@ class PreprocessinatorCodeFinder
   # Wrap a GCC preprocessor output string in a StringIO and search it for code.
   # Returns the 1-indexed source line number of the match, or nil if not found.
   # Intended for test use so that specs require no temporary files.
-  def find_in_preprpocessed_string(content, code)
+  def find_in_preprocessed_string(content, code)
     buffer = StringIO.new( content )
     return find_in_preprocessed_content( io: buffer, search: code )
   end
@@ -36,7 +40,7 @@ class PreprocessinatorCodeFinder
   # Returns the 1-indexed source line number of the match, or nil if not found.
   # Intended for production use where C file resides on disk.
   def find_in_c_file(filepath, code)
-    File.open( filepath, 'r' ) do |file|
+    @file_wrapper.open( filepath, 'r' ) do |file|
       return find_in_c_code( io: file, search: code )
     end
   end
@@ -120,8 +124,6 @@ class PreprocessinatorCodeFinder
     return (content[0, match_pos].count("\n")) + 1
   end
 
-  private
-
   def whitespace_insensitive_search(content, code)
     # Collapse whitespace to a unique token
     _code = code.gsub(/\s+/, WHITESPACE_MARKER)