ceedling 1.2.0 → 1.2.2

data/lib/ceedling/filesystem/project_paths.rb

@@ -0,0 +1,184 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+require 'pathname'
+require 'rbconfig'
+require 'ceedling/filesystem/working_dir'
+
+# One spelling for every path a project names.
+#
+# A place can be written many ways: relative or absolute, with `./`, `..`, `~`, backslashes,
+# or through a symlink. Intake spells each path once, relative to the working directory
+# (`canonical`). Comparisons then use whole directories, never text prefixes (`contains?`).
+# BuildSubpath places build files from these spellings.
+#
+# Pure functions over strings, except where a function says it reads the disk, and no
+# dependency on DIY, so the launcher in bin/ shares it.
+module ProjectPaths
+
+  DECORATOR = /\A[+-]:/
+  WINDOWS   = (RbConfig::CONFIG['host_os'] =~ /mswin|mingw|msys|ucrt/i) ? true : false
+
+  # What `absolute` makes of a path, which `clean_absolute?` finds already so: rooted, `C:/`
+  # on Windows, and free of `.`/`..` segments, doubled `/`, and backslashes. Windows'
+  # File.expand_path also lengthens a short `~` name and drops a trailing dot or space.
+  ROOTED      = WINDOWS ? %r{\A[A-Z]:/} : %r{\A/}
+  ROOT_LENGTH = WINDOWS ? 3 : 1
+  UNCLEAN     = WINDOWS ? %r{//|/\.\.?(?:/|\z)|\\|~|[. ](?:/|\z)} : %r{//|/\.\.?(?:/|\z)|\\}
+
+  @lock      = Mutex.new
+  @absolutes = {}
+
+  # The working directory with every symlink resolved, read once (see WorkingDir)
+  def self.working_dir
+    return WorkingDir.path
+  end
+
+  # A path written as a project file writes it, in Ceedling's form: trimmed, `/`-separated,
+  # with no trailing separator, and `~` read as the home directory. A `+:`/`-:` decorator is
+  # kept. `~user` is left as written.
+  def self.standardize(path)
+    path = path.to_s.strip.tr( '\\', '/' )
+    decorator = path[DECORATOR] || ''
+    path = expand_home( path.delete_prefix( decorator ).strip )
+    path = path.sub( %r{/+\z}, '' ) unless path.match?( %r{\A(?:[A-Za-z]:)?/+\z} )
+    return decorator + path
+  end
+
+  # `path` as an absolute path, its `..` and `.` resolved against the working directory
+  # without reading the disk. A drive letter is upper case. Remembered for each working
+  # directory and home directory, since a build compares the same few roots many times.
+  def self.absolute(path)
+    return path if clean_absolute?( path )
+
+    key    = [working_dir, Dir.home, path.to_s]
+    cached = @lock.synchronize { @absolutes[key] }
+    return cached unless cached.nil?
+
+    absolute = absolute_of( path ).freeze
+    return @lock.synchronize { @absolutes[key] = absolute }
+  end
+
+  # The one spelling intake records for `path`: relative to the working directory, with the
+  # symlinks along its existing part resolved. A path with no relative form (another drive,
+  # a UNC share) stays absolute. Reads the disk.
+  def self.canonical(path)
+    return relative( real_absolute( path ) )
+  end
+
+  # `absolute` with the symlinks along its existing part resolved. Reads the disk.
+  def self.real_absolute(path)
+    return real( absolute( path ) )
+  end
+
+  # `absolute` relative to the working directory, or absolute when it has no relative form.
+  # The working directory itself is `.`.
+  def self.relative(absolute)
+    return absolute if unc?( absolute )
+
+    # Most paths lie below the working directory, which needs no Pathname walk
+    return '.' if same?( absolute, working_dir )
+    return absolute[(working_dir.length + 1)..] if clean_absolute?( absolute ) and starts_with?( absolute, "#{working_dir}/" )
+
+    return Pathname.new( absolute ).relative_path_from( Pathname.new( working_dir ) ).to_s
+  rescue ::ArgumentError
+    return absolute
+  end
+
+  # Whether `path` is `root` or lies below it, compared as whole directories. Windows folds case.
+  def self.contains?(root, path)
+    return !subdir_below( root, path ).nil?
+  end
+
+  # The directories from `root` down to `path`: '' for `root` itself, or nil when `path`
+  # doesn't lie below `root`. Never holds `..`, and is never absolute.
+  def self.subdir_below(root, path)
+    base = absolute( root )
+    full = absolute( path )
+    return '' if same?( base, full )
+
+    prefix = base.end_with?( '/' ) ? base : "#{base}/"
+    return nil unless starts_with?( full, prefix )
+
+    return full[prefix.length..]
+  end
+
+  # A path's segments, `.` and empty segments dropped
+  def self.segments(path)
+    return path.to_s.split( %r{[\\/]} ).reject { |segment| segment.empty? || segment == '.' }
+  end
+
+  def self.absolute?(path)
+    return path.start_with?( '/' ) || path.match?( %r{\A[A-Za-z]:/} )
+  end
+
+  # A Windows share. Elsewhere a doubled leading separator is the filesystem root.
+  def self.unc?(path)
+    return WINDOWS && path.start_with?( '//' )
+  end
+
+  # Whether two spellings are the same text, folding case on Windows
+  def self.same?(a, b)
+    return WINDOWS ? a.casecmp?( b ) : a == b
+  end
+
+  def self.starts_with?(path, prefix)
+    return WINDOWS ? path.downcase.start_with?( prefix.downcase ) : path.start_with?( prefix )
+  end
+
+  # Already absolute as `absolute` would spell it: rooted (with an upper case drive on
+  # Windows), with no `.` or `..` segment, doubled or trailing `/`, backslash, or surrounding
+  # space. On Windows, File.expand_path also lengthens a short `~` name and drops a trailing
+  # dot or space, so a segment with any of those is never clean.
+  def self.clean_absolute?(path)
+    return false unless path.is_a?( String ) and path.match?( ROOTED )
+    return false if path.match?( UNCLEAN ) or path != path.strip
+
+    return path.length == ROOT_LENGTH || !path.end_with?( '/' )
+  end
+
+  # A `~user` path names a directory of that name, which File.expand_path would read as the
+  # user's home (or raise for no such user). A share's `..` never leaves the share.
+  def self.absolute_of(path)
+    path = standardize( path )
+    return unc_absolute( path ) if unc?( path )
+
+    path = "./#{path}" if path.start_with?( '~' )
+    return File.expand_path( path, working_dir ).squeeze( '/' ).sub( /\A[a-z](?=:)/ ) { |drive| drive.upcase }
+  end
+
+  def self.unc_absolute(path)
+    server, share, *rest = path.split( '/' ).reject { |segment| segment.empty? || segment == '.' }
+    kept = rest.each_with_object( [] ) { |segment, resolved| segment == '..' ? resolved.pop : resolved.push( segment ) }
+    return "//#{[server, share, *kept].compact.join( '/' )}"
+  end
+
+  def self.expand_home(path)
+    return path unless path == '~' || path.start_with?( '~/' )
+
+    return Dir.home + path.delete_prefix( '~' )
+  end
+
+  # The real path of the longest existing part of `absolute`, with the rest appended
+  def self.real(absolute)
+    return File.realpath( absolute ) if File.exist?( absolute )
+
+    existing = absolute
+    missing  = []
+    until File.exist?( existing ) || existing == File.dirname( existing )
+      missing.unshift( File.basename( existing ) )
+      existing = File.dirname( existing )
+    end
+
+    return absolute unless File.exist?( existing )
+
+    return File.join( File.realpath( existing ), *missing )
+  end
+
+  private_class_method :clean_absolute?, :absolute_of, :unc_absolute, :expand_home, :real
+
+end

data/lib/ceedling/filesystem/working_dir.rb

@@ -0,0 +1,40 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+# The directory Ceedling runs in, read once.
+#
+# A build resolves paths against the working directory tens of thousands of times, and
+# asking the operating system for it costs tens of microseconds on macOS. Ceedling changes
+# directory only through `chdir`, which forgets the remembered directory going in and
+# coming out.
+#
+# No dependency on DIY, so the launcher in bin/ shares it.
+module WorkingDir
+
+  @lock = Mutex.new
+  @path = nil
+
+  # The working directory with every symlink resolved
+  def self.path
+    return @path || @lock.synchronize { @path ||= File.realpath( Dir.pwd ).freeze }
+  end
+
+  # Changes directory for the block, as Dir.chdir does, so paths resolved inside it resolve
+  # against the new directory and paths resolved after it against the old one
+  def self.chdir(dir, &block)
+    forget
+    return Dir.chdir( dir, &block )
+  ensure
+    forget
+  end
+
+  # The next `path` reads the working directory again
+  def self.forget
+    @lock.synchronize { @path = nil }
+  end
+
+end

data/lib/ceedling/generators/generator.rb

@@ -8,7 +8,7 @@
 require 'ceedling/constants'
 require 'ceedling/exceptions'
 require 'ceedling/includes/includes'
-require 'ceedling/file_path_utils'
+require 'ceedling/filesystem/file_path_utils'
 require 'rake'
 
 class Generator
@@ -120,7 +120,7 @@ class Generator
     return @generator_partials.generate_implementation( **arg_hash )
   end
 
-  def generate_mock(context:, mock:, test:, input_filepath:, output_path:, folder: nil, overrides: {})
+  def generate_mock(context:, mock:, test:, input_filepath:, output_path:, mock_root:, folder: nil, overrides: {})
     arg_hash = {
       :header_file => input_filepath,
       :test => test,
@@ -139,8 +139,7 @@ class Generator
       #  - Make CMock thread-safe
 
       # Get default config created by Ceedling and customize it
-      # CMock writes to its root plus `folder`. That folder always ends `output_path`.
-      mock_root = folder ? output_path.delete_suffix( File.join( '', folder ) ) : output_path
+      # CMock writes below `mock_root` at `folder`, which leads to `output_path`
       config = @generator_mocks.build_configuration( mock_root, overrides: overrides )
   
       # Generate mock
@@ -514,8 +513,8 @@ class Generator
     explain = ->(result) { crash_message( crash_explanation( arg_hash, result ) ) }
 
     case backtrace
-    when :gdb    then @backtrace.do_gdb( filename, executable, shell_result, test_cases, context: context )
-    when :simple then @backtrace.do_simple( filename, executable, shell_result, test_cases, context: context, tool: arg_hash[:tool], explain: explain )
+    when :gdb    then @backtrace.do_gdb( filename, executable, shell_result, test_cases, context: context, test_name: arg_hash[:test_name] )
+    when :simple then @backtrace.do_simple( filename, executable, shell_result, test_cases, tool: arg_hash[:tool], explain: explain )
     # A crash is otherwise reported as a single failure
     else @generator_test_results.create_crash_failure( filename, shell_result, test_cases, message: crash_message( explanation ) || 'Test executable crashed' )
     end

data/lib/ceedling/generators/generator_partials.rb

@@ -5,7 +5,7 @@
 #   SPDX-License-Identifier: MIT
 # =========================================================================
 
-require 'ceedling/file_wrapper'
+require 'ceedling/filesystem/file_wrapper'
 require 'ceedling/partials/partials'
 require 'ceedling/c_extractor/c_extractor_types'
 require 'ceedling/c_extractor/c_extractor_constants'

data/lib/ceedling/generators/generator_test_results_backtrace.rb

@@ -8,7 +8,7 @@
 class GeneratorTestResultsBacktrace
 
   constructor :configurator, :tool_executor, :generator_test_results, :generator_helper,
-              :file_path_utils, :file_wrapper, :loginator
+              :file_path_utils, :build_log_writer, :loginator
 
   def setup()
     @RESULTS_COLLECTOR = Struct.new( :passed, :failed, :ignored, :output, keyword_init:true )
@@ -31,7 +31,10 @@ class GeneratorTestResultsBacktrace
   # Writes the full gdb transcript to a per-test-case log file and assembles a
   # terse crash label (signal + description, optional source line in backticks)
   # for each failing test case. Returns a modified shell_result with regenerated output.
-  def do_gdb(filename, executable, shell_result, test_cases, context:)
+  #
+  # `test_name` places the logs, so same-named tests keep separate ones. Each log holds only
+  # this build's crash.
+  def do_gdb(filename, executable, shell_result, test_cases, context:, test_name:)
     gdb_script_filepath = File.join( @configurator.project_build_tests_root, BACKTRACE_GDB_SCRIPT_FILE )
 
     # Clean stats tracker
@@ -40,8 +43,6 @@ class GeneratorTestResultsBacktrace
     # Reset time
     shell_result[:time] = 0
 
-    test_name = File.basename( filename, '.*' )
-
     # True once some retry group has actually shown crash evidence of its own -- an
     # unresolved member, or (below) a group whose real status contradicts a fully clean
     # set of matches. If this stays false across every group, the whole diagnostic never
@@ -120,8 +121,7 @@ class GeneratorTestResultsBacktrace
 
         # Per-test-case log file: <log_path>/<context>/<test_name>/<test_case>.gdb.log
         log_path = @file_path_utils.form_test_gdb_log( test_name, context: context, name: crashed_case[:test] )
-        @file_wrapper.mkdir( File.dirname( log_path ) )
-        @file_wrapper.write( log_path, "=== #{crashed_case[:test]} ===\n#{crash_result[:output]}\n", 'a' )
+        @build_log_writer.write( log_path, "=== #{crashed_case[:test]} ===\n#{crash_result[:output]}\n" )
 
         unresolved.each do |test_case|
           group_results[:failed] += 1
@@ -296,7 +296,7 @@ class GeneratorTestResultsBacktrace
   # such as Valgrind's, keeps the main run's report.
   #
   # `explain` names the cause of a rerun's crash, if a plugin recognizes it.
-  def do_simple(filename, executable, shell_result, test_cases, context:, tool: nil, explain: nil)
+  def do_simple(filename, executable, shell_result, test_cases, tool: nil, explain: nil)
     results = @RESULTS_COLLECTOR.new( passed:0, failed:0, ignored:0, output:[] )
     shell_result[:time] = 0 # Summed over the per-group sub-process runs
     any_crashed = false

data/lib/ceedling/handoff.rb

@@ -0,0 +1,121 @@
+# =========================================================================
+#   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'
+require_relative 'installation'
+
+# The protocol by which one Ceedling installation hands a command off to another: the
+# selected installation's own launcher replaces this process, given the original command
+# line. Environment markers tell that process who launched it and stop it handing off again.
+#
+# Like Installation, this file depends on nothing else in lib/, so an application loaded
+# by an older launcher can load it with require_relative.
+module Handoff
+
+  LAUNCHER_VAR = 'CEEDLING_HANDOFF_LAUNCHER'
+  TARGET_VAR   = 'CEEDLING_HANDOFF_TARGET'
+
+  # Removes the markers from env, so no subprocess of this build inherits them, and
+  # returns them, or nil when no launcher handed off to this process
+  def self.take_markers(env)
+    launcher = env.delete( LAUNCHER_VAR )
+    target = env.delete( TARGET_VAR )
+    return nil if target.nil?
+
+    return {launcher: launcher, target: target}
+  end
+
+  # Whether the markers name own as the installation a launcher handed off to
+  def self.received?(markers, own:)
+    return false if markers.nil? or markers[:target].nil?
+
+    return Installation.new( markers[:target] ) == own
+  end
+
+  def self.handing_off_message(launcher:, target:)
+    return "#{launcher.describe( 'Ceedling launcher' )} is handing off to #{target.describe()}, which runs in its own process."
+  end
+
+  def self.received_message(markers, own:)
+    return "#{own.describe()} is now running, launched from #{Installation.new( markers[:launcher] ).describe()}."
+  end
+
+  # Replaces this process with target's own launcher. Nothing after this call runs, not
+  # even END blocks, so logging drains and the standard streams flush first.
+  def self.exec(target:, launcher:, argv:, loginator:)
+    loginator.wrapup()
+    $stdout.flush()
+    $stderr.flush()
+
+    markers = {LAUNCHER_VAR => launcher.root, TARGET_VAR => target.root}
+    replace_process( markers, RbConfig.ruby, target.bin_path, *argv )
+  end
+
+  # Finishes a hand-off that a launcher before 1.2.2 cannot make: it loads this application
+  # into its own process. Every such launcher kept the original command line in the
+  # SystemWrapper it hands over, so the application restarts as its own launcher. Without
+  # that command line, or inside a hand-off already, it warns and continues in-process,
+  # so a restart never cycles.
+  def self.complete_in_process(app_root:, app_cfg:, handoff_objects:, env:)
+    launcher = Installation.new( launcher_root_of( app_cfg ) )
+    app = Installation.new( app_root )
+    return if launcher == app
+
+    loginator = handoff_objects[:loginator]
+    argv = command_line( handoff_objects[:system_wrapper] )
+    restart = !(argv.nil? or in_handoff?( app_cfg, env ))
+
+    loginator.log( loaded_message( launcher, app, restart ), Verbosity::COMPLAIN )
+    exec( target:app, launcher:launcher, argv:argv, loginator:loginator ) if restart
+  end
+
+  # The one seam to the operating system, so specs can stand in for it
+  def self.replace_process(env, *command)
+    Kernel.exec( env, *command )
+  end
+
+  # The launcher's CeedlingAppConfig is defined in its own bin/
+  def self.launcher_root_of(app_cfg)
+    filepath, _ = app_cfg.class.instance_method( :initialize ).source_location
+    return File.expand_path( '..', File.dirname( filepath ) )
+  end
+
+  def self.command_line(system_wrapper)
+    return nil if !system_wrapper.respond_to?( :get_cmdline )
+
+    return system_wrapper.get_cmdline()
+  end
+
+  def self.in_handoff?(app_cfg, env)
+    return true if !app_cfg[:handoff].nil?
+
+    return !(env[TARGET_VAR].nil? and env[LAUNCHER_VAR].nil?)
+  end
+
+  def self.loaded_message(launcher, app, restart)
+    loaded = "#{launcher.describe( 'Ceedling launcher' )} loaded #{app.describe()} into its own process."
+    return "#{loaded} Restarting in #{app.name()}'s own process. Upgrade Ceedling and review your installations to avoid this." if restart
+
+    return "#{loaded} #{continuing_advice( app )}"
+  end
+
+  def self.continuing_advice(app)
+    return "Continuing in the launcher's process, which can fail or misbehave. Upgrade Ceedling, or run this " +
+           "installation's own launcher directly with `ruby #{display_path( app.bin_path )}`. A project created " +
+           "with `--local` has a launch script at its root that does this: run `./ceedling` from the project root " +
+           "(`.\\ceedling.cmd` on Windows)."
+  end
+
+  # Relative to the working directory when beneath it, as a user would type it
+  def self.display_path(filepath)
+    cwd = File.join( Dir.pwd, '' )
+    return filepath.start_with?( cwd ) ? filepath.delete_prefix( cwd ) : filepath
+  end
+
+  private_class_method :launcher_root_of, :command_line, :in_handoff?, :loaded_message, :continuing_advice, :display_path
+
+end

data/lib/ceedling/includes/include_factory.rb

@@ -40,9 +40,9 @@ class IncludeFactory
 
   # A resolved mock include's filepath may carry a leading build directory path that
   # snuck in from discovering an empty mock stand-in or an already-generated mock file.
-  # That leading path is the current test's own mock subdirectory -- which mirrors the
-  # test's path below its configured :paths -> :test root, so it can be more than one
-  # segment deep (e.g. `adc/TestFoo`) -- followed by however many further segments mirror
+  # That leading path is the current test's own mock subdirectory -- named by the test's
+  # path from the project root, so it can be more than one segment deep (e.g.
+  # `test/adc/TestFoo`) -- followed by however many further segments mirror
   # the mocked header's own relative directory (e.g. `calculators/`). Knowing the current
   # test's identity lets exactly the first part be removed, leaving any header-mirroring
   # segments after it untouched. Without that identity, fall back to stripping everything

data/lib/ceedling/includes/include_pathinator.rb

@@ -7,10 +7,18 @@
 
 require 'pathname'
 require 'ceedling/exceptions'
-require 'ceedling/file_path_utils'
+require 'ceedling/filesystem/file_path_utils'
+require 'ceedling/filesystem/project_paths'
 
 class IncludePathinator
 
+  NO_HEADERS_MESSAGE = "No header files found in project.\n" +
+                       "Add search paths to :paths ↳ :include in your project file and/or use TEST_INCLUDE_PATH() in your test files.\n" +
+                       "Verify header files with `ceedling paths:include` and\\or `ceedling files:include`."
+
+  # What `header_listing` remembers for a directory under the build root
+  LISTED_FRESH = :listed_fresh
+
   constructor :configurator, :test_context_extractor, :loginator, :file_wrapper
 
   def setup
@@ -20,6 +28,10 @@ class IncludePathinator
 
     # Alias for brevity
     @extractor = @test_context_extractor
+
+    # Each search path's header listing for one test build (see `header_listing`)
+    @listings      = {}
+    @listings_lock = Mutex.new
   end
 
   def validate_test_build_directive_paths
@@ -52,12 +64,7 @@ class IncludePathinator
 
     headers.uniq!
 
-    if headers.length == 0
-      error = "No header files found in project.\n" +
-              "Add search paths to :paths ↳ :include in your project file and/or use TEST_INCLUDE_PATH() in your test files.\n" +
-              "Verify header files with `ceedling paths:include` and\\or `ceedling files:include`."
-      @loginator.log( error, Verbosity::COMPLAIN )
-    end
+    @loginator.log( NO_HEADERS_MESSAGE, Verbosity::COMPLAIN ) if headers.empty?
 
     return headers
   end
@@ -70,11 +77,16 @@ class IncludePathinator
   def ordered_header_files(search_paths)
     headers = []
     search_paths.each do |path|
-      headers += @file_wrapper.directory_listing( @configurator.extension_header.glob_patterns(path) )
+      headers.concat( header_listing( path ) )
     end
     return headers.uniq
   end
 
+  # Starts a test build with every search path listed afresh
+  def forget_header_listings
+    @listings_lock.synchronize { @listings.clear }
+  end
+
   # The project's whole header collection, reordered so headers beneath this test's
   # own earlier search paths come first.
   #
@@ -88,10 +100,10 @@ class IncludePathinator
   # reference that distinguishes nothing resolving exactly as it did before.
   def prioritized_header_files(search_paths)
     roots = search_paths.map { |path| FilePathUtils.no_decorators( path ) }.reject(&:empty?)
+    ranks = root_ranks( roots )
 
     @configurator.collection_all_headers.to_a.each_with_index.sort_by do |header, index|
-      rank = roots.index { |root| header == root || header.start_with?( root + '/' ) } || roots.length
-      [rank, index]
+      [header_rank( header, ranks, roots.length ), index]
     end.map(&:first)
   end
 
@@ -116,4 +128,49 @@ class IncludePathinator
     return paths
   end
 
+  private
+
+  # One search path's headers. A directory outside the build root keeps its listing for the
+  # test build, since a build never writes there, and a test's search paths are listed
+  # several times a test. One under the build root is listed every time, since the build
+  # fills it as it runs.
+  def header_listing(path)
+    key        = [ProjectPaths.working_dir, path]
+    remembered = @listings_lock.synchronize { @listings[key] }
+    return remembered if remembered.is_a?( Array )
+
+    listing = @file_wrapper.directory_listing( @configurator.extension_header.glob_patterns( path ) ).freeze
+    return listing if remembered == LISTED_FRESH
+
+    kept = ProjectPaths.contains?( @configurator.project_build_root, path ) ? LISTED_FRESH : listing
+    @listings_lock.synchronize { @listings[key] ||= kept }
+    return listing
+  end
+
+  # Each root's place in the search order by its absolute path, the first one kept, so a
+  # header's rank comes from walking up its own directories rather than trying every root
+  def root_ranks(roots)
+    return roots.each_with_index.with_object( {} ) { |(root, index), ranks| ranks[rank_key( ProjectPaths.absolute( root ) )] ||= index }
+  end
+
+  # The earliest-searched root a header lies below, or `none` for no root
+  def header_rank(header, ranks, none)
+    rank = none
+    path = ProjectPaths.absolute( header )
+    loop do
+      parent = File.dirname( path )
+      break if parent == path
+
+      path = parent
+      rank = [rank, ranks.fetch( rank_key( path ), none )].min
+    end
+
+    return rank
+  end
+
+  # Windows compares paths without regard to case
+  def rank_key(path)
+    return ProjectPaths::WINDOWS ? path.downcase : path
+  end
+
 end

data/lib/ceedling/includes/includes.rb

@@ -7,7 +7,7 @@
 
 require 'set'
 require 'ceedling/exceptions'
-require 'ceedling/path_matcher'
+require 'ceedling/filesystem/path_matcher'
 
 class Includes
   # Class method to convert mixed list of Include objects into an order-preserving list of hashes