ceedling 1.2.1 → 1.2.2

data/lib/ceedling/filesystem/file_path_collection_utils.rb

@@ -0,0 +1,183 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+require 'set'
+require 'pathname'
+require 'fileutils'
+require 'ceedling/filesystem/file_path_utils'
+require 'ceedling/exceptions'
+require 'ceedling/filesystem/project_paths'
+require 'ceedling/filesystem/path_spellings'
+require 'ceedling/filesystem/path_exclusions'
+
+
+class FilePathCollectionUtils
+
+  # One collected directory: its spelling through its entry's real base, both of its
+  # spellings, and how far below the nearest base of an entry naming it it lies
+  Named = Struct.new( :spelled, :spellings, :distance )
+
+  constructor :file_wrapper
+
+  # The directories one or more (+:/-:) paths and globs name, once each, spelled through
+  # each entry's base as the base really is, as an #include or a test name reaches them. A
+  # `-:` entry drops the directories it names and every directory below them, except one an
+  # additive entry naming it names nearer. Each path in `exclude` does so too, except where
+  # an entry naming a directory is based no farther away. Each path in `reserved`, and every
+  # directory below it, is never collected.
+  def collect_paths(paths, exclude: [], reserved: [])
+    # Nil input (e.g. unconfigured section) is treated as an empty list
+    return [] if paths.nil?
+
+    additive, subtractive = paths.partition { |entry| FilePathUtils.add_path?( entry ) }
+    minus = PathExclusions.of( directories_of( subtractive ), exclude, reserved )
+
+    kept = named_directories( additive ).select { |named| minus.keeps?( named.spellings, named.distance ) }
+    return kept.map { |named| ProjectPaths.relative( named.spelled ) }
+  end
+
+  # Given a file list, add to it or remove from it considering (+:/-:) aggregation operators.
+  # Rake's FileList does not robustly handle relative filepaths and patterns.
+  # So, we rebuild the FileList ourselves and return it. A revision adds no file below a
+  # path in `exclude` unless the revision is based no farther away, and none below a path in
+  # `reserved` at all.
+  def revise_filelist(list, revisions, exclude: [], reserved: [])
+    # Nil list produces an empty FileList; nil revisions leaves the list unchanged
+    return FileList.new([]) if list.nil?
+
+    additive, subtractive = (revisions || []).partition { |revision| FilePathUtils.add_path?( revision ) }
+    kept = kept_files( list, additive, subtractive, PathExclusions.of( [], exclude, reserved ) )
+
+    # #104 -- every entry here is already a concrete, real file, but plain FileList.new or
+    # #include re-reads each as a glob, silently dropping a literal `[`/`]`.
+    # FileWrapper#instantiate_file_list_literal adds every entry as-is.
+    result = @file_wrapper.instantiate_file_list_literal( kept.map { |path| ProjectPaths.relative( path ) } )
+    result.resolve() # Force expansion to prevent race conditions in threaded context
+    return result
+  end
+
+  # The places files below `entries` mirror below, each spelled canonically: the base of a
+  # `/**` or `/*` entry, every directory a glob within an entry names, or the entry itself.
+  # A `-:` exclusion roots nothing. A `[`/`]` is part of a name (#104), never a glob.
+  def collect_mirror_roots(entries)
+    return [] if entries.nil?
+
+    roots = entries.select { |entry| FilePathUtils.add_path?( entry ) }.flat_map { |entry| entry_roots( entry ) }
+    return roots.map { |root| ProjectPaths.canonical( root ) }.uniq
+  end
+
+  # A path relative to the working directory, or absolute when it has no relative form
+  def shortest_path_from_working(path)
+    return ProjectPaths.relative( ProjectPaths.absolute( path ) )
+  end
+
+  private
+
+  # Every directory additive entries name, once each by its real spelling, with its distance
+  # below the nearest base of the entries naming it
+  def named_directories(entries)
+    named = {}
+    entries.each do |entry|
+      bases = PathSpellings.of( [FilePathUtils.no_decorators( entry )] )
+      entry_directories( entry ).each { |dir| name_directory( named, dir, bases ) }
+    end
+
+    return named.values
+  end
+
+  # Records `dir`, the first spelling of its real place kept, nearer if these bases are
+  def name_directory(named, dir, bases)
+    both  = [dir, ProjectPaths.real_absolute( dir )]
+    found = (named[PathSpellings.key( both.last )] ||= Named.new( dir, both, Float::INFINITY ))
+    found.distance = [found.distance, PathSpellings.nearer( both, bases )].min
+  end
+
+  # The listed files and those additive revisions name, less those `-:` revisions name, each
+  # compared through its directory as it really is
+  def kept_files(list, additive, subtractive, excluded)
+    real  = {}
+    minus = Set.new( files_of( subtractive ).map { |path| real_key( path, real ) } )
+    added = added_files( additive, excluded, real )
+    return (list.map { |path| ProjectPaths.absolute( path ) } + added).uniq { |path| real_key( path, real ) }.reject { |path| minus.include?( real_key( path, real ) ) }
+  end
+
+  # The files additive revisions name that `excluded` keeps, each judged by its distance
+  # below the base of the revision naming it
+  def added_files(additive, excluded, real)
+    return files_of( additive ) if excluded.none?
+
+    return additive.flat_map do |revision|
+      bases = PathSpellings.of( [FilePathUtils.no_decorators( revision )] )
+      revision_files( revision ).select do |file|
+        spellings = [file, real_spelling( file, real )]
+        excluded.keeps?( spellings, PathSpellings.nearer( spellings, bases ) )
+      end
+    end
+  end
+
+  def directories_of(entries)
+    return entries.flat_map { |entry| entry_directories( entry ) }
+  end
+
+  def files_of(revisions)
+    return revisions.flat_map { |revision| revision_files( revision ) }
+  end
+
+  # Every directory one entry names, absolute and spelled through its base as the base
+  # really is, so one place is never collected under two spellings of that base
+  def entry_directories(entry)
+    path = ProjectPaths.standardize( FilePathUtils.no_aggregation_decorators( entry ) )
+    dirs = listed_directories( path )
+    dirs = with_parents( dirs, path ) if path.end_with?( '/**', '/*' )
+
+    return PathSpellings.through_real( dirs.map { |dir| ProjectPaths.absolute( dir ) }, ProjectPaths.absolute( FilePathUtils.no_decorators( path ) ) )
+  end
+
+  # #104 -- FilePathUtils.subdirectory_glob escapes a literal `[`/`]` in the path itself, so
+  # it's matched literally rather than read as glob syntax. Sorted for Github Issue #860.
+  def listed_directories(path)
+    entries = @file_wrapper.directory_listing( FilePathUtils.subdirectory_glob( path ) ).sort
+    return entries.select { |entry| @file_wrapper.directory?( entry ) }
+  end
+
+  # Ceedling's recursive glob convention includes the directory above each match, unlike
+  # Ruby's, and the base directory itself when nothing below it matches
+  def with_parents(dirs, path)
+    parents = dirs.map { |dir| File.join( dir, '..' ) }
+    parents << FilePathUtils.no_decorators( path ) if dirs.empty?
+    return parents + dirs
+  end
+
+  def entry_roots(entry)
+    path = ProjectPaths.standardize( FilePathUtils.no_aggregation_decorators( entry ) ).sub( %r{(?:/\*\*?)+\z}, '' )
+    return [path] unless path.match?( /[*?{]/ )
+
+    listing = @file_wrapper.directory_listing( FilePathUtils.escape_glob_brackets( path ) )
+    return listing.sort.select { |listed| @file_wrapper.directory?( listed ) }
+  end
+
+  # Every file one :files revision names, absolute and spelled through its base as the base
+  # really is. #104 -- a literal `[`/`]` is escaped as in `listed_directories`.
+  def revision_files(revision)
+    path  = ProjectPaths.standardize( FilePathUtils.no_aggregation_decorators( revision ) )
+    files = @file_wrapper.directory_listing( FilePathUtils.escape_glob_brackets( path ) ).sort.reject { |entry| @file_wrapper.directory?( entry ) }
+
+    return PathSpellings.through_real( files.map { |file| ProjectPaths.absolute( file ) }, ProjectPaths.absolute( FilePathUtils.no_decorators( path ) ) )
+  end
+
+  # A file compared through its directory as it really is, keeping its own name. Each
+  # directory is resolved once per call, in `real`.
+  def real_key(file, real)
+    return PathSpellings.key( real_spelling( file, real ) )
+  end
+
+  def real_spelling(file, real)
+    dir = File.dirname( file )
+    return File.join( (real[dir] ||= ProjectPaths.real_absolute( dir )), File.basename( file ) )
+  end
+
+end

data/lib/ceedling/{file_path_utils.rb → filesystem/file_path_utils.rb}

@@ -8,10 +8,16 @@
 require 'rubygems'
 require 'rake' # for ext()
 require 'fileutils'
+require 'pathname'
 require 'ceedling/exceptions'
+require 'set'
 require 'ceedling/system_wrapper'
 require 'ceedling/constants'
-require 'ceedling/path_mirror'
+require 'ceedling/filesystem/path_mirror'
+require 'ceedling/filesystem/path_matcher'
+require 'ceedling/filesystem/project_paths'
+require 'ceedling/filesystem/build_subpath'
+require 'ceedling/filesystem/destination_collision'
 
 # global utility methods (for plugins, project files, etc.)
 def ceedling_form_filepath(destination_path, original_filepath, new_extension=nil)
@@ -24,6 +30,10 @@ class FilePathUtils
 
   constructor :configurator, :file_wrapper
 
+  def setup
+    @formed_lock  = Mutex.new
+    @formed_paths = Set.new
+  end
 
   ######### Class methods ##########
 
@@ -32,9 +42,7 @@ class FilePathUtils
   def self.standardize_in_place(path)
     if path.is_a? String
       raise CeedlingException.new("Attempted to standardize path in frozen string ⏩️ #{path.inspect}") if path.frozen?
-      path.strip!
-      path.tr!("\\", '/')
-      path.chomp!('/')
+      path.replace( ProjectPaths.standardize( path ) )
     end
     return path
   end
@@ -149,31 +157,24 @@ class FilePathUtils
   #   ['a/b', 'a/c', 'a']             =>  ['a']
   #   ['src', 'lib/core', 'lib/utils'] =>  ['src', 'lib/core', 'lib/utils']  (unchanged)
   #
-  # Comparison uses forward-slash-normalized copies; returned paths preserve the original
-  # form supplied by the caller.
+  # Paths compare as the directories they name (ProjectPaths.contains?), so `..` holds
+  # `../sib` but not `../../far/x`. Returned paths preserve the form the caller supplied.
   def self.collapse_to_common_parents(paths)
     return paths if paths.nil? || paths.length <= 1
 
-    # Pair each original path with a normalized form used only for ancestry comparison.
-    # Normalize to forward slashes and strip any trailing separator.
-    pairs = paths.map { |p| [p, p.tr('\\', '/').chomp('/')] }
-
-    # Sort shallowest-first so ancestors are always encountered before their descendants.
-    # No tiebreaker for same-depth entries needed: Ruby's sort_by doesn't guarantee a
-    # stable order among ties, but two same-depth paths can never be each other's
-    # ancestor, so the ancestor-exclusion check below is correct regardless of which
-    # order same-depth ties come out in.
-    pairs.sort_by! { |_, normalized| normalized.count('/') }
-
-    kept = []
-    pairs.each do |original, normalized|
-      # Skip this path if any already-kept path is a proper ancestor of it.
-      next if kept.any? { |_, k| normalized.start_with?(k + '/') }
-      kept << [original, normalized]
-    end
+    # Shortest absolute spelling first, so an ancestor is always met before what it holds
+    pairs = paths.map { |path| [path, ProjectPaths.absolute( path )] }.sort_by { |_, absolute| absolute.length }
+
+    return outermost( pairs ).map { |original, _| original }
+  end
 
-    kept.map { |original, _| original }
+  # The [original, absolute] pairs no earlier pair's directory holds
+  def self.outermost(pairs)
+    return pairs.each_with_object( [] ) do |pair, kept|
+      kept << pair unless kept.any? { |_, held| ProjectPaths.contains?( held, pair.last ) }
+    end
   end
+  private_class_method :outermost
 
 
   ######### Instance methods ##########
@@ -192,12 +193,7 @@ class FilePathUtils
   end
 
   def form_release_build_objects_filelist(files)
-    return mirror_build_objects(
-      files,
-      root:  @configurator.project_release_build_output_path,
-      ext:   @configurator.extension_object.primary,
-      roots: @configurator.paths_source
-    )
+    return mirror_build_objects( files, root: @configurator.project_release_build_output_path, ext: @configurator.extension_object.primary )
   end
 
   # `filepath` is an already-mirrored object path -- its own directory is exactly where its
@@ -207,32 +203,34 @@ class FilePathUtils
   end
 
   def form_release_dependencies_filelist(files)
-    return mirror_build_objects(
-      files,
-      root:  @configurator.project_release_dependencies_path,
-      ext:   @configurator.extension_dependencies.primary,
-      roots: @configurator.paths_source
-    )
+    return mirror_build_objects( files, root: @configurator.project_release_dependencies_path, ext: @configurator.extension_dependencies.primary )
   end
 
   ### Tests ###
 
+  # A test is named by its path from the project root, without its extension. The name places
+  # the test's build, results, runner, mock, preprocessing and log directories, and a path is
+  # unique, so no two tests share them. A test outside the project keeps its whole path too,
+  # with each `..` written as `_up_`, and a path with no relative form (another Windows drive)
+  # placed under `_abs_`, so no name reaches outside the build directory.
+  def form_test_name(filepath)
+    return BuildSubpath.encode( filepath.to_s.ext( '' ) )
+  end
+
   def form_test_build_path(name, context: nil)
     form_build_context_path(BUILD_OUT_DIR, name: name, context: context)
   end
 
+  # Where a build places the object of `filepath`: below its test's build path, or below the
+  # context's own output root for a source compiled outside any test
   def form_test_object_filepath(filepath, name: nil, context: nil)
-    File.join(
-      form_build_context_path(BUILD_OUT_DIR, name: name, context: context),
-      File.basename(filepath).ext(@configurator.extension_object.primary)
-    )
+    root = form_build_context_path( BUILD_OUT_DIR, name: name, context: context )
+    return build_filepath( filepath, root: root, ext: @configurator.extension_object.primary, generated_roots: generated_roots( name ) )
   end
 
-  # As `form_test_runners_path`: a flat test's own identity forms the shared flat results
-  # directory, untouched -- only a genuinely nested test's own mirrored subdirectory
-  # becomes an extra directory level here, so two same-named tests land in distinct
-  # results directories without perturbing the overwhelmingly common flat, non-duplicate
-  # case.
+  # As `form_test_runners_path`: a test's results sit beneath the directories of its name,
+  # so same-named tests in different directories keep apart. Only a test at the project
+  # root uses the results directory itself.
   def form_test_results_path(name = nil, context: nil)
     subdir = name.nil? ? '' : mirrored_test_subdir(name)
     return form_build_context_path(BUILD_RESULTS_DIR, context: context) if subdir.empty?
@@ -253,51 +251,46 @@ class FilePathUtils
     form_build_context_path(BUILD_DEPENDENCIES_DIR, name: name, context: context)
   end
 
-  # `filepath` is an already-mirrored object path -- recovering the mirrored subdirectory
-  # beyond the test's own build root and re-rooting it under this test's dependencies path
-  # keeps this dependencies file alongside the same-named object it accompanies, rather
-  # than colliding with another object's dependencies file at a shared flat basename.
-  # Without a test identity to recover that build root from, there's no mirroring to do --
-  # the dependencies file stays exactly where its context-level directory alone places it.
+  # `filepath` is an object path. Its dependencies file sits at the object's own place below
+  # the dependencies root, so it never collides with another same-named object's. Without a
+  # test, that place is below the context's own output root.
   def form_test_dependencies_filepath(filepath, name: nil, context: nil)
     root     = form_build_context_path(BUILD_DEPENDENCIES_DIR, name: name, context: context)
     basename = File.basename(filepath).ext(@configurator.extension_dependencies.primary)
 
-    return File.join(root, basename) if name.nil?
-
-    subdir = PathMirror.relative_subdir( filepath, [form_test_build_path(name, context: context)] )
+    subdir = ProjectPaths.subdir_below( form_test_build_path( name, context: context ), File.dirname( filepath ) ) || ''
     return subdir.empty? ? File.join(root, basename) : File.join(root, subdir, basename)
   end
 
-  def form_test_mocks_path(name, context: nil)
+  def form_test_mocks_path(name)
     form_named_path(@configurator.cmock_mock_path, name)
   end
 
-  def form_test_partials_path(name, context: nil)
+  def form_test_partials_path(name)
     form_named_path(@configurator.project_test_partials_path, name)
   end
 
-  def form_test_preprocess_includes_path(name, context: nil)
+  def form_test_preprocess_includes_path(name)
     form_named_path(@configurator.project_test_preprocess_includes_path, name)
   end
 
-  def form_test_preprocess_files_path(name, context: nil)
+  def form_test_preprocess_files_path(name)
     form_named_path(@configurator.project_test_preprocess_files_path, name)
   end
 
-  def form_test_preprocess_files_full_expansion_path(name, context: nil)
+  def form_test_preprocess_files_full_expansion_path(name)
     form_named_path(@configurator.project_test_preprocess_files_path, name, subdir: PREPROCESS_FULL_EXPANSION_DIR)
   end
 
-  def form_test_preprocess_files_directives_only_path(name, context: nil)
+  def form_test_preprocess_files_directives_only_path(name)
     form_named_path(@configurator.project_test_preprocess_files_path, name, subdir: PREPROCESS_DIRECTIVES_ONLY_DIR)
   end
 
-  def form_test_preprocess_files_raw_directives_only_path(name, context: nil)
+  def form_test_preprocess_files_raw_directives_only_path(name)
     form_named_path(@configurator.project_test_preprocess_files_path, name, subdir: PREPROCESS_RAW_DIRECTIVES_ONLY_DIR)
   end
 
-  def form_test_preprocess_build_directives_path(name, context: nil)
+  def form_test_preprocess_build_directives_path(name)
     form_named_path(@configurator.project_test_preprocess_build_directives_path, name)
   end
 
@@ -323,12 +316,10 @@ class FilePathUtils
     return File.join( build_output_path, File.basename(filepath).ext(@configurator.extension_testfail.primary) )
   end
 
-  # A flat test's own identity (no mirrored subdirectory of its own) forms the shared flat
-  # runners directory, untouched -- only a genuinely nested test's own mirrored
-  # subdirectory (excluding its own basename) becomes an extra directory level here, so two
-  # same-named tests in different directories land in distinct runner directories without
-  # perturbing the overwhelmingly common flat, non-duplicate case.
-  def form_test_runners_path(name, context: nil)
+  # A test's runner sits beneath the directories of its name, so same-named tests in
+  # different directories keep apart. Only a test at the project root uses the runners
+  # directory itself.
+  def form_test_runners_path(name)
     subdir = mirrored_test_subdir(name)
     return @configurator.project_test_runners_path if subdir.empty?
     return File.join(@configurator.project_test_runners_path, subdir)
@@ -373,13 +364,7 @@ class FilePathUtils
   # the same filepath, so all of them agree on where the artifact lands without
   # coordinating.
   def preprocessed_file_subpath(filepath, test = nil)
-    roots = @configurator.paths_source +
-            @configurator.paths_support +
-            @configurator.paths_include +
-            @configurator.paths_test +
-            generated_roots( test )
-
-    subdir   = PathMirror.relative_subdir( filepath, roots )
+    subdir   = form_build_subpath( filepath, generated_roots: generated_roots( test ) )
     basename = File.basename( filepath )
 
     return basename if subdir.empty?
@@ -450,12 +435,7 @@ class FilePathUtils
   # standard roots mirrors it. Without its root here, two modules sharing a basename
   # collapse onto one object filename.
   def form_test_build_objects_filelist(path, sources, extra_roots: [])
-    return mirror_build_objects(
-      sources,
-      root:  path,
-      ext:   @configurator.extension_object.primary,
-      roots: @configurator.paths_source + @configurator.paths_support + extra_roots
-    )
+    return mirror_build_objects( sources, root: path, ext: @configurator.extension_object.primary, generated_roots: extra_roots )
   end
 
   # Where one mock's generated files sit: its test's mock root, plus the subdirectory
@@ -546,13 +526,13 @@ class FilePathUtils
     return form_partial_filename( _module, PARTIAL_SUFFIX_IMPL, EXTENSION_CORE_SOURCE )
   end
 
+  # Each test's results file sits where `form_test_results_path` puts it, beneath its name
   def form_pass_results_filelist(path, files)
-    return mirror_build_objects(
-      files,
-      root:  path,
-      ext:   @configurator.extension_testpass.primary,
-      roots: @configurator.paths_test
-    )
+    results = @file_wrapper.instantiate_file_list_literal( files ).map do |file|
+      subdir = mirrored_test_subdir( form_test_name( file ) )
+      form_pass_results_filepath( subdir.empty? ? path : File.join( path, subdir ), file )
+    end
+    return @file_wrapper.instantiate_file_list_literal( results )
   end
 
   ### Private ###
@@ -577,9 +557,8 @@ class FilePathUtils
     return path
   end
 
-  # The mirrored-subdirectory portion of a test's own identity, excluding its own basename
-  # -- '' for a flat test (e.g. 'TestFoo', no subdirectory at all), or the leading segments
-  # for a nested one (e.g. 'unit' for 'unit/test_foo').
+  # The directories of a test's name, excluding its basename: 'test/unit' for
+  # 'test/unit/test_foo', or '' for a test at the project root.
   def mirrored_test_subdir(name)
     dir = File.dirname(name)
     return '' if dir == '.'
@@ -602,15 +581,47 @@ class FilePathUtils
   # it contains a literal `[`/`]`. FileWrapper#instantiate_file_list_literal (`<<`, not
   # `.new`/`.include`) adds every entry as-is, with no glob interpretation at all -- the
   # correct construction for a list that's already the real, final answer.
-  def mirror_build_objects(files, root:, ext:, roots:)
-    clean_roots = PathMirror.clean_roots( roots )
+  def mirror_build_objects(files, root:, ext:, generated_roots: [])
+    sources = @file_wrapper.instantiate_file_list_literal( files ).to_a.uniq { |file| ProjectPaths.absolute( file ) }
+    objects = sources.map { |file| build_filepath( file, root: root, ext: ext, generated_roots: generated_roots ) }
 
-    objects = @file_wrapper.instantiate_file_list_literal(files).map do |file|
-      subdir   = PathMirror.relative_subdir_from_clean_roots( file, clean_roots )
-      basename = File.basename(file).ext(ext)
-      subdir.empty? ? File.join(root, basename) : File.join(root, subdir, basename)
-    end
+    validate_distinct_build_files!( sources, objects )
     return @file_wrapper.instantiate_file_list_literal( objects )
   end
 
+  def build_filepath(file, root:, ext:, generated_roots:)
+    subdir   = form_build_subpath( file, generated_roots: generated_roots )
+    basename = File.basename( file ).ext( ext )
+    path     = subdir.empty? ? File.join( root, basename ) : File.join( root, subdir, basename )
+
+    # A source far from the project gains a directory for each level its path climbs. Each
+    # path is checked once, however often it is formed.
+    @file_wrapper.check_path_length( path, origin: 'FilePathUtils#build_filepath' ) if first_formed?( path )
+    return path
+  end
+
+  def first_formed?(path)
+    return @formed_lock.synchronize { @formed_paths.add?( path ) }
+  end
+
+  # Where below a build output root the build file of `file` lands. A file below one of the
+  # caller's generated roots (a test's mocks or Partials) mirrors below that root; one
+  # below the build root otherwise (vendored frameworks, runners) lands flat; and any other
+  # lands by its own path from the project root, so two sources never share one.
+  def form_build_subpath(file, generated_roots: [])
+    generated = PathMirror.relative_subdir_if_rooted_in_clean_roots( file, generated_roots )
+    return generated unless generated.nil?
+    return '' if ProjectPaths.contains?( @configurator.project_build_root, file )
+
+    return BuildSubpath.of_directory( File.dirname( file ) )
+  end
+
+  # Two sources building to one file would leave one of them out of the build
+  def validate_distinct_build_files!(sources, built)
+    built_from = sources.zip( built ).to_h
+    DestinationCollision.find( sources ) { |source| built_from[source] }.each do |file, sharing|
+      DestinationCollision.raise_for( file, sharing, 'would build to the same file' )
+    end
+  end
+
 end

data/lib/ceedling/{file_system_wrapper.rb → filesystem/file_system_wrapper.rb}

@@ -5,12 +5,13 @@
 #   SPDX-License-Identifier: MIT
 # =========================================================================
 
+require 'ceedling/filesystem/working_dir'
+
 class FileSystemWrapper
 
-  def cd(path)
-    FileUtils.cd path do
-      yield
-    end
+  # Through WorkingDir, so paths resolved inside the block resolve against `path`
+  def cd(path, &block)
+    return WorkingDir.chdir( path, &block )
   end
 
-end
+end