ceedling 0.0.1

data/new_project_template/vendor/ceedling/lib/configurator.rb

@@ -0,0 +1,254 @@
+require 'defaults'
+require 'constants'
+require 'file_path_utils'
+require 'deep_merge'
+
+
+
+class Configurator
+
+  attr_reader :project_config_hash, :environment, :script_plugins, :rake_plugins
+  attr_accessor :project_logging, :project_debug, :project_verbosity, :sanity_checks
+  
+  constructor(:configurator_setup, :configurator_builder, :configurator_plugins, :cmock_builder, :yaml_wrapper, :system_wrapper) do
+    @project_logging   = false
+    @project_debug     = false
+    @project_verbosity = Verbosity::NORMAL
+    @sanity_checks     = TestResultsSanityChecks::NORMAL
+  end
+  
+  
+  def setup
+    # special copy of cmock config to provide to cmock for construction
+    @cmock_config_hash = {}
+
+    # capture our source config for later merge operations
+    @source_config_hash = {}
+    
+    # note: project_config_hash is an instance variable so constants and accessors created
+    # in eval() statements in build() have something of proper scope and persistence to reference
+    @project_config_hash = {}
+    @project_config_hash_backup = {}
+    
+    @script_plugins = []
+    @rake_plugins   = []
+  end
+
+  
+  def replace_flattened_config(config)
+    @project_config_hash.merge!(config)
+    @configurator_setup.build_constants_and_accessors(@project_config_hash, binding())
+  end
+
+  
+  def store_config
+    @project_config_hash_backup = @project_config_hash.clone
+  end
+  
+  
+  def restore_config
+    @project_config_hash = @project_config_hash_backup
+    @configurator_setup.build_constants_and_accessors(@project_config_hash, binding())
+  end
+
+
+  def reset_defaults(config)
+    [:test_compiler,
+     :test_linker,
+     :test_fixture,
+     :test_includes_preprocessor,
+     :test_file_preprocessor,
+     :test_dependencies_generator,
+     :release_compiler,
+     :release_assembler,
+     :release_linker,
+     :release_dependencies_generator].each do |tool|
+      config[:tools].delete(tool) if (not (config[:tools][tool].nil?))
+    end
+  end
+
+
+  def populate_defaults(config)
+    new_config = DEFAULT_CEEDLING_CONFIG.clone
+    new_config.deep_merge!(config)
+    config.replace(new_config)
+
+    @configurator_builder.populate_defaults( config, DEFAULT_TOOLS_TEST )
+    @configurator_builder.populate_defaults( config, DEFAULT_TOOLS_TEST_PREPROCESSORS ) if (config[:project][:use_test_preprocessor])
+    @configurator_builder.populate_defaults( config, DEFAULT_TOOLS_TEST_DEPENDENCIES ) if (config[:project][:use_auxiliary_dependencies])
+    
+    @configurator_builder.populate_defaults( config, DEFAULT_TOOLS_RELEASE )              if (config[:project][:release_build])
+    @configurator_builder.populate_defaults( config, DEFAULT_TOOLS_RELEASE_ASSEMBLER )    if (config[:project][:release_build] and config[:release_build][:use_assembly])
+    @configurator_builder.populate_defaults( config, DEFAULT_TOOLS_RELEASE_DEPENDENCIES ) if (config[:project][:release_build] and config[:project][:use_auxiliary_dependencies])
+  end
+  
+
+  def populate_unity_defines(config)
+    run_test = true
+  
+    config[:unity][:defines].each do |define|
+      if (define =~ /RUN_TEST\s*\(.+\)\s*=/)
+        run_test = false
+        break
+      end
+    end
+  
+    if (run_test)
+      config[:unity][:defines] << "\"RUN_TEST(func, line_num)=TestRun(func, #func, line_num)\""
+    end
+  end
+  
+  
+  def populate_cmock_defaults(config)
+    # cmock has its own internal defaults handling, but we need to set these specific values
+    # so they're present for the build environment to access;
+    # note: these need to end up in the hash given to initialize cmock for this to be successful
+    cmock = config[:cmock]
+
+    # yes, we're duplicating the default mock_prefix in cmock, but it's because we need CMOCK_MOCK_PREFIX always available in Ceedling's environment
+    cmock[:mock_prefix] = 'Mock' if (cmock[:mock_prefix].nil?)
+    
+    # just because strict ordering is the way to go
+    cmock[:enforce_strict_ordering] = true                                                  if (cmock[:enforce_strict_ordering].nil?)
+    
+    cmock[:mock_path] = File.join(config[:project][:build_root], TESTS_BASE_PATH, 'mocks')  if (cmock[:mock_path].nil?)
+    cmock[:verbosity] = @project_verbosity                                                  if (cmock[:verbosity].nil?)
+
+    cmock[:plugins] = []                             if (cmock[:plugins].nil?)
+    cmock[:plugins].map! { |plugin| plugin.to_sym }
+    cmock[:plugins] << (:cexception)                 if (!cmock[:plugins].include?(:cexception) and (config[:project][:use_exceptions]))
+    cmock[:plugins].uniq!
+
+    cmock[:unity_helper] = false                     if (cmock[:unity_helper].nil?)
+    
+    if (cmock[:unity_helper])
+      cmock[:includes] << File.basename(cmock[:unity_helper])
+      cmock[:includes].uniq!
+    end
+
+    @cmock_builder.manufacture(cmock)
+  end
+
+
+  # grab tool names from yaml and insert into tool structures so available for error messages
+  def populate_tool_names_and_stderr_redirect(config)
+    config[:tools].each_key do |name|
+      tool = config[:tools][name]
+      
+      # populate name if not given      
+      tool[:name] = name.to_s if (tool[:name].nil?)
+
+      # populate stderr redirect option
+      tool[:stderr_redirect] = StdErrRedirect::NONE if (tool[:stderr_redirect].nil?)
+    end
+  end
+  
+
+  def find_and_merge_plugins(config)
+    # plugins must be loaded before generic path evaluation & magic that happen later: perform path magic here as discrete step
+    config[:plugins][:load_paths].each do |path|
+      path.replace(@system_wrapper.module_eval(path)) if (path =~ RUBY_STRING_REPLACEMENT_PATTERN)
+      FilePathUtils::standardize(path)
+    end
+    
+    @configurator_plugins.add_load_paths(config)
+  
+    @rake_plugins   = @configurator_plugins.find_rake_plugins(config)
+    @script_plugins = @configurator_plugins.find_script_plugins(config)
+    config_plugins  = @configurator_plugins.find_config_plugins(config)
+    plugin_defaults = @configurator_plugins.find_plugin_defaults(config)
+    
+    config_plugins.each do |plugin|
+      config.deep_merge( @yaml_wrapper.load(plugin) )
+    end
+    
+    plugin_defaults.each do |defaults|
+      @configurator_builder.populate_defaults( config, @yaml_wrapper.load(defaults) )
+    end
+    
+    # special plugin setting for results printing
+    config[:plugins][:display_raw_test_results] = true if (config[:plugins][:display_raw_test_results].nil?)
+  end
+
+  
+  def eval_environment_variables(config)
+    config[:environment].each do |hash|
+      key = hash.keys[0]
+      value_string = hash[key].to_s
+      if (value_string =~ RUBY_STRING_REPLACEMENT_PATTERN)
+        value_string.replace(@system_wrapper.module_eval(value_string))
+      end
+      @system_wrapper.env_set(key.to_s.upcase, value_string)
+    end    
+  end
+
+  
+  def eval_paths(config)
+    # [:plugins]:load_paths] already handled
+    individual_paths = [
+      config[:project][:build_root],
+      config[:project][:options_paths]]
+      
+    individual_paths.flatten.each do |path|
+      path.replace(@system_wrapper.module_eval(path)) if (path =~ RUBY_STRING_REPLACEMENT_PATTERN)
+    end
+  
+    config[:paths].each_pair do |key, list|
+      list.each { |path_entry| path_entry.replace(@system_wrapper.module_eval(path_entry)) if (path_entry =~ RUBY_STRING_REPLACEMENT_PATTERN) }
+    end    
+  end
+  
+  
+  def standardize_paths(config)
+    # [:plugins]:load_paths] already handled
+    individual_paths = [
+      config[:project][:build_root],
+      config[:project][:options_paths],
+      config[:cmock][:mock_path]] # cmock path in case it was explicitly set in config
+
+    individual_paths.flatten.each { |path| FilePathUtils::standardize(path) }
+
+    config[:paths].each_pair do |key, list|
+      list.each{|path| FilePathUtils::standardize(path)}
+      # ensure that list is an array (i.e. handle case of list being a single string)
+      config[:paths][key] = [list].flatten
+    end
+
+    config[:tools].each_pair do |key, tool_config|
+      FilePathUtils::standardize(tool_config[:executable])
+    end    
+  end
+
+
+  def validate(config)
+    # collect felonies and go straight to jail
+    raise if (not @configurator_setup.validate_required_sections(config))
+    
+    # collect all misdemeanors, everybody on probation
+    blotter = []
+    blotter << @configurator_setup.validate_required_section_values(config)
+    blotter << @configurator_setup.validate_paths(config)
+    blotter << @configurator_setup.validate_tools(config)
+    
+    raise if (blotter.include?(false))
+  end
+    
+  
+  def build(config)
+    built_config = @configurator_setup.build_project_config(config)
+    
+    @source_config_hash   = config.clone
+    @project_config_hash  = built_config.clone
+    store_config()
+
+    @configurator_setup.build_constants_and_accessors(built_config, binding())
+  end
+    
+  
+  def insert_rake_plugins(plugins)
+    plugins.each do |plugin|
+      @project_config_hash[:project_rakefile_component_files] << plugin
+    end
+  end
+  
+end

data/new_project_template/vendor/ceedling/lib/configurator_builder.rb

@@ -0,0 +1,408 @@
+require 'rubygems'
+require 'rake'            # for ext() method
+require 'file_path_utils' # for class methods
+require 'defaults'
+require 'constants'       # for Verbosity constants class & base file paths
+
+
+
+class ConfiguratorBuilder
+  
+  constructor :file_system_utils, :file_wrapper, :system_wrapper
+    
+  
+  def build_global_constants(config)
+    config.each_pair do |key, value|
+      formatted_key = key.to_s.upcase
+      # undefine global constant if it already exists
+      Object.send(:remove_const, formatted_key.to_sym) if @system_wrapper.constants_include?(formatted_key)
+      # create global constant
+      Object.module_eval("#{formatted_key} = value")
+    end
+  end
+
+  
+  def build_accessor_methods(config, context)
+    config.each_pair do |key, value|
+      # fill configurator object with accessor methods
+      eval("def #{key.to_s.downcase}() return @project_config_hash[:#{key.to_s}] end", context)
+    end
+  end
+
+  
+  # create a flattened hash from the original configuration structure
+  def flattenify(config)
+    new_hash = {}
+    
+    config.each_key do | parent |
+
+      # gracefully handle empty top-level entries
+      next if (config[parent].nil?)
+
+      case config[parent]
+      when Array
+        config[parent].each do |hash|
+          key = "#{parent.to_s.downcase}_#{hash.keys[0].to_s.downcase}".to_sym
+          new_hash[key] = hash[hash.keys[0]]
+        end
+      when Hash
+        config[parent].each_pair do | child, value |
+          key = "#{parent.to_s.downcase}_#{child.to_s.downcase}".to_sym
+          new_hash[key] = value
+        end
+      # handle entries with no children, only values
+      else
+        new_hash["#{parent.to_s.downcase}".to_sym] = config[parent]
+      end
+      
+    end
+    
+    return new_hash
+  end
+
+  
+  def populate_defaults(config, defaults)
+    defaults.keys.sort.each do |section|
+      defaults[section].keys.sort.each do |entry|
+        config[section][entry] = defaults[section][entry] if (config[section].nil? or config[section][entry].nil?)
+      end
+    end
+  end
+
+
+  def clean(in_hash)
+    # ensure that include files inserted into test runners have file extensions & proper ones at that
+    in_hash[:test_runner_includes].map!{|include| include.ext(in_hash[:extension_header])}
+  end
+
+
+  def set_build_paths(in_hash)
+    out_hash = {}
+
+    project_build_artifacts_root = File.join(in_hash[:project_build_root], 'artifacts')
+    project_build_tests_root     = File.join(in_hash[:project_build_root], TESTS_BASE_PATH)
+    project_build_release_root   = File.join(in_hash[:project_build_root], RELEASE_BASE_PATH)
+
+    paths = [
+      [:project_build_artifacts_root,  project_build_artifacts_root, true ],
+      [:project_build_tests_root,      project_build_tests_root,     true ],
+      [:project_build_release_root,    project_build_release_root,   in_hash[:project_release_build] ],
+
+      [:project_test_artifacts_path,     File.join(project_build_artifacts_root, TESTS_BASE_PATH), true ],
+      [:project_test_runners_path,       File.join(project_build_tests_root, 'runners'),           true ],
+      [:project_test_results_path,       File.join(project_build_tests_root, 'results'),           true ],
+      [:project_test_build_output_path,  File.join(project_build_tests_root, 'out'),               true ],
+      [:project_test_build_cache_path,   File.join(project_build_tests_root, 'cache'),             true ],
+      [:project_test_dependencies_path,  File.join(project_build_tests_root, 'dependencies'),      true ],
+
+      [:project_release_artifacts_path,         File.join(project_build_artifacts_root, RELEASE_BASE_PATH), in_hash[:project_release_build] ],
+      [:project_release_build_cache_path,       File.join(project_build_release_root, 'cache'),             in_hash[:project_release_build] ],
+      [:project_release_build_output_path,      File.join(project_build_release_root, 'out'),               in_hash[:project_release_build] ],
+      [:project_release_build_output_asm_path,  File.join(project_build_release_root, 'out', 'asm'),        in_hash[:project_release_build] ],
+      [:project_release_build_output_c_path,    File.join(project_build_release_root, 'out', 'c'),          in_hash[:project_release_build] ],
+      [:project_release_dependencies_path,      File.join(project_build_release_root, 'dependencies'),      in_hash[:project_release_build] ],
+
+      [:project_log_path,   File.join(in_hash[:project_build_root], 'logs'), true ],
+      [:project_temp_path,  File.join(in_hash[:project_build_root], 'temp'), true ],
+
+      [:project_test_preprocess_includes_path,  File.join(project_build_tests_root, 'preprocess/includes'), in_hash[:project_use_test_preprocessor] ],
+      [:project_test_preprocess_files_path,     File.join(project_build_tests_root, 'preprocess/files'),    in_hash[:project_use_test_preprocessor] ],
+    ]
+
+    out_hash[:project_build_paths] = []
+
+    # fetch already set mock path
+    out_hash[:project_build_paths] << in_hash[:cmock_mock_path] if (in_hash[:project_use_mocks])
+
+    paths.each do |path|
+      build_path_name          = path[0]
+      build_path               = path[1]
+      build_path_add_condition = path[2]
+      
+      # insert path into build paths if associated with true condition
+      out_hash[:project_build_paths] << build_path if build_path_add_condition
+      # set path symbol name and path for each entry in paths array
+      out_hash[build_path_name] = build_path
+    end
+
+    return out_hash
+  end
+
+
+  def set_force_build_filepaths(in_hash)
+    out_hash = {}
+    
+    out_hash[:project_test_force_rebuild_filepath]    = File.join( in_hash[:project_test_dependencies_path], 'force_build' )
+    out_hash[:project_release_force_rebuild_filepath] = File.join( in_hash[:project_release_dependencies_path], 'force_build' ) if (in_hash[:project_release_build])
+
+    return out_hash
+  end
+
+
+  def set_rakefile_components(in_hash)
+    out_hash = {
+      :project_rakefile_component_files => 
+        [File.join(CEEDLING_LIB, 'tasks_base.rake'),
+         File.join(CEEDLING_LIB, 'tasks_filesystem.rake'),
+         File.join(CEEDLING_LIB, 'tasks_tests.rake'),
+         File.join(CEEDLING_LIB, 'tasks_vendor.rake'),
+         File.join(CEEDLING_LIB, 'rules_tests.rake')]}
+
+    out_hash[:project_rakefile_component_files] << File.join(CEEDLING_LIB, 'rules_cmock.rake') if (in_hash[:project_use_mocks])
+    out_hash[:project_rakefile_component_files] << File.join(CEEDLING_LIB, 'rules_preprocess.rake') if (in_hash[:project_use_test_preprocessor])
+    out_hash[:project_rakefile_component_files] << File.join(CEEDLING_LIB, 'rules_tests_aux_dependencies.rake') if (in_hash[:project_use_auxiliary_dependencies])
+
+    out_hash[:project_rakefile_component_files] << File.join(CEEDLING_LIB, 'rules_release_aux_dependencies.rake') if (in_hash[:project_release_build] and in_hash[:project_use_auxiliary_dependencies])
+    out_hash[:project_rakefile_component_files] << File.join(CEEDLING_LIB, 'rules_release.rake') if (in_hash[:project_release_build])
+    out_hash[:project_rakefile_component_files] << File.join(CEEDLING_LIB, 'tasks_release.rake') if (in_hash[:project_release_build])
+
+    return out_hash
+  end
+  
+
+  def set_library_build_info_filepaths(hash)
+
+    # Notes:
+    #  - Dependency on a change to our input configuration hash is handled elsewhere as it is 
+    #    dynamically formed during ceedling's execution
+    #  - Compiled vendor dependencies like cmock.o, unity.o, cexception.o are handled below;
+    #    here we're interested only in ceedling-based code generation dependencies
+    
+    ceedling_build_info_filepath = File.join(CEEDLING_RELEASE, 'build.info')
+    cmock_build_info_filepath    = FilePathUtils::form_ceedling_vendor_path('cmock/release', 'build.info')
+
+    out_hash = {
+      :ceedling_build_info_filepath => ceedling_build_info_filepath,
+      :cmock_build_info_filepath => cmock_build_info_filepath
+    }
+    
+    return out_hash
+  end
+
+  
+  def set_release_target(in_hash)
+    return {} if (not in_hash[:project_release_build])
+    
+    release_target_file = ((in_hash[:release_build_output].nil?) ? (DEFAULT_RELEASE_TARGET_NAME.ext(in_hash[:extension_executable])) : in_hash[:release_build_output])
+    
+    return {
+      # tempted to make a helper method in file_path_utils? stop right there, pal. you'll introduce a cyclical dependency
+      :project_release_build_target => File.join(in_hash[:project_release_artifacts_path], release_target_file)
+      }
+  end
+  
+
+  def collect_environment_variables(in_hash)
+    return {
+      :collection_environment => in_hash[:environment]
+      }
+  end
+
+  
+  def collect_project_options(in_hash)
+    options = []
+    
+    in_hash[:project_options_paths].each do |path|
+      options << @file_wrapper.directory_listing( File.join(path, '*.yml') )
+    end
+    
+    return {
+      :collection_project_options => options.flatten
+      }
+  end
+  
+
+  def expand_all_path_globs(in_hash)
+    out_hash = {}
+    path_keys = []
+    
+    in_hash.each_key do |key|
+      next if (not key.to_s[0..4] == 'paths')
+      path_keys << key
+    end
+    
+    # sorted to provide assured order of traversal in test calls on mocks
+    path_keys.sort.each do |key|
+      out_hash["collection_#{key.to_s}".to_sym] = @file_system_utils.collect_paths( in_hash[key] )
+    end
+    
+    return out_hash
+  end
+
+
+  def collect_source_and_include_paths(in_hash)
+    return {
+      :collection_paths_source_and_include => 
+        in_hash[:collection_paths_source] + 
+        in_hash[:collection_paths_include]
+      }    
+  end
+
+
+  def collect_source_include_vendor_paths(in_hash)
+    extra_paths = []
+    extra_paths << FilePathUtils::form_ceedling_vendor_path(CEXCEPTION_LIB_PATH) if (in_hash[:project_use_exceptions])
+
+    return {
+      :collection_paths_source_include_vendor => 
+        in_hash[:collection_paths_source_and_include] + 
+        extra_paths
+      }    
+  end
+
+
+  def collect_test_support_source_include_paths(in_hash)
+    return {
+      :collection_paths_test_support_source_include => 
+        in_hash[:collection_paths_test] +
+        in_hash[:collection_paths_support] +
+        in_hash[:collection_paths_source] + 
+        in_hash[:collection_paths_include]
+      }    
+  end
+  
+  
+  def collect_test_support_source_include_vendor_paths(in_hash)
+    extra_paths = []
+    extra_paths << FilePathUtils::form_ceedling_vendor_path(UNITY_LIB_PATH)
+    extra_paths << FilePathUtils::form_ceedling_vendor_path(CEXCEPTION_LIB_PATH) if (in_hash[:project_use_exceptions])
+    extra_paths << FilePathUtils::form_ceedling_vendor_path(CMOCK_LIB_PATH)       if (in_hash[:project_use_mocks])
+    extra_paths << in_hash[:cmock_mock_path]                                   if (in_hash[:project_use_mocks])
+
+    return {
+      :collection_paths_test_support_source_include_vendor => 
+        in_hash[:collection_paths_test_support_source_include] +
+        extra_paths
+      }    
+  end
+  
+  
+  def collect_tests(in_hash)
+    all_tests = @file_wrapper.instantiate_file_list
+
+    in_hash[:collection_paths_test].each do |path|
+      all_tests.include( File.join(path, "#{in_hash[:project_test_file_prefix]}*#{in_hash[:extension_source]}") )
+    end
+
+    return {:collection_all_tests => all_tests}
+  end
+
+
+  def collect_assembly(in_hash)
+    all_assembly = @file_wrapper.instantiate_file_list
+
+    return {:collection_all_assembly => all_assembly} if (not in_hash[:release_build_use_assembly])
+    
+    in_hash[:collection_paths_source].each do |path|
+      all_assembly.include( File.join(path, "*#{in_hash[:extension_assembly]}") )
+    end
+    
+    return {:collection_all_assembly => all_assembly}
+  end
+
+
+  def collect_source(in_hash)
+    all_source = @file_wrapper.instantiate_file_list
+    
+    in_hash[:collection_paths_source].each do |path|
+      all_source.include( File.join(path, "*#{in_hash[:extension_source]}") )
+    end
+    
+    return {:collection_all_source => all_source}
+  end
+
+
+  def collect_headers(in_hash)
+    all_headers = @file_wrapper.instantiate_file_list
+
+    paths = 
+      in_hash[:collection_paths_test] +
+      in_hash[:collection_paths_support] +
+      in_hash[:collection_paths_source] + 
+      in_hash[:collection_paths_include]
+    
+    (paths).each do |path|
+      all_headers.include( File.join(path, "*#{in_hash[:extension_header]}") )
+    end
+    
+    return {:collection_all_headers => all_headers}
+  end
+
+
+  def collect_all_existing_compilation_input(in_hash)
+    all_input = @file_wrapper.instantiate_file_list
+
+    paths = 
+      in_hash[:collection_paths_test] + 
+      in_hash[:collection_paths_support] + 
+      in_hash[:collection_paths_source] + 
+      in_hash[:collection_paths_include] +
+      [FilePathUtils::form_ceedling_vendor_path(UNITY_LIB_PATH)]
+    
+    paths << FilePathUtils::form_ceedling_vendor_path(CEXCEPTION_LIB_PATH) if (in_hash[:project_use_exceptions])
+    paths << FilePathUtils::form_ceedling_vendor_path(CMOCK_LIB_PATH) if (in_hash[:project_use_mocks])
+
+    (paths).each do |path|
+      all_input.include( File.join(path, "*#{in_hash[:extension_header]}") )
+      all_input.include( File.join(path, "*#{in_hash[:extension_source]}") )
+    end
+    
+    return {:collection_all_existing_compilation_input => all_input}    
+  end
+
+
+  def collect_test_and_vendor_defines(in_hash)
+    test_defines = in_hash[:defines_test].clone
+
+    test_defines.concat(in_hash[:unity_defines])
+    test_defines.concat(in_hash[:cmock_defines])      if (in_hash[:project_use_mocks])
+    test_defines.concat(in_hash[:cexception_defines]) if (in_hash[:project_use_exceptions])
+    
+    return {:collection_defines_test_and_vendor => test_defines}
+  end
+
+
+  def collect_release_and_vendor_defines(in_hash)
+    release_defines = in_hash[:defines_release].clone
+    
+    release_defines.concat(in_hash[:cexception_defines]) if (in_hash[:project_use_exceptions])
+    
+    return {:collection_defines_release_and_vendor => release_defines}
+  end
+
+
+  def collect_release_artifact_extra_link_objects(in_hash)
+    objects = []
+
+    # no build paths here so plugins can remap if necessary (i.e. path mapping happens at runtime)
+    objects << CEXCEPTION_C_FILE.ext( in_hash[:extension_object] ) if (in_hash[:project_use_exceptions])
+    
+    return {:collection_release_artifact_extra_link_objects => objects}
+  end
+  
+
+  def collect_test_fixture_extra_link_objects(in_hash)
+    #  Note: Symbols passed to compiler at command line can change Unity and CException behavior / configuration;
+    #    we also handle those dependencies elsewhere in compilation dependencies
+    
+    objects = [UNITY_C_FILE]
+    
+    # we don't include paths here because use of plugins or mixing different compilers may require different build paths
+    objects << CEXCEPTION_C_FILE if (in_hash[:project_use_exceptions])
+    objects << CMOCK_C_FILE      if (in_hash[:project_use_mocks])
+    
+    # if we're using mocks & a unity helper is defined & that unity helper includes a source file component (not only a header of macros),
+    # then link in the unity_helper object file too
+    if ( in_hash[:project_use_mocks] and
+         in_hash[:cmock_unity_helper] and 
+         @file_wrapper.exist?(in_hash[:cmock_unity_helper].ext(in_hash[:extension_source])) )
+      objects << File.basename(in_hash[:cmock_unity_helper])
+    end
+
+    # no build paths here so plugins can remap if necessary (i.e. path mapping happens at runtime)
+    objects.map! { |object| object.ext(in_hash[:extension_object]) }
+    
+    return { :collection_test_fixture_extra_link_objects => objects }
+  end
+  
+end