ceedling 1.2.1 → 1.2.2

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

@@ -7,15 +7,22 @@
 
 require 'rubygems'
 require 'rake' # for adding ext() method to string
+require 'set'
 require 'ceedling/exceptions'
-require 'ceedling/path_matcher'
-require 'ceedling/path_mirror'
-require 'ceedling/file_path_utils'
+require 'ceedling/filesystem/path_matcher'
+require 'ceedling/filesystem/path_mirror'
+require 'ceedling/filesystem/file_path_utils'
+require 'ceedling/filesystem/project_paths'
+require 'ceedling/filesystem/build_subpath'
 
 class FileFinder
 
   constructor :configurator, :file_finder_helper, :file_path_utils, :file_wrapper, :yaml_wrapper
 
+  def setup
+    @test_names_lock = Mutex.new
+  end
+
 
   # `collection`, when given, is a caller's own already-ordered, per-test header list
   # (see IncludePathinator#ordered_header_files) reflecting that one test's real search-path
@@ -59,7 +66,7 @@ class FileFinder
     source = find_header_input_for_mock(mock, collection: collection, complain: complain)
     return [nil, nil] if source.nil?
 
-    subdir = PathMirror.relative_subdir(source, @configurator.paths_test + @configurator.paths_support + @configurator.paths_include)
+    subdir = PathMirror.relative_subdir_from_clean_roots( source, @configurator.collection_mirror_roots_headers )
     return [source, subdir]
   end
 
@@ -72,11 +79,10 @@ class FileFinder
   # compilation step downstream to catch a wrong guess the way there is for a header
   # or source file resolved during a build.
   #
-  # A task name has no file of its own to anchor a `..` against, unlike an #include or
-  # TEST_SOURCE_FILE() entry -- resolving with no anchor surfaces that as a specific,
-  # named error rather than falling through to a generic file-not-found further down.
+  # A task name is relative to the working directory, as every collected path is, so a
+  # leading `..` names a test outside the project.
   def find_test_file_from_name(name)
-    name = PathMatcher.resolve_relative(name)
+    name = PathMatcher.resolve_relative(name, anchor: '')
     return find_first_candidate(name, @configurator.extension_source, @configurator.collection_all_tests, :error, strict: true)
   end
 
@@ -107,9 +113,8 @@ class FileFinder
     #       Some legacy files can include naming conventions like <name>.##.<ext> for versioning.
     #       If we use .ext() below we'll clobber the dotted portion of the filename
 
-    # Generated test runners -- a flat test's own runner is searched for in the shared flat
-    # runners directory; only a nested test's own mirrored subdirectory scopes the search
-    # further, so two same-named tests' runners are never mistaken for each other
+    # Generated test runners -- searched for in the runners directory of this test's name,
+    # so two same-named tests' runners are never mistaken for each other
     if (!release) and
        (source_file =~ /^#{Regexp.escape(@configurator.project_test_file_prefix)}.+#{Regexp.escape(@configurator.test_runner_file_suffix)}$/)
       _source_file = source_file + EXTENSION_CORE_SOURCE
@@ -140,9 +145,7 @@ class FileFinder
       found_file =
         @file_finder_helper.find_file_in_collection(
           _source_file,
-          @file_wrapper.directory_listing(
-            File.join(mocks_root, ('**/*' + EXTENSION_CORE_SOURCE))
-          ),
+          own_generated_files( @configurator.cmock_mock_path, test_context ),
           complain)
 
     # Generated partials -- same per-test scoping rationale as mocks, above
@@ -157,10 +160,7 @@ class FileFinder
       _source_file = source_file + EXTENSION_CORE_SOURCE
       _source_file = File.join( subdir, _source_file ) unless subdir.empty?
 
-      collection =
-        @file_wrapper.directory_listing(
-          File.join(partials_root, ('**/*' + EXTENSION_CORE_SOURCE))
-        )
+      collection = own_generated_files( @configurator.project_test_partials_path, test_context )
 
       # Ambiguity is detected here rather than rescued from the matching below. One
       # matching implementation stays in force, and the message is composed from the
@@ -180,12 +180,11 @@ class FileFinder
           @configurator.collection_existing_test_build_input,
           complain)
 
-    # The test file's own object, resolving back to its own source -- go directly by this
-    # object's own test identity rather than searching the whole project's test collection
-    # by bare basename, which is exactly the kind of query that's ambiguous the moment
-    # another same-named test exists elsewhere
+    # The test file's own object resolves to the test it names. A name is the test's path,
+    # so the lookup is exact. Searching by name instead is ambiguous wherever one test's
+    # name ends another test's path.
     elsif (!release) and !test_context.empty? and (source_file == File.basename( test_context ))
-      found_file = find_test_file_from_name( test_context )
+      found_file = test_files_by_name[test_context]
 
     end
 
@@ -202,37 +201,16 @@ class FileFinder
     # We save the existence handling until the end.
     #
 
-    # A module-under-test or release source's object mirrors that source's own subdirectory
-    # below whichever configured root it came from -- recovering that mirrored subdirectory
-    # here lets the query go straight to the matching source, rather than a bare basename
-    # that's ambiguous the moment another same-named source exists elsewhere.
-    query_file = mirrored_query(filepath, release: release, test: test, context: context)
+    # A module-under-test or release object sits at its source's own path below its build
+    # root, so that path recovers the one source, rather than a bare basename that is
+    # ambiguous the moment another same-named source exists elsewhere.
+    query_file, exact = mirrored_query(filepath, release: release, test: test, context: context)
 
-    # Assembly files for release build
-    if release and @configurator.release_build_use_assembly
-      found_file = try_extensions(query_file, @configurator.extension_assembly, @configurator.collection_release_build_input)
-
-    # Assembly files for test build
-    elsif (!release) and @configurator.test_build_use_assembly
-      found_file = try_extensions(query_file, @configurator.extension_assembly, @configurator.collection_existing_test_build_input)
-    end
-
-    if !found_file.nil?
-        return found_file
-    end
-
-    # Release build C files
-    if release
-      found_file = try_extensions(query_file, @configurator.extension_source, @configurator.collection_release_build_input)
-
-    # Test build C files
-    else
-      found_file = try_extensions(query_file, @configurator.extension_source, @configurator.collection_existing_test_build_input)
-    end
+    found_file = find_compiled_input( query_file, release: release, exact: exact )
 
     if found_file.nil?
-      # Every name actually attempted above, laid out for the reader in the same order they
-      # were tried, so a missing-file complaint names every filename ceedling went looking for.
+      # Every name actually attempted, in the order tried, so a missing-file complaint
+      # names every filename ceedling went looking for.
       tried = @configurator.extension_source.map { |ext| query_file + ext }
       tried += @configurator.extension_assembly.map { |ext| query_file + ext } if @configurator.release_build_use_assembly
       @file_finder_helper.handle_missing_file(tried.join(' or '), complain)
@@ -265,6 +243,24 @@ class FileFinder
 
   private
 
+  # A C or assembly build input for `query`, assembly first where the build uses it. An
+  # exact query is the file's own path, matched as such before any tail match.
+  def find_compiled_input(query, release:, exact:)
+    collection = release ? @configurator.collection_release_build_input : @configurator.collection_existing_test_build_input
+
+    compiled_extensions( release ).each do |extension|
+      found = (exact && exact_file( query, extension, collection )) || try_extensions( query, extension, collection )
+      return found unless found.nil?
+    end
+
+    return nil
+  end
+
+  def compiled_extensions(release)
+    assembly = release ? @configurator.release_build_use_assembly : @configurator.test_build_use_assembly
+    return assembly ? [@configurator.extension_assembly, @configurator.extension_source] : [@configurator.extension_source]
+  end
+
   # Translates a generated-Partial ambiguity into the test author's own terms. The query
   # here is a generated filename under a build directory, neither of which the author
   # typed, so reporting them offers nothing to act on. Candidates render as extensionless
@@ -299,74 +295,133 @@ class FileFinder
     raise CeedlingException.new( message )
   end
 
-  # A test object's build directory identity mirrors the configured test root a source
-  # file lives under (e.g. `unit/test_foo` for `test/unit/test_foo.c`, plain `test_foo` for
-  # a flat file). Recovering that identity from a build artifact's own path lets a lookup
-  # go straight to the one test it belongs to, rather than searching the whole project by
-  # bare basename -- exactly the query shape that's ambiguous when another same-named test
-  # exists elsewhere.
+  # A test object's build directory is its test's name, the test's path from the project
+  # root (e.g. `test/unit/test_foo` for `test/unit/test_foo.c`). Recovering that name from
+  # a build artifact's own path lets a lookup go straight to the one test it belongs to,
+  # rather than searching the whole project by bare basename -- exactly the query shape
+  # that's ambiguous when another same-named test exists elsewhere.
   #
   # A filepath that isn't under the test build root at all (a source-tree-relative query
   # from an #include or TEST_SOURCE_FILE(), rather than a build artifact's own path) has no
   # test identity to recover -- empty string, never a directory name that could coincidentally
   # match some unrelated file's own basename.
+  #
+  # A test's build directory also holds its objects at their sources' own paths, so the
+  # name is the longest one of a known test that the directory begins with.
   def test_context_of(filepath)
-    dir  = File.dirname( filepath )
-    root = @configurator.project_test_build_output_path
-    return dir.start_with?( root + '/' ) ? dir[(root.length + 1)..] : ''
+    subdir = ProjectPaths.subdir_below( @configurator.project_test_build_output_path, File.dirname( filepath ) )
+    return '' if subdir.nil?
+
+    parts = subdir.split( '/' )
+    parts.length.downto( 1 ) do |count|
+      name = parts.first( count ).join( '/' )
+      return name if test_files_by_name.key?( name )
+    end
+
+    return ''
   end
 
-  # A flat test's own runner lives in the shared flat runners directory; only a nested
-  # test's own mirrored subdirectory (excluding its own basename) narrows the search
-  # further -- mirroring FilePathUtils#form_test_runners_path's own directory-forming rule.
-  # Takes the test identity already recovered by the caller rather than a raw filepath, so
-  # it isn't independently re-deriving what the caller already has in hand.
+  # A test's runner lives where FilePathUtils#form_test_runners_path puts it. Takes the test
+  # identity the caller already recovered rather than a raw filepath.
   def runner_scope_dir(test_context)
-    subdir = File.dirname( test_context )
-    root   = @configurator.project_test_runners_path
-    return subdir == '.' ? root : File.join(root, subdir)
+    return @file_path_utils.form_test_runners_path( test_context )
   end
 
-  # A release or module-under-test object's own path mirrors its source's subdirectory
-  # below whichever configured root it came from, rooted at the release build output path
-  # or (given the current test's identity) that test's own build path. Recovering that
-  # mirrored subdirectory and combining it with the bare basename recreates a query that
-  # identifies the same one source PathMirror originally mirrored it from.
+  # Every test file by its name. Names are paths, and a build stops before its first lookup
+  # if two tests in it share one. Built once, on first use, since build threads share this
+  # finder.
+  def test_files_by_name
+    @test_names_lock.synchronize do
+      @test_files_by_name ||= @configurator.collection_all_tests.to_h { |test| [@file_path_utils.form_test_name( test ), test.to_s] }
+    end
+  end
+
+  # For each test's name, the names of the tests nested beneath it (`test/test_foo/test_bar`
+  # beneath `test/test_foo`)
+  def nested_test_names
+    names = test_files_by_name.keys
+    @test_names_lock.synchronize do
+      @nested_test_names ||= nest_names( names )
+    end
+  end
+
+  # Files each name under every other name that is one of its parent directories
+  def nest_names(names)
+    known  = names.to_set
+    nested = Hash.new { |hash, name| hash[name] = [] }
+
+    names.each do |name|
+      parts = name.split( '/' )
+      (1...parts.length).each do |count|
+        parent = parts.first( count ).join( '/' )
+        nested[parent] << name if known.include?( parent )
+      end
+    end
+
+    return nested
+  end
+
+  # A test's generated mocks or Partials, beneath its own directory below `base`. A test
+  # whose name continues this one's (`test/test_foo/test_bar` after `test/test_foo`) has its
+  # directory nested here, and the files in it are that test's own.
+  def own_generated_files(base, test_context)
+    listing = @file_wrapper.directory_listing( FilePathUtils.glob( File.join( base, test_context ), '**/*' + EXTENSION_CORE_SOURCE ) )
+    nested  = nested_test_names.fetch( test_context, [] ).map { |name| File.join( base, name ) + '/' }
+    return listing if nested.empty?
+
+    return listing.reject { |file| nested.any? { |dir| file.start_with?( dir ) } }
+  end
+
+  # The query for the source of a release or module-under-test object, and whether it is
+  # exact. Such an object sits at its source's own path below the release output root, or
+  # below the build path of the test it belongs to, so decoding that path names the source.
   #
-  # A filepath that isn't under the project's build root at all is a source-tree-relative
-  # query in its own right -- straight from an #include or a TEST_SOURCE_FILE() directive,
-  # say. Such a path keeps whatever disambiguating path it carries rather than being
-  # collapsed to a bare basename, reduced to its own namespace below a configured include
-  # root when one contains it (see header_root_relative_query below).
+  # A filepath outside the build root is a source-tree-relative query in its own right,
+  # from an #include or a TEST_SOURCE_FILE() directive, say. It keeps whatever path it
+  # carries, reduced to its namespace below a configured include root when one contains it
+  # (see header_root_relative_query below).
   #
-  # A filepath that IS somewhere under the build root, but either belongs to a build
-  # context this method doesn't specifically know how to mirror (a plugin's own object
-  # output, e.g. build/valgrind/out/..., rather than release or test) or lacks enough to
-  # peel back a known per-test root (test build input queried without a test identity),
-  # falls back to the bare basename -- exactly what every caller has always seen for those
-  # cases.
+  # A filepath below the build root in a context this method doesn't know (a plugin's own
+  # object output, e.g. build/valgrind/out/...), or test build input queried without a test
+  # identity, falls back to the bare basename.
   def mirrored_query(filepath, release:, test:, context:)
-    dir = File.dirname(filepath)
-    build_root = @configurator.project_build_root
+    return [source_tree_query( filepath ), false] unless ProjectPaths.contains?( @configurator.project_build_root, filepath )
 
-    unless dir == build_root || dir.start_with?(build_root + '/')
-      query = header_root_relative_query( filepath )
-      return query.nil? ? filepath.ext('') : query
-    end
+    root     = placement_root( release, test, context )
+    subdir   = root.nil? ? nil : ProjectPaths.subdir_below( root, File.dirname( filepath ) )
+    basename = File.basename( filepath ).ext('')
+    return [basename, false] if subdir.nil? || subdir.empty?
+
+    return [File.join( BuildSubpath.decode( subdir ), basename ), true]
+  end
 
-    basename = File.basename(filepath).ext('')
+  def source_tree_query(filepath)
+    query = header_root_relative_query( filepath )
+    return query.nil? ? filepath.ext('') : query
+  end
 
-    root =
-      if release
-        @configurator.project_release_build_output_path
-      elsif test
-        @file_path_utils.form_test_build_path(test, context: context)
-      end
+  # The root a release or test object is placed below, or nil where none is known
+  def placement_root(release, test, context)
+    return @configurator.project_release_build_output_path if release
+    return nil if test.nil?
 
-    return basename if root.nil?
+    return @file_path_utils.form_test_build_path( test, context: context )
+  end
+
+  # The file of `collection` at exactly `query` plus one of `extension`'s spellings, or nil.
+  # Compared by absolute path, through an index built once per collection, since build
+  # threads share this finder.
+  def exact_file(query, extension, collection)
+    index = @test_names_lock.synchronize do
+      (@exact_indexes ||= {}.compare_by_identity)[collection] ||= collection.to_h { |file| [ProjectPaths.absolute( file ), file.to_s] }
+    end
+
+    extension.to_a.each do |ext|
+      found = index[ProjectPaths.absolute( query + ext )]
+      return found unless found.nil?
+    end
 
-    subdir = PathMirror.relative_subdir(filepath, [root])
-    return subdir.empty? ? basename : File.join(subdir, basename)
+    return nil
   end
 
   # The subdirectory a generated file's query carries, mirroring the module it belongs to.
@@ -399,9 +454,9 @@ class FileFinder
 
     return '' if dir == '.'
 
-    # Matched at a path boundary. A directory merely beginning with the build root's own
-    # name is an ordinary relative directory and still names its module.
-    return '' if dir == root || dir.start_with?( root + '/' )
+    # Compared as directories. A directory merely beginning with the build root's own name
+    # is an ordinary relative directory and still names its module.
+    return '' if ProjectPaths.contains?( root, dir )
 
     return dir
   end
@@ -415,7 +470,7 @@ class FileFinder
   # Only the root is dropped. The namespace is preserved, since that is what keeps two
   # same-basename modules apart.
   def header_root_relative_query(filepath)
-    subdir = PathMirror.relative_subdir_if_rooted( filepath, @configurator.paths_include )
+    subdir = PathMirror.relative_subdir_if_rooted_in_clean_roots( filepath, @configurator.collection_mirror_roots_include )
 
     return nil if subdir.nil?
 

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

@@ -8,12 +8,16 @@
 require 'fileutils'
 require 'ceedling/constants' # for Verbosity enumeration
 require 'ceedling/exceptions'
-require 'ceedling/path_matcher'
+require 'ceedling/filesystem/path_matcher'
 
 class FileFinderHelper
 
   constructor :loginator
 
+  def setup
+    @noticed      = []
+    @notice_mutex = Mutex.new
+  end
 
   def find_file_in_collection(filename, file_list, complain)
     found = PathMatcher.match(filename, file_list)
@@ -25,7 +29,8 @@ class FileFinderHelper
   # As `#find_file_in_collection`, but never raises on ambiguity -- a query matching
   # more than one file resolves to the first entry in `file_list`'s own order (which
   # already reflects real project path priority), with an ℹ️ NOTICE naming what else
-  # matched so the choice isn't silent.
+  # matched so the choice isn't silent. Every test that names the file makes the same
+  # choice, so a build notes it once.
   def resolve_file_in_collection(filename, file_list, complain)
     found, others = PathMatcher.resolve(filename, file_list)
     return not_found_in_collection(filename, file_list, complain) if found.nil?
@@ -34,7 +39,8 @@ class FileFinderHelper
       msg = "Multiple files matched '#{filename}' but chose '#{found}' by search-path priority. " \
             "Other candidates: #{others.join(', ')}. Add more path to '#{filename}' at its point " \
             "of reference to select a different file."
-      @loginator.log( msg, Verbosity::COMPLAIN, LogLabels::NOTICE )
+      first = @notice_mutex.synchronize { !@noticed.include?( msg ) && @noticed << msg }
+      @loginator.log( msg, Verbosity::COMPLAIN, LogLabels::NOTICE ) if first
     end
 
     return found
@@ -45,35 +51,14 @@ class FileFinderHelper
     raise "No path list provided for #{description} search" if path_list.nil?
     return pathname if path_list.include?(pathname)
 
-    # Determine the closest match by looking for matching path segments, especially paths ENDING the same
-    best_match_index = 0
-    best_match_value = 0
-    reverse_original_pieces = pathname.split(/(?:\\|\/)/).reverse
-    path_list.each_with_index do |p,i|
-      reverse_match_pieces = p.split(/(?:\\|\/)/).reverse
-      # 
-      num = reverse_original_pieces.zip(reverse_match_pieces).inject(0){|s,v| v[0] == v[1] ? s+3 : s}
-      num = reverse_original_pieces.inject(num){|s,v| reverse_match_pieces.include?(v) ? s+1 : s}
-      if num > best_match_value
-        best_match_index = i 
-        best_match_value = num 
-      end
-    end
+    # The closest match shares the most path segments, especially those ENDING the same. The
+    # first of equally close matches wins, and the first path when none shares a segment.
+    pieces = reversed_pieces( pathname )
+    scores = path_list.map { |path| match_score( pieces, reversed_pieces( path ) ) }
 
-    # If none of the options were a good match, handle to the best of our ability
-    if (best_match_value == 0) && (reverse_original_pieces.length > 0)
-      case (complain)
-        when :error
-          raise CeedlingException.new( "Found no path `#{pathname}` in #{description} search paths." ) 
-        when :warn
-          warning = "Found no path `#{pathname}` in #{description} search paths."
-          @loginator.log( warning, Verbosity::COMPLAIN )
-        when :ignore 
-          # nothing further to do
-      end
-    end
+    complain_of_no_path( "Found no path `#{pathname}` in #{description} search paths.", complain ) if scores.max.to_i.zero? and !pieces.empty?
 
-    return path_list[best_match_index]
+    return path_list[best_index( scores )]
   end
 
   def handle_missing_file(filename, complain)
@@ -122,6 +107,26 @@ class FileFinderHelper
     @loginator.log( warning, Verbosity::COMPLAIN )
   end
 
-end
+  def reversed_pieces(path)
+    return path.split( /(?:\\|\/)/ ).reverse
+  end
+
+  # Three for each trailing segment matched in place, and one for each segment found anywhere
+  def match_score(pieces, candidate)
+    in_place = pieces.zip( candidate ).count { |piece, other| piece == other }
+    return (in_place * 3) + pieces.count { |piece| candidate.include?( piece ) }
+  end
+
+  # The first of the highest scores, or the first when none scores
+  def best_index(scores)
+    best = scores.max.to_i
+    return best.zero? ? 0 : scores.index( best )
+  end
 
+  def complain_of_no_path(message, complain)
+    raise CeedlingException.new( message ) if complain == :error
 
+    @loginator.log( message, Verbosity::COMPLAIN ) if complain == :warn
+  end
+
+end