ceedling 0.9.0 → 1.0.1

data/lib/ceedling/file_finder.rb

@@ -0,0 +1,183 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+require 'rubygems'
+require 'rake' # for adding ext() method to string
+require 'ceedling/exceptions'
+
+class FileFinder
+
+  constructor :configurator, :file_finder_helper, :cacheinator, :file_path_utils, :file_wrapper, :yaml_wrapper
+
+
+  def find_header_input_for_mock(mock_name)
+    # Mock name => <mock prefix><header filename without extension>
+    # Examples: 'Mockfoo' or 'mock_Bar'
+    # Note: In some rare cases, a mock name may include a dot (ex. Sensor.44) because of versioning file naming convention
+    #       Be careful about assuming the end of the name has any sort of file extension
+
+    header = mock_name.sub(/#{@configurator.cmock_mock_prefix}/, '') + @configurator.extension_header
+
+    found_path = @file_finder_helper.find_file_in_collection(header, @configurator.collection_all_headers, :error, mock_name)
+
+    return found_path
+  end
+
+
+  # Find test filepath from another filepath (e.g. test executable with same base name, a/path/test_foo.exe)
+  def find_test_file_from_filepath(filepath)
+    # Strip filepath down to filename and remove file extension
+    name = File.basename( filepath ).ext('')
+
+    return find_test_file_from_name( name )
+  end
+
+
+  # Find test filepath from only the base name of a test file (e.g. 'test_foo')
+  def find_test_file_from_name(name)
+    test_file = name + @configurator.extension_source
+
+    found_path = @file_finder_helper.find_file_in_collection(test_file, @configurator.collection_all_tests, :error, name)
+
+    return found_path
+  end
+
+
+  def find_build_input_file(filepath:, complain: :error, context:)
+    release = (context == RELEASE_SYM)
+
+    found_file = nil
+
+    # Strip off file extension
+    source_file = File.basename(filepath).ext('')
+
+    # We only collect files that already exist when we start up.
+    # FileLists can produce undesired results for dynamically generated files depending on when they're accessed.
+    # So collect mocks and runners separately and right now.
+    # Assume that project configuration options will have already filtered out any files that should not be searched for.
+
+    # Note: We carefully add file extensions below with string addition instead of using .ext()
+    #       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
+    if (!release) and (source_file =~ /^#{@configurator.project_test_file_prefix}.+#{@configurator.test_runner_file_suffix}$/)
+      _source_file = source_file + EXTENSION_CORE_SOURCE
+      found_file =
+        @file_finder_helper.find_file_in_collection(
+          _source_file,
+          @file_wrapper.directory_listing( File.join(@configurator.project_test_runners_path, '*') ),
+          complain,
+          filepath)
+
+    # Generated mocks
+    elsif (!release) and (source_file =~ /^#{@configurator.cmock_mock_prefix}/)
+      _source_file = source_file + EXTENSION_CORE_SOURCE
+      found_file =
+        @file_finder_helper.find_file_in_collection(
+          _source_file,
+          @file_wrapper.directory_listing( File.join(@configurator.cmock_mock_path, '**/*') ),
+          complain,
+          filepath)
+
+    # Vendor framework sources (unity.c, cmock.c, cexception.c, etc.)
+    # Note: Taking a small chance by mixing test and release frameworks without smart checks on test/release build
+    elsif (@configurator.collection_vendor_framework_sources.include?(source_file.ext(EXTENSION_CORE_SOURCE)))
+      _source_file = source_file + EXTENSION_CORE_SOURCE
+      found_file =
+        @file_finder_helper.find_file_in_collection(
+          _source_file,
+          @configurator.collection_existing_test_build_input,
+          complain,
+          filepath)
+
+    end
+
+    if !found_file.nil?
+      return found_file
+    end
+
+    #
+    # Above we can confidently rely on the complain parameter passed to file_finder_helper because
+    # we know the specific type of file being searched for.
+    #
+    # Below we ignore file misses because of lgoical complexities of searching for potentially either 
+    # assmebly or C files, including C files that may not exist (counterparts to header files by convention).
+    # We save the existence handling until the end.
+    #
+
+    # Assembly files for release build 
+    if release and @configurator.release_build_use_assembly
+      _source_file = source_file + @configurator.extension_assembly
+      found_file =
+        @file_finder_helper.find_file_in_collection(
+          _source_file,
+          @configurator.collection_release_build_input,
+          :ignore,
+          filepath)
+
+    # Assembly files for test build 
+    elsif (!release) and @configurator.test_build_use_assembly
+      _source_file = source_file + @configurator.extension_assembly
+      found_file =
+        @file_finder_helper.find_file_in_collection(
+          _source_file,
+          @configurator.collection_existing_test_build_input,
+          :ignore,
+          filepath)
+    end
+
+    if !found_file.nil?
+        return found_file
+    end
+
+    # Release build C files
+    if release
+      _source_file = source_file + @configurator.extension_source
+      found_file =
+        @file_finder_helper.find_file_in_collection(
+          _source_file,
+          @configurator.collection_release_build_input,
+          :ignore,
+          filepath)
+        
+    # Test build C files
+    else
+      _source_file = source_file + @configurator.extension_source
+      found_file =
+        @file_finder_helper.find_file_in_collection(
+          _source_file,
+          @configurator.collection_existing_test_build_input,
+          :ignore,
+          filepath)
+    end
+
+    if found_file.nil?
+      _source_file += " or #{_source_file.ext(@configurator.extension_assembly)}" if @configurator.release_build_use_assembly
+      @file_finder_helper.handle_missing_file(_source_file, complain)
+    end
+
+    return found_file
+  end
+
+
+  def find_source_file(filepath, complain = :error)
+    source_file = File.basename(filepath).ext(@configurator.extension_source)
+    return @file_finder_helper.find_file_in_collection(source_file, @configurator.collection_all_source, complain, filepath)
+  end
+
+
+  def find_assembly_file(filepath, complain = :error)
+    assembly_file = File.basename(filepath).ext(@configurator.extension_assembly)
+    return @file_finder_helper.find_file_in_collection(assembly_file, @configurator.collection_all_assembly, complain, filepath)
+  end
+
+  def find_file_from_list(filepath, file_list, complain)
+    return @file_finder_helper.find_file_in_collection(filepath, file_list, complain, filepath)
+  end
+end
+

data/lib/ceedling/file_finder_helper.rb

@@ -0,0 +1,116 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+require 'fileutils'
+require 'ceedling/constants' # for Verbosity enumeration
+require 'ceedling/exceptions'
+
+class FileFinderHelper
+
+  constructor :loginator
+  
+  
+  def find_file_in_collection(filename, file_list, complain, original_filepath="")
+    # Search our collection for the specified base filename
+    matches = file_list.find_all {|v| File.basename(v) == filename }
+    
+    case matches.length 
+      when 0 
+        matches = file_list.find_all {|v| v =~ /(?:\\|\/|^)#{filename}$/i}
+        if (matches.length > 0)
+          blow_up(filename, "However, a filename having different capitalization was found: '#{matches[0]}'.")
+        end
+
+        return handle_missing_file(filename, complain)
+      when 1
+        return matches[0]
+      else
+        # 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 = original_filepath.split(/(?:\\|\/)/).reverse
+        matches.each_with_index do |m,i|
+          reverse_match_pieces = m.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
+        return matches[best_match_index]
+    end
+
+    return nil
+  end
+
+  def find_best_path_in_collection(pathname, path_list, complain, description)
+    # search our collection for the specified exact path
+    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
+
+    # 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
+
+    return path_list[best_match_index]
+  end
+
+  def handle_missing_file(filename, complain)
+    case (complain)
+      when :error then blow_up(filename) 
+      when :warn
+        gripe(filename)
+        return nil
+      when :ignore then return nil
+    end
+
+    return nil
+  end
+
+  ### Private ###
+
+  private
+
+  def blow_up(filename, extra_message="")
+    error = ["Found no file `#{filename}` in search paths.", extra_message].join(' ').strip
+    raise CeedlingException.new( error )
+  end
+    
+  def gripe(filename, extra_message="")
+    warning = ["Found no file `#{filename}` in search paths.", extra_message].join(' ').strip
+    @loginator.log( warning, Verbosity::COMPLAIN )
+  end
+
+end
+
+

data/lib/ceedling/file_path_collection_utils.rb

@@ -0,0 +1,137 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+require 'set'
+require 'pathname'
+require 'fileutils'
+require 'ceedling/file_path_utils'
+require 'ceedling/exceptions'
+
+
+class FilePathCollectionUtils
+  
+  constructor :file_wrapper
+
+  def setup()
+    # TODO: Update Dir.pwd() to use a project root once it has been figured out
+    @working_dir_path = Pathname.new( Dir.pwd() )
+  end
+
+  # Build up a directory path list from one or more strings or arrays of (+:/-:) simple paths & globs
+  def collect_paths(paths)
+    plus  = Set.new # All real, expanded directory paths to add
+    minus = Set.new # All real, expanded paths to exclude
+    
+    # Iterate each path possibly decorated with aggregation modifiers and/or containing glob characters
+    paths.each do |path|
+      dirs = [] # Working list for evaluated directory paths
+    
+      # Get path stripped of any +:/-: aggregation modifier
+      _path = FilePathUtils.no_aggregation_decorators( path )
+
+      # If it's a glob, modify it for Ceedling's recursive subdirectory convention
+      _reformed = FilePathUtils::reform_subdirectory_glob( _path )
+
+      # Expand paths using Ruby's Dir.glob()
+      #  - A simple path will yield that path
+      #  - A path glob will expand to one or more paths
+      # Note: `sort()` because of Github Issue #860
+      @file_wrapper.directory_listing( _reformed ).sort.each do |entry|
+        # For each result, add it to the working list *only* if it's a directory
+        # Previous validation has already made warnings about filepaths in the list
+        dirs << entry if @file_wrapper.directory?(entry)
+      end
+      
+      # For recursive directory glob at end of a path, collect parent directories too.
+      # Ceedling's recursive glob convention includes parent directories (unlike Ruby's glob).
+      if path.end_with?('/**') or path.end_with?('/*')
+        parents = []
+        
+        dirs.each {|dir| parents << File.join(dir, '..')}
+
+        # Handle edge case of subdirectory glob but no subdirectories and therefore no parents
+        # (Containing parent directory still exists)
+        parents << FilePathUtils.no_decorators( _path ) if dirs.empty?
+
+        dirs = parents + dirs
+      end
+
+      # Based on aggregation modifiers, add entries to plus and minus sets.
+      # Use full, absolute paths to ensure logical paths are compared properly.
+      # './<path>' is logically equivalent to '<path>' but is not equivalent as strings.
+      # Because plus and minus are sets, each insertion eliminates any duplicates
+      # (such as the parent directories for each directory as added above).
+      dirs.each do |dir|
+        abs_path = File.expand_path( dir )
+        if FilePathUtils.add_path?( path )
+          plus << abs_path
+        else
+          minus << abs_path
+        end
+      end
+    end
+
+    # Use Set subtraction operator to remove any excluded paths
+    paths = (plus - minus).to_a
+    paths.map! {|path| shortest_path_from_working(path) }
+
+    return paths
+  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.
+  # TODO: Replace FileList with our own, better version.
+  def revise_filelist(list, revisions)
+    plus  = Set.new # All real, expanded directory paths to add
+    minus = Set.new # All real, expanded paths to exclude
+    
+    # Build base plus set for revised path
+    list.each do |path|
+      # Start with expanding all list entries to absolute paths
+      plus << File.expand_path( path )
+    end
+
+    revisions.each do |revision|
+      # Include or exclude revisions in file list
+      path = FilePathUtils.no_aggregation_decorators( revision )
+      
+      # Working list of revisions
+      filepaths = []
+
+      # Expand path by pattern as needed and add only filepaths to working list
+      @file_wrapper.directory_listing( path ).each do |entry|
+        filepaths << File.expand_path( entry ) if !@file_wrapper.directory?( entry )
+      end
+
+      # Handle +: / -: revisions
+      if FilePathUtils.add_path?( revision )
+        plus.merge( filepaths )
+      else
+        minus.merge( filepaths )
+      end
+    end
+
+    # Use Set subtraction operator to remove any excluded paths
+    paths = (plus - minus).to_a
+    paths.map! {|path| shortest_path_from_working(path) }
+
+    return FileList.new( paths )
+  end
+
+  def shortest_path_from_working(path)
+    begin
+      # Reform path from full absolute to nice, neat relative path instead
+      (Pathname.new( path ).relative_path_from( @working_dir_path )).to_s
+    rescue StandardError
+      # If we can't form a relative path between these paths, use the absolute
+      path 
+    end
+  end
+
+end

data/lib/ceedling/file_path_utils.rb

@@ -0,0 +1,190 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+require 'rubygems'
+require 'rake' # for ext()
+require 'fileutils'
+require 'ceedling/system_wrapper'
+require 'ceedling/constants'
+
+# global utility methods (for plugins, project files, etc.)
+def ceedling_form_filepath(destination_path, original_filepath, new_extension=nil)
+  filename = File.basename(original_filepath)
+  filename.replace(filename.ext(new_extension)) if (!new_extension.nil?)
+  return File.join( destination_path.gsub(/\\/, '/'), filename )
+end
+
+class FilePathUtils
+
+  constructor :configurator, :file_wrapper
+
+
+  ######### Class methods ##########
+
+  # Standardize path to use '/' path separator & have no trailing path separator
+  def self.standardize(path)
+    if path.is_a? String
+      path.strip!
+      path.gsub!(/\\/, '/')
+      path.chomp!('/')
+    end
+    return path
+  end
+
+  def self.os_executable_ext(executable)
+    return executable.ext('.exe') if SystemWrapper.windows?
+    return executable
+  end
+
+  # Extract path from between optional aggregation modifiers 
+  # and up to last path separator before glob specifiers.
+  # Examples:
+  #  - '+:foo/bar/baz/'       => 'foo/bar/baz'
+  #  - 'foo/bar/ba?'          => 'foo/bar'
+  #  - 'foo/bar/baz/'         => 'foo/bar/baz'
+  #  - 'foo/bar/baz/file.x'   => 'foo/bar/baz/file.x'
+  #  - 'foo/bar/baz/file*.x'  => 'foo/bar/baz'
+  def self.no_decorators(path)
+    path = self.no_aggregation_decorators(path)
+
+    # Find first occurrence of glob specifier: *, ?, {, }, [, ]
+    find_index = (path =~ PATTERNS::GLOB)
+
+    # Return empty path if first character is part of a glob
+    return '' if find_index == 0
+
+    # If path contains no glob, clean it up and return whole path
+    return path.chomp('/') if (find_index.nil?)
+
+    # Extract up to first glob specifier
+    path = path[0..(find_index-1)]
+
+    # Keep everything from start of path string up to and 
+    # including final path separator before glob character
+    find_index = path.rindex('/')
+    return path[0..(find_index-1)] if (not find_index.nil?)
+
+    # Otherwise, return empty string
+    # (Not enough of a usable path exists free of glob operators)
+    return ''
+  end
+
+  # Return whether the given path is to be aggregated (no aggregation modifier defaults to same as +:)
+  def self.add_path?(path)
+    return !path.strip.start_with?('-:')
+  end
+
+  # Get path (and glob) lopping off optional +: / -: prefixed aggregation modifiers
+  def self.no_aggregation_decorators(path)
+    return path.sub(/^(\+|-):/, '').strip()
+  end
+
+  # To recurse through all subdirectories, the RUby glob is <dir>/**/**, but our paths use
+  # convenience convention of only <dir>/** at tail end of a path.
+  def self.reform_subdirectory_glob(path)
+    return path if path.end_with?( '/**/**' )
+    return path + '/**' if path.end_with?( '/**' )
+    return path
+  end
+
+  ######### instance methods ##########
+
+  ### release ###
+  def form_release_build_cache_path(filepath)
+    return File.join( @configurator.project_release_build_cache_path, File.basename(filepath) )
+  end
+
+  def form_release_dependencies_filepath(filepath)
+    return File.join( @configurator.project_release_dependencies_path, File.basename(filepath).ext(@configurator.extension_dependencies) )
+  end
+
+  def form_release_build_objects_filelist(files)
+    return (@file_wrapper.instantiate_file_list(files)).pathmap("#{@configurator.project_release_build_output_path}/%n#{@configurator.extension_object}")
+  end
+
+  def form_release_build_list_filepath(filepath)
+    return File.join( @configurator.project_release_build_output_path, File.basename(filepath).ext(@configurator.extension_list) )
+  end
+
+  def form_release_dependencies_filelist(files)
+    return (@file_wrapper.instantiate_file_list(files)).pathmap("#{@configurator.project_release_dependencies_path}/%n#{@configurator.extension_dependencies}")
+  end
+
+  ### Tests ###
+
+  def form_test_build_cache_path(filepath)
+    return File.join( @configurator.project_test_build_cache_path, File.basename(filepath) )
+  end
+
+  def form_test_dependencies_filepath(filepath)
+    return File.join( @configurator.project_test_dependencies_path, File.basename(filepath).ext(@configurator.extension_dependencies) )
+  end
+
+  def form_pass_results_filepath(build_output_path, filepath)
+    return File.join( build_output_path, File.basename(filepath).ext(@configurator.extension_testpass) )
+  end
+
+  def form_fail_results_filepath(build_output_path, filepath)
+    return File.join( build_output_path, File.basename(filepath).ext(@configurator.extension_testfail) )
+  end
+
+  def form_runner_filepath_from_test(filepath)
+    return File.join( @configurator.project_test_runners_path, File.basename(filepath, @configurator.extension_source)) + @configurator.test_runner_file_suffix + EXTENSION_CORE_SOURCE
+  end
+
+  def form_test_filepath_from_runner(filepath)
+    return filepath.sub(/#{TEST_RUNNER_FILE_SUFFIX}/, '')
+  end
+
+  def form_test_executable_filepath(build_output_path, filepath)
+    return File.join( build_output_path, File.basename(filepath).ext(@configurator.extension_executable) )
+  end
+
+  def form_test_build_map_filepath(build_output_path, filepath)
+    return File.join( build_output_path, File.basename(filepath).ext(@configurator.extension_map) )
+  end
+
+  def form_test_build_list_filepath(filepath)
+    return File.join( @configurator.project_test_build_output_path, File.basename(filepath).ext(@configurator.extension_list) )
+  end
+
+  def form_preprocessed_includes_list_filepath(filepath, subdir)
+    return File.join( @configurator.project_test_preprocess_includes_path, subdir, File.basename(filepath) + @configurator.extension_yaml )
+  end
+
+  def form_preprocessed_file_filepath(filepath, subdir)
+    return File.join( @configurator.project_test_preprocess_files_path, subdir, File.basename(filepath) )
+  end
+
+  def form_preprocessed_file_full_expansion_filepath(filepath, subdir)
+    return File.join( @configurator.project_test_preprocess_files_path, subdir, PREPROCESS_FULL_EXPANSION_DIR, File.basename(filepath) )
+  end
+
+  def form_preprocessed_file_directives_only_filepath(filepath, subdir)
+    return File.join( @configurator.project_test_preprocess_files_path, subdir, PREPROCESS_DIRECTIVES_ONLY_DIR, File.basename(filepath) )
+  end
+
+  def form_test_build_objects_filelist(path, sources)
+    return (@file_wrapper.instantiate_file_list(sources)).pathmap("#{path}/%n#{@configurator.extension_object}")
+  end
+
+  def form_mocks_source_filelist(path, mocks)
+    list = (@file_wrapper.instantiate_file_list(mocks))
+    return list.map{ |file| File.join(path, File.basename(file).ext(@configurator.extension_source)) }
+  end
+
+  def form_test_dependencies_filelist(files)
+    list = @file_wrapper.instantiate_file_list(files)
+    return list.pathmap("#{@configurator.project_test_dependencies_path}/%n#{@configurator.extension_dependencies}")
+  end
+
+  def form_pass_results_filelist(path, files)
+    list = @file_wrapper.instantiate_file_list(files)
+    return list.pathmap("#{path}/%n#{@configurator.extension_testpass}")
+  end
+
+end

data/lib/ceedling/file_system_wrapper.rb

@@ -0,0 +1,16 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+class FileSystemWrapper
+
+  def cd(path)
+    FileUtils.cd path do
+      yield
+    end
+  end
+
+end