ceedling 1.2.1 → 1.2.2

data/lib/ceedling/config/configurator_builder.rb

@@ -7,11 +7,13 @@
 
 require 'rubygems'
 require 'rake'                     # for ext() method
-require 'ceedling/file_path_utils' # for class methods
+require 'ceedling/filesystem/file_path_utils' # for class methods
+require 'ceedling/filesystem/project_paths'
 require 'ceedling/defaults'
 require 'ceedling/constants'       # for Verbosity constants class & base file paths
 require 'ceedling/filename_extension'
 require 'ceedling/rake_app/rakefile_component_resolver'
+require 'ceedling/config/build_root_policy'
 
 class ConfiguratorBuilder
 
@@ -130,17 +132,18 @@ class ConfiguratorBuilder
 
 
   # A release is named by :release_build ↳ :output, or by default and the executable
-  # extension. Its map file shares its name.
+  # extension. Its map file shares its name. A relative name is below the release build root,
+  # and an absolute one names the release itself.
   def set_release_target(in_hash)
     return {} if (not in_hash[:project_release_build])
 
-    output = in_hash[:release_build_output]
+    output = in_hash[:release_build_output]&.then { |name| ProjectPaths.standardize( name ) }
     target = output || DEFAULT_RELEASE_TARGET_NAME.ext( in_hash[:extension_executable].primary )
     map    = (output || DEFAULT_RELEASE_TARGET_NAME).ext( in_hash[:extension_map].primary )
 
     # tempted to make a helper method in file_path_utils? stop right there, pal. you'll introduce a cyclical dependency
     root = in_hash[:project_build_release_root]
-    return { project_release_build_target: File.join( root, target ), project_release_build_map: File.join( root, map ) }
+    return { project_release_build_target: release_place( root, target ), project_release_build_map: release_place( root, map ) }
   end
 
 
@@ -163,14 +166,28 @@ class ConfiguratorBuilder
   end
 
 
-  # Every :paths entry becomes a collection of the directories its globs name
+  # Every :paths entry becomes a collection of the directories its globs name, leaving out
+  # the build root, which a root above it (`../**`, `./**`) would otherwise sweep in, and
+  # the directories Ceedling creates
   def expand_all_path_globs(in_hash)
     path_keys = in_hash.keys.select { |key| key.to_s.start_with?( 'paths' ) }
 
-    return path_keys.to_h { |key| [:"collection_#{key}", @file_path_collection_utils.collect_paths( in_hash[key] )] }
+    return path_keys.to_h { |key| [:"collection_#{key}", @file_path_collection_utils.collect_paths( in_hash[key], **build_exclusions( in_hash ) )] }
   end
 
 
+  # The roots build files mirror below, each spelled canonically: those of :paths ↳ :include,
+  # for a header's source by convention, and those every header is collected from
+  def collect_mirror_roots(in_hash)
+    include = Array( in_hash[:paths_include] )
+    headers = Array( in_hash[:paths_test] ) + Array( in_hash[:paths_support] ) + include
+
+    return {
+      :collection_mirror_roots_include => @file_path_collection_utils.collect_mirror_roots( include ),
+      :collection_mirror_roots_headers => @file_path_collection_utils.collect_mirror_roots( headers )
+    }
+  end
+
   def collect_source_and_include_paths(in_hash)
     return {
       :collection_paths_source_and_include =>
@@ -228,7 +245,7 @@ class ConfiguratorBuilder
     end
 
     # Add / subtract files via :files ↳ :test
-    tests = file_collection( patterns, in_hash[:files_test] )
+    tests = file_collection( in_hash, patterns, in_hash[:files_test] )
     return { :collection_all_tests => tests }, tests
   end
 
@@ -242,19 +259,16 @@ class ConfiguratorBuilder
     paths = in_hash[:collection_paths_source] + in_hash[:collection_paths_support]
 
     # Add / subtract files via :files ↳ :assembly
-    return { :collection_all_assembly => file_collection( code_patterns( paths, in_hash[:extension_assembly] ), in_hash[:files_assembly] ) }
+    return { :collection_all_assembly => file_collection( in_hash, code_patterns( paths, in_hash[:extension_assembly] ), in_hash[:files_assembly] ) }
   end
 
 
-  # Source files, less any test files that overlapping test and source paths also matched
+  # Source files, less any test files that overlapping test and source paths, or :files
+  # revisions, also matched
   def collect_source(in_hash, test_list)
-    sources = file_list( code_patterns( in_hash[:collection_paths_source], in_hash[:extension_source] ) )
-
-    mixed_in = test_list.select { |test| sources.include?( test ) }
-    exclude_tests( sources, mixed_in ) unless mixed_in.empty?
-
     # Add / subtract files via :files ↳ :source
-    return { :collection_all_source => @file_path_collection_utils.revise_filelist( sources, in_hash[:files_source] ) }
+    sources = file_collection( in_hash, code_patterns( in_hash[:collection_paths_source], in_hash[:extension_source] ), in_hash[:files_source] )
+    return { :collection_all_source => without_tests( sources, test_list ) }
   end
 
 
@@ -262,12 +276,12 @@ class ConfiguratorBuilder
     paths = in_hash[:collection_paths_test] + in_hash[:collection_paths_support] + in_hash[:collection_paths_include]
 
     # Add / subtract files via :files ↳ :include
-    return { :collection_all_headers => file_collection( code_patterns( paths, in_hash[:extension_header] ), in_hash[:files_include] ) }
+    return { :collection_all_headers => file_collection( in_hash, code_patterns( paths, in_hash[:extension_header] ), in_hash[:files_include] ) }
   end
 
 
   # Source files, plus CException's when exceptions are in use and assembly files when the
-  # release build assembles
+  # release build assembles, less any test file. Source collection already warned of those.
   def collect_release_build_input(in_hash)
     assembly = in_hash[:release_build_use_assembly]
     vendor   = in_hash[:project_use_exceptions] ? [in_hash[:project_build_vendor_cexception_path]] : []
@@ -275,7 +289,7 @@ class ConfiguratorBuilder
 
     # Add / subtract files via :files ↳ :source & :files ↳ :assembly
     revisions = in_hash[:files_source] + (assembly ? in_hash[:files_assembly] : [])
-    return { :collection_release_build_input => file_collection( patterns, revisions ) }
+    return { :collection_release_build_input => without_tests( file_collection( in_hash, patterns, revisions ), in_hash[:collection_all_tests], warn: false ) }
   end
 
 
@@ -285,7 +299,7 @@ class ConfiguratorBuilder
     paths    = in_hash[:collection_paths_test] + in_hash[:collection_paths_support] + in_hash[:collection_paths_source]
     patterns = vendor_patterns( test_vendor_paths( in_hash ) ) + code_patterns( paths, *code_extensions( in_hash, assembly ) )
 
-    return { :collection_existing_test_build_input => file_collection( patterns, test_build_revisions( in_hash, assembly ) ) }
+    return { :collection_existing_test_build_input => file_collection( in_hash, patterns, test_build_revisions( in_hash, assembly ) ) }
   end
 
 
@@ -306,7 +320,7 @@ class ConfiguratorBuilder
     patterns   = code_patterns( in_hash[:collection_paths_support], *extensions )
 
     # Add / subtract files via :files ↳ :support
-    sources = file_collection( patterns, in_hash[:files_support] ).to_a
+    sources = file_collection( in_hash, patterns, in_hash[:files_support] ).to_a
     objects = sources.map { |file| File.basename( file ).ext( in_hash[:extension_object].primary ) }
 
     return { :collection_all_support => sources, :collection_test_fixture_extra_link_objects => objects }
@@ -325,6 +339,11 @@ class ConfiguratorBuilder
 
   private
 
+  # A relative release name is below the release build root, and an absolute one names itself
+  def release_place(root, name)
+    return ProjectPaths.absolute?( name ) ? name : File.join( root, name )
+  end
+
   def flatten_section(section, value)
     case value
     when nil   then {}
@@ -443,8 +462,18 @@ class ConfiguratorBuilder
   end
 
   # Files matching `patterns`, revised by a :files list of additions and removals
-  def file_collection(patterns, revisions)
-    return @file_path_collection_utils.revise_filelist( file_list( patterns ), revisions )
+  def file_collection(in_hash, patterns, revisions)
+    return revised( in_hash, file_list( patterns ), revisions )
+  end
+
+  # A :files glob adds nothing from the build root it is based above, and no :files entry
+  # adds anything from the directories Ceedling creates
+  def revised(in_hash, list, revisions)
+    return @file_path_collection_utils.revise_filelist( list, revisions, **build_exclusions( in_hash ) )
+  end
+
+  def build_exclusions(in_hash)
+    return { exclude: [in_hash[:project_build_root]].compact, reserved: BuildRootPolicy.reserved( in_hash ) }
   end
 
   # FileList expands its patterns lazily, so they are expanded here
@@ -454,12 +483,13 @@ class ConfiguratorBuilder
     return list.resolve()
   end
 
-  def exclude_tests(sources, tests)
-    sources.exclude( *tests )
-    @loginator.log(
-      "Test file paths and source file paths overlap -- test files have been filtered out of the source file collection",
-      Verbosity::COMPLAIN
-    )
+  # `files` less any of `tests`, compared as collected, warning of any
+  def without_tests(files, tests, warn: true)
+    mixed_in = files.to_a & tests.to_a
+    return files if mixed_in.empty?
+
+    @loginator.log( 'Test file paths and source file paths overlap -- test files have been filtered out of the source file collection', Verbosity::COMPLAIN ) if warn
+    return @file_wrapper.instantiate_file_list_literal( files.to_a - mixed_in ).resolve()
   end
 
 end

data/lib/ceedling/config/configurator_paths_validator.rb

@@ -0,0 +1,179 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+require 'ceedling/constants'
+require 'ceedling/filesystem/file_path_utils'  # for glob handling class methods
+require 'ceedling/filesystem/project_paths'
+require 'ceedling/config/build_root_policy'
+
+# Checks the paths a project file names against the filesystem: each :paths and :files
+# entry, and paths named singly
+class ConfiguratorPathsValidator
+
+  constructor :config_walkinator, :file_wrapper, :loginator, :reportinator
+
+  # Walk into config hash. verify existence of path(s) at given key depth.
+  # Paths are either full simple paths or a simple portion of a path up to a glob.
+  def validate_path_list(config, *keys)
+    list, depth = @config_walkinator.fetch_value( *keys, hash:config )
+    return false if list.nil?
+
+    # Trimming add/subtract notation and glob specifiers leaves nothing of a path that
+    # begins with a glob, so there is nothing to check
+    missing = checked_bases( list ).reject { |path| path.empty? or @file_wrapper.exist?( path ) }
+
+    walk = @reportinator.generate_config_walk( keys, depth )
+    missing.each { |path| log_error( "Config path #{walk} => '#{path}' does not exist in the filesystem." ) }
+
+    return missing.empty?
+  end
+
+
+  # Validate :paths entries, exercising each entry as Ceedling directory glob (variation of Ruby glob)
+  def validate_paths_entries(config, key)
+    return validate_entries( config, :paths, key ) { |entry, walk, build_root| valid_paths_entry?( entry, walk, build_root ) }
+  end
+
+
+  # Validate :files entries, exercising each entry as FileList glob
+  def validate_files_entries(config, key)
+    return validate_entries( config, :files, key ) { |entry, walk, build_root| valid_files_entry?( entry, walk, build_root ) }
+  end
+
+
+  # A build root of its own, warning of each :paths and :files entry within it (BuildRootPolicy)
+  def validate_build_root(config)
+    root    = config[:project][:build_root].to_s
+    problem = BuildRootPolicy.problem( root )
+    log_error( BuildRootPolicy.message( root, problem ) ) unless problem.nil?
+    return false unless problem.nil?
+
+    BuildRootPolicy.warnings( root, config ) { |keys| @reportinator.generate_config_walk( keys ) }.each { |warning| log_complaint( warning ) }
+    return true
+  end
+
+
+  # Simple path verification
+  def validate_filepath_simple(path, *keys)
+    return true if @file_wrapper.exist?( path )
+
+    walk = @reportinator.generate_config_walk( keys, keys.size )
+    log_error( "Config path '#{path}' associated with #{walk} does not exist in the filesystem." )
+    return false
+  end
+
+  ### Private ###
+
+  private
+
+  # Each entry of one :paths or :files list, usable and passing `check`
+  def validate_entries(config, section, key)
+    list, _ = @config_walkinator.fetch_value( section, key, hash:config )
+    return false if list.nil?
+
+    walk       = @reportinator.generate_config_walk( [section, key] )
+    build_root = config.dig( :project, :build_root )
+    return list.map { |entry| usable_entry?( entry, walk ) && yield( entry, walk, build_root ) }.all?
+  end
+
+  # Each additive entry's path up to its first glob. An entry YAML read as something other
+  # than a string, and a `-:` entry, which may name nothing, are left to the entries validation.
+  def checked_bases(list)
+    return list.grep( String ).select { |path| FilePathUtils.add_path?( path ) }.map { |path| FilePathUtils::no_decorators( path ) }
+  end
+
+  # A :paths or :files entry that names no path, or wraps its path in quotes, usually
+  # quotes only the path after its decoration. YAML keeps those quote marks as part of
+  # the value, so the hint points at quoting the whole entry. YAML also reads an unquoted
+  # decoration with nothing after it (`- -:`) as a one-key mapping rather than a string.
+  ENTRY_QUOTING_HINT = 'Quote the whole entry, decoration included (e.g. "-:path/to/file.c"), ' +
+                       'not only the path after its +: or -: decoration.'
+
+  def usable_entry?(entry, walk)
+    path = entry.is_a?( String ) ? FilePathUtils::no_aggregation_decorators( entry ) : ''
+
+    problem =
+      if !entry.nil? and !entry.is_a?( String ) then "is not a path (YAML read it as a #{entry.class})"
+      elsif path.empty? then 'names no path'
+      elsif path.start_with?( '"', "'" ) then 'wraps its path in quotes'
+      end
+    return true if problem.nil?
+
+    log_error( "#{walk} => '#{entry}' #{problem}" )
+    log_error( ENTRY_QUOTING_HINT )
+    return false
+  end
+
+  # A path naming a file is ignored with a warning. Any other entry must yield directories,
+  # except a subdirectories glob of a directory that has none, and a `-:` entry.
+  def valid_paths_entry?(entry, walk, build_root)
+    path = FilePathUtils::no_aggregation_decorators( entry )
+
+    if @file_wrapper.exist?( path ) and !@file_wrapper.directory?( path )
+      log_complaint( "#{walk} => '#{path}' is a filepath and will be ignored (FYI :paths is directory-oriented while :files is file-oriented)" )
+      return true
+    end
+
+    return valid_subtraction?( entry, path, walk, build_root ) unless FilePathUtils.add_path?( entry )
+    return true if globbed_directories?( path ) or path =~ /\/\*{1,2}$/
+
+    log_error( "#{walk} => '#{path}' yielded no directories -- matching glob is malformed or directories do not exist" )
+    return false
+  end
+
+  # A `-:` entry leaves out what it names, or warns of naming nothing. A subdirectories glob
+  # names its directory too.
+  def valid_subtraction?(entry, path, walk, build_root)
+    named = path.match?( %r{/\*{1,2}\z} ) ? @file_wrapper.exist?( FilePathUtils.no_decorators( entry ) ) : @file_wrapper.exist?( path )
+    return true if named or globbed_directories?( path )
+
+    return subtracts_nothing( entry, walk, build_root, 'directory' )
+  end
+
+  # A `-:` entry names what a build leaves out, so naming nothing is no error. Below the build
+  # root, where nothing exists before a first build, it passes without a word.
+  def subtracts_nothing(entry, walk, build_root, kind)
+    unless build_root and ProjectPaths.contains?( build_root, FilePathUtils.no_decorators( entry ) )
+      log_complaint( "#{walk} => '#{entry.strip}' leaves out nothing; no #{kind} matches it" )
+    end
+
+    return true
+  end
+
+  # #104 -- FilePathUtils.subdirectory_glob escapes literal brackets in the path, so they
+  # are matched rather than read as a glob character class
+  def globbed_directories?(path)
+    return @file_wrapper.directory_listing( FilePathUtils.subdirectory_glob( path ) ).any? { |entry| @file_wrapper.directory?( entry ) }
+  end
+
+  # A path naming a directory is ignored with a warning. Any other entry must yield files,
+  # except a `-:` entry.
+  def valid_files_entry?(entry, walk, build_root)
+    path = FilePathUtils::no_aggregation_decorators( entry )
+
+    if @file_wrapper.exist?( path ) and @file_wrapper.directory?( path )
+      log_complaint( "#{walk} => '#{path}' is a directory path and will be ignored (FYI :files is file-oriented while :paths is directory-oriented)" )
+      return true
+    end
+
+    # #104 -- literal brackets are escaped so they are matched rather than read as a glob
+    return true unless @file_wrapper.instantiate_file_list( FilePathUtils.escape_glob_brackets( path ) ).size.zero?
+    return subtracts_nothing( entry, walk, build_root, 'file' ) unless FilePathUtils.add_path?( entry )
+
+    log_error( "#{walk} => '#{path}' yielded no files -- matching glob is malformed or files do not exist" )
+    return false
+  end
+
+  def log_error(message)
+    @loginator.log( message, Verbosity::ERRORS )
+  end
+
+  def log_complaint(message)
+    @loginator.log( message, Verbosity::COMPLAIN )
+  end
+
+end

data/lib/ceedling/config/configurator_plugins.rb

@@ -6,7 +6,7 @@
 # =========================================================================
 
 require 'ceedling/constants'
-require 'ceedling/file_path_utils'
+require 'ceedling/filesystem/file_path_utils'
 
 class ConfiguratorPlugins
 

data/lib/ceedling/config/configurator_setup.rb

@@ -12,12 +12,13 @@ require 'ceedling/config/line_marker_suppressors'
 
 class ConfiguratorSetup
 
-  constructor :configurator_builder, :configurator_validator, :loginator, :reportinator, :file_wrapper,
+  constructor :configurator_builder, :configurator_validator, :configurator_paths_validator, :loginator, :reportinator, :file_wrapper,
               :system_wrapper, :tool_executor
 
   # Path collections, in order, since each builds on those before it
   PATH_COLLECTIONS = [
     :expand_all_path_globs,
+    :collect_mirror_roots,
     :collect_vendor_paths,
     :collect_source_and_include_paths,
     :collect_source_include_vendor_paths,
@@ -72,17 +73,6 @@ class ConfiguratorSetup
     end
   end
 
-  # A vendor destination must be a directory, and the marker file inside it (unity.c,
-  # cmock.c, CException.c) a plain file. An interrupted run, or a second Ceedling run racing
-  # this one, can leave either as the wrong type, and the copy would then fail on every
-  # later build. The whole destination is cleared, so the copy recreates it.
-  def heal_vendor_path(path, marker_file)
-    return unless corrupted_vendor_path?( path, marker_file )
-
-    @loginator.log( "Removing corrupted vendor path (unexpected file/directory type): #{path}", Verbosity::COMPLAIN, LogLabels::NOTICE )
-    @file_wrapper.rm_rf( path )
-  end
-
   # Brings build/vendor up to date with the frameworks and support files a build needs. Only
   # a build does this, so a command that only reads the project leaves a concurrent build's
   # files alone. A file that already matches its source is not written, and one that differs,
@@ -90,8 +80,7 @@ class ConfiguratorSetup
   #
   # A release build needs only CException, and that only when exceptions are enabled.
   def vendor_frameworks_and_support_files(ceedling_lib_path, flattened_config, test_build:, release_build:)
-    frameworks_for_build( flattened_config, test_build: test_build, release_build: release_build ).each do |source, destination, marker_file|
-      heal_vendor_path( destination, marker_file )
+    frameworks_for_build( flattened_config, test_build: test_build, release_build: release_build ).each do |source, destination|
       @file_wrapper.sync_tree( source, destination )
     end
 
@@ -130,6 +119,11 @@ class ConfiguratorSetup
   end
 
 
+  def validate_build_root(config)
+    return @configurator_paths_validator.validate_build_root( config )
+  end
+
+
   # Every check runs, so every problem is reported
   def validate_paths(config)
     valid  = validate_simple_paths( config[:cmock][:unity_helper_path], :cmock, :unity_helper_path )
@@ -308,23 +302,16 @@ class ConfiguratorSetup
 
   private
 
-  def corrupted_vendor_path?(path, marker_file)
-    marker = File.join( path, marker_file )
-
-    return ( @file_wrapper.exist?( path ) && !@file_wrapper.directory?( path ) ) ||
-           ( @file_wrapper.exist?( marker ) && @file_wrapper.directory?( marker ) )
-  end
-
-  # Each framework a build uses, as [vendored source, build destination, marker file]
+  # Each framework a build uses, as [vendored source, build destination]
   def vendored_frameworks(config)
-    frameworks = [ [File.join( config[:unity_vendor_path], UNITY_LIB_PATH ), config[:project_build_vendor_unity_path], UNITY_C_FILE] ]
+    frameworks = [ [File.join( config[:unity_vendor_path], UNITY_LIB_PATH ), config[:project_build_vendor_unity_path]] ]
 
     if config[:project_use_mocks]
-      frameworks << [File.join( config[:cmock_vendor_path], CMOCK_LIB_PATH ), config[:project_build_vendor_cmock_path], CMOCK_C_FILE]
+      frameworks << [File.join( config[:cmock_vendor_path], CMOCK_LIB_PATH ), config[:project_build_vendor_cmock_path]]
     end
 
     if config[:project_use_exceptions]
-      frameworks << [File.join( config[:cexception_vendor_path], CEXCEPTION_LIB_PATH ), config[:project_build_vendor_cexception_path], CEXCEPTION_C_FILE]
+      frameworks << [File.join( config[:cexception_vendor_path], CEXCEPTION_LIB_PATH ), config[:project_build_vendor_cexception_path]]
     end
 
     return frameworks
@@ -332,7 +319,7 @@ class ConfiguratorSetup
 
   def frameworks_for_build(config, test_build:, release_build:)
     return vendored_frameworks( config ) if test_build
-    return vendored_frameworks( config ).select { |_, _, marker_file| marker_file == CEXCEPTION_C_FILE } if release_build
+    return vendored_frameworks( config ).select { |_, destination| destination == config[:project_build_vendor_cexception_path] } if release_build
 
     return []
   end
@@ -353,13 +340,13 @@ class ConfiguratorSetup
   end
 
   def validate_simple_paths(paths, *keys)
-    return paths.map { |path| @configurator_validator.validate_filepath_simple( path, *keys ) }.all?
+    return paths.map { |path| @configurator_paths_validator.validate_filepath_simple( path, *keys ) }.all?
   end
 
   # Each entry of :paths or :files must exist and yield what its section expects
   def validate_path_section(config, section, entries_validation)
     return config[section].keys.sort.map do |key|
-      @configurator_validator.validate_path_list( config, section, key ) & @configurator_validator.public_send( entries_validation, config, key )
+      @configurator_paths_validator.validate_path_list( config, section, key ) & @configurator_paths_validator.public_send( entries_validation, config, key )
     end.all?
   end
 

data/lib/ceedling/config/configurator_validator.rb

@@ -6,13 +6,12 @@
 # =========================================================================
 
 require 'ceedling/constants'
-require 'ceedling/file_path_utils'  # for glob handling class methods
 require 'ceedling/config/config_matchinator'
 
 
 class ConfiguratorValidator
 
-  constructor :config_walkinator, :file_wrapper, :loginator, :reportinator, :tool_validator
+  constructor :config_walkinator, :loginator, :reportinator, :tool_validator
 
   # Walk into config hash verify existence of data at key depth
   def exists?(config, *keys)
@@ -23,54 +22,6 @@ class ConfiguratorValidator
     return false
   end
 
-  # Walk into config hash. verify existence of path(s) at given key depth.
-  # Paths are either full simple paths or a simple portion of a path up to a glob.
-  def validate_path_list(config, *keys)
-    list, depth = @config_walkinator.fetch_value( *keys, hash:config )
-    return false if list.nil?
-
-    # Trimming add/subtract notation and glob specifiers leaves nothing of a path that
-    # begins with a glob, so there is nothing to check. An entry YAML read as something
-    # other than a string is left to the entries validation, which reports it.
-    paths   = list.grep( String ).map { |path| FilePathUtils::no_decorators( path ) }
-    missing = paths.reject { |path| path.empty? or @file_wrapper.exist?( path ) }
-
-    walk = @reportinator.generate_config_walk( keys, depth )
-    missing.each { |path| log_error( "Config path #{walk} => '#{path}' does not exist in the filesystem." ) }
-
-    return missing.empty?
-  end
-
-
-  # Validate :paths entries, exercising each entry as Ceedling directory glob (variation of Ruby glob)
-  def validate_paths_entries(config, key)
-    list, _ = @config_walkinator.fetch_value( :paths, key, hash:config )
-    return false if list.nil?
-
-    walk = @reportinator.generate_config_walk( [:paths, key] )
-    return list.map { |path| usable_entry?( path, walk ) && valid_paths_entry?( FilePathUtils::no_aggregation_decorators( path ), walk ) }.all?
-  end
-
-
-  # Validate :files entries, exercising each entry as FileList glob
-  def validate_files_entries(config, key)
-    list, _ = @config_walkinator.fetch_value( :files, key, hash:config )
-    return false if list.nil?
-
-    walk = @reportinator.generate_config_walk( [:files, key] )
-    return list.map { |path| usable_entry?( path, walk ) && valid_files_entry?( FilePathUtils::no_aggregation_decorators( path ), walk ) }.all?
-  end
-
-
-  # Simple path verification
-  def validate_filepath_simple(path, *keys)
-    return true if @file_wrapper.exist?( path )
-
-    walk = @reportinator.generate_config_walk( keys, keys.size )
-    log_error( "Config path '#{path}' associated with #{walk} does not exist in the filesystem." )
-    return false
-  end
-
   def validate_tool(config:, key:, respect_optional:true)
     # Get tool
     walk = [:tools, key]
@@ -102,62 +53,6 @@ class ConfiguratorValidator
 
   private
 
-  # A :paths or :files entry that names no path, or wraps its path in quotes, usually
-  # quotes only the path after its decoration. YAML keeps those quote marks as part of
-  # the value, so the hint points at quoting the whole entry. YAML also reads an unquoted
-  # decoration with nothing after it (`- -:`) as a one-key mapping rather than a string.
-  ENTRY_QUOTING_HINT = 'Quote the whole entry, decoration included (e.g. "-:path/to/file.c"), ' +
-                       'not only the path after its +: or -: decoration.'
-
-  def usable_entry?(entry, walk)
-    path = entry.is_a?( String ) ? FilePathUtils::no_aggregation_decorators( entry ) : ''
-
-    problem =
-      if !entry.nil? and !entry.is_a?( String ) then "is not a path (YAML read it as a #{entry.class})"
-      elsif path.empty? then 'names no path'
-      elsif path.start_with?( '"', "'" ) then 'wraps its path in quotes'
-      end
-    return true if problem.nil?
-
-    log_error( "#{walk} => '#{entry}' #{problem}" )
-    log_error( ENTRY_QUOTING_HINT )
-    return false
-  end
-
-  # A path naming a file is ignored with a warning. Any other entry must yield directories,
-  # except a subdirectories glob of a directory that has none.
-  def valid_paths_entry?(path, walk)
-    if @file_wrapper.exist?( path ) and !@file_wrapper.directory?( path )
-      log_complaint( "#{walk} => '#{path}' is a filepath and will be ignored (FYI :paths is directory-oriented while :files is file-oriented)" )
-      return true
-    end
-
-    return true if globbed_directories?( path ) or path =~ /\/\*{1,2}$/
-
-    log_error( "#{walk} => '#{path}' yielded no directories -- matching glob is malformed or directories do not exist" )
-    return false
-  end
-
-  # #104 -- FilePathUtils.subdirectory_glob escapes literal brackets in the path, so they
-  # are matched rather than read as a glob character class
-  def globbed_directories?(path)
-    return @file_wrapper.directory_listing( FilePathUtils.subdirectory_glob( path ) ).any? { |entry| @file_wrapper.directory?( entry ) }
-  end
-
-  # A path naming a directory is ignored with a warning. Any other entry must yield files.
-  def valid_files_entry?(path, walk)
-    if @file_wrapper.exist?( path ) and @file_wrapper.directory?( path )
-      log_complaint( "#{walk} => '#{path}' is a directory path and will be ignored (FYI :files is file-oriented while :paths is directory-oriented)" )
-      return true
-    end
-
-    # #104 -- literal brackets are escaped so they are matched rather than read as a glob
-    return true unless @file_wrapper.instantiate_file_list( FilePathUtils.escape_glob_brackets( path ) ).size.zero?
-
-    log_error( "#{walk} => '#{path}' yielded no files -- matching glob is malformed or files do not exist" )
-    return false
-  end
-
   def validate_regex_matcher(matcher)
     Regexp.compile( matcher[1..-2] )
   rescue RegexpError => ex
@@ -168,8 +63,4 @@ class ConfiguratorValidator
     @loginator.log( message, Verbosity::ERRORS )
   end
 
-  def log_complaint(message)
-    @loginator.log( message, Verbosity::COMPLAIN )
-  end
-
 end

data/lib/ceedling/defaults.rb

@@ -7,7 +7,7 @@
 
 require 'ceedling/constants'
 require 'ceedling/system_wrapper'
-require 'ceedling/file_path_utils'
+require 'ceedling/filesystem/file_path_utils'
 
 # Assign a default value for system testing where CEEDLING_APPCFG may not be present
 # TODO: Create code config & test structure that does not internalize a test path like this
@@ -58,14 +58,14 @@ DEFAULT_TEST_LINKER_TOOL = {
   }
 
 DEFAULT_TEST_FIXTURE_TOOL = {
-  :executable => '${1}'.freeze, # Unity test runner executable
+  :executable => '"${1}"'.freeze, # Unity test runner executable, quoted as a path
   :name => 'default_test_fixture'.freeze,
   :optional => false.freeze,
   :arguments => [].freeze
   }
 
 DEFAULT_TEST_FIXTURE_SIMPLE_BACKTRACE_TOOL = {
-  :executable => '${1}'.freeze, # Unity test runner executable
+  :executable => '"${1}"'.freeze, # Unity test runner executable, quoted as a path
   :name => 'default_test_fixture_simple_backtrace'.freeze,
   :optional => false.freeze,
   :arguments => [
@@ -204,7 +204,7 @@ DEFAULT_TEST_BACKTRACE_GDB_TOOL = {
     '--eval-command run'.freeze,
     "--command \"${1}\"".freeze, # Debug script file to run
     '--args'.freeze,
-    '${2}'.freeze,               # Test executable
+    '"${2}"'.freeze,             # Test executable, quoted as a path
     # Test case matching flag and (quoted) value, fully composed by the caller as
     # either `-n "<exact name>"` or `-f "<base name>"` -- see
     # GeneratorTestResultsBacktrace#unity_filter_arg.