ceedling 1.1.10 → 1.2.1

data/plugins/dependencies/lib/dependencies.rb

@@ -8,34 +8,37 @@
 require 'ceedling/plugins/plugin'
 require 'ceedling/constants'
 require 'ceedling/exceptions'
-require 'pathname'
+require 'dependency_spec'
+require 'dependency_commands'
+require 'dependency_environment'
 
 DEPENDENCIES_ROOT_NAME = 'dependencies'
 DEPENDENCIES_TASK_ROOT = DEPENDENCIES_ROOT_NAME + ':'
 DEPENDENCIES_SYM       = DEPENDENCIES_ROOT_NAME.to_sym
 
+# Fetches, builds, cleans, and deploys the third-party code a project depends on, and adds
+# its headers, sources, and libraries to test and release builds.
+#
+# DependencySpec reads each configured dependency, DependencyCommands decides which tool
+# commands fetch and build it, and DependencyEnvironment holds its environment variables
+# while they run. This plugin carries those out. Files and directories go through the
+# file wrapper and commands through the tool executor, and only a dependency's own
+# commands run from inside its directories.
 class Dependencies < Plugin
 
-  def setup()
-    # Set up a fast way to look up dependencies by name or static lib path
-    @dependencies = {}
-    @dynamic_libraries = []
-    DEPENDENCIES_DEPS.each do |deplib|
-
-      @dependencies[ deplib[:name] ] = deplib.clone
-      all_deps = get_static_libraries_for_dependency(deplib) +
-                 get_dynamic_libraries_for_dependency(deplib) +
-                 get_include_directories_for_dependency(deplib) +
-                 get_source_files_for_dependency(deplib)
-      all_deps.each do |key|
-        @dependencies[key] = @dependencies[ deplib[:name] ]
-      end
+  attr_reader :specs
 
-      @dynamic_libraries += get_dynamic_libraries_for_dependency(deplib)
+  def setup()
+    @specs  = DependencySpec.build_all( DEPENDENCIES_DEPS )
+    @lookup = {}
+
+    # A dependency is found by its name, its task name, or any artifact it produces
+    @specs.each do |spec|
+      keys = [spec.name, spec.task_name] + spec.static_libraries + spec.dynamic_libraries + spec.executables +
+             spec.include_directories( path_collector ) + spec.include_files + spec.source_paths
+      keys.each { |key| @lookup[key] = spec }
+      environment_for( spec )
     end
-
-    # Validate fetch tools per the configuration
-    @dependencies.each {|_, config| validate_fetch_tools( config )}
   end
 
   def config()
@@ -44,500 +47,302 @@ class Dependencies < Plugin
       :collection_all_headers => COLLECTION_ALL_HEADERS,
     }
 
-    DEPENDENCIES_DEPS.each do |deplib|
-      @ceedling[DEPENDENCIES_SYM].get_include_directories_for_dependency(deplib).each do |incpath|
-        updates[:collection_paths_include] << incpath
-      end
-
-      @ceedling[DEPENDENCIES_SYM].get_include_files_for_dependency(deplib).each do |inc|
-        updates[:collection_all_headers] << inc
-      end
+    @ceedling[DEPENDENCIES_SYM].specs.each do |spec|
+      updates[:collection_paths_include].concat( spec.include_directories( path_collector ) )
+      updates[:collection_all_headers].concat( spec.include_files )
     end
 
     updates
   end
 
-  def get_name(deplib)
-    raise CeedlingException.new( "Each dependency must have a name!" ) if deplib[:name].nil?
-    return deplib[:name].gsub(/\W*/,'')
+  # Globbed include entries expand against the disk
+  def path_collector
+    return ->( glob ) { @ceedling[:file_path_collection_utils].collect_paths( [glob] ) }
   end
 
-  def get_fetch_path(deplib)
-    if deplib.include? :paths
-      return deplib[:paths][:fetch] || deplib[:paths][:source] || File.join('dependencies', get_name(deplib))
-    else
-      return File.join('dependencies', get_name(deplib))
-    end
+  def spec_for(key)
+    return @lookup[key] || raise( CeedlingException.new( "Could not find dependency '#{key}'" ) )
   end
 
-  def get_source_path(deplib)
-    if deplib.include? :paths
-      return deplib[:paths][:source] || deplib[:paths][:fetch] || File.join('dependencies', get_name(deplib))
-    else
-      return File.join('dependencies', get_name(deplib))
+  # Fetches, then builds, a dependency inside its environment
+  def make_if_required(key)
+    spec = spec_for( key )
+    environment_for( spec ).apply do
+      fetch_dependency( spec )
+      build_dependency( spec )
     end
   end
 
-  def get_build_path(deplib)
-    if deplib.include? :paths
-      return deplib[:paths][:build] || deplib[:paths][:source] || deplib[:paths][:fetch] || File.join('dependencies', get_name(deplib))
-    else
-      return File.join('dependencies', get_name(deplib))
-    end
+  def fetch_if_required(key)
+    spec = spec_for( key )
+    environment_for( spec ).apply { fetch_dependency( spec ) }
   end
 
-  def get_artifact_path(deplib)
-    if deplib.include? :paths
-      return deplib[:paths][:artifact] || deplib[:paths][:build] || File.join('dependencies', get_name(deplib))
-    else
-      return File.join('dependencies', get_name(deplib))
+  # A fetched dependency's every working path goes, so a later fetch gets a fresh copy.
+  # A dependency that is not fetched keeps its source, losing only its artifacts.
+  def clean_if_required(key)
+    spec = spec_for( key )
+
+    if spec.fetch_method.nil?
+      log( "Nothing to clean for dependency #{spec.name}" )
+      return
     end
-  end
 
-  def get_working_paths(deplib, artifact_only=false)
-    paths = if deplib.include?(:paths)
-      if artifact_only
-        [deplib[:paths][:artifact]].compact.uniq
-      else
-        deplib[:paths].values.compact.uniq
-      end
-    else
-      []
+    log( "Cleaning dependency #{spec.name}..." )
+    spec.working_paths( artifacts_only: spec.fetch_method == :none ).each do |path|
+      @ceedling[:file_wrapper].rm_rf( path ) if @ceedling[:file_wrapper].directory?( path )
     end
-    paths = [ File.join('dependencies', get_name(deplib)) ] if (paths.empty?)
-    return paths
   end
 
-  def get_static_libraries_for_dependency(deplib)
-    (deplib[:artifacts][:static_libraries] || []).map {|path| File.join(get_artifact_path(deplib), path)}
-  end
+  # Copies every dynamic library and executable to the deploy path, by default beside the
+  # release build, where they run from
+  def deploy_if_required(key)
+    spec      = spec_for( key )
+    artifacts = spec.dynamic_libraries + spec.executables
 
-  def get_dynamic_libraries_for_dependency(deplib)
-    (deplib[:artifacts][:dynamic_libraries] || []).map {|path| File.join(get_artifact_path(deplib), path)}
-  end
+    if artifacts.empty?
+      log( "Nothing to deploy for dependency #{spec.name}" )
+      return
+    end
 
-  def get_source_files_for_dependency(deplib)
-    (deplib[:artifacts][:source] || []).map {|path| File.join(get_artifact_path(deplib), path)}
-  end
+    log( "Deploying dependency #{spec.name}..." )
+    destination = spec.deploy_path( File.dirname( PROJECT_RELEASE_BUILD_TARGET ) )
+    @ceedling[:file_wrapper].mkdir( destination )
 
-  def get_include_directories_for_dependency(deplib)
-    paths = (deplib[:artifacts][:includes] || []).map do |path| 
-      if (path =~ /.*\.h$/)
-        path.split(/[\/\\]/)[0..-2]
-      elsif (path =~ /(?:^\+:)|(?:^-:)|(?:\*\*)/)
-        @ceedling[:file_path_collection_utils].collect_paths([path])
-      else
-        path
+    # The deploy task builds missing artifacts first, so one still missing was never made
+    artifacts.each do |artifact|
+      unless @ceedling[:file_wrapper].exist?( artifact )
+        raise CeedlingException.new(
+          "Dependency `#{spec.name}` has no #{artifact} to deploy: its build did not produce it. Check its :build steps and :artifacts."
+        )
       end
+
+      @ceedling[:file_wrapper].cp( artifact, destination )
     end
-    return paths.map{|path| File.join(get_artifact_path(deplib), path) }.uniq 
   end
 
-  def get_include_files_for_dependency(deplib)
-    (deplib[:artifacts][:includes] || []).map {|path| File.join(get_artifact_path(deplib), path)}
-  end
+  # Library names and their directories, for test and release linking
+  def link_libraries
+    libraries = @specs.flat_map { |spec| spec.static_libraries + spec.dynamic_libraries }
 
-  def set_env_if_required(lib_path)
-    blob = @dependencies[lib_path]
-    raise CeedlingException.new( "Could not find dependency '#{lib_path}'" ) if blob.nil?
-    return if (blob[:environment].nil?)
-    return if (blob[:environment].empty?)
-
-    blob[:environment].each do |e|
-      m = e.match(/^(\w+)\s*(\+?\-?=)\s*(.*)$/)
-      unless m.nil?
-        case m[2]
-        when "+="
-          ENV[m[1]] = (ENV[m[1]] || "") + m[3]
-        when "-="
-          ENV[m[1]] = (ENV[m[1]] || "").gsub(m[3],'')
-        else
-          ENV[m[1]] = m[3]
-        end
-      end
-    end
+    return {
+      names: libraries.map { |library| File.basename( library, '.*' ).delete_prefix( 'lib' ) }.reject( &:empty? ).uniq,
+      paths: libraries.map { |library| File.dirname( library ) }.reject( &:empty? ).uniq
+    }
   end
 
-  def generate_command_line(cmdline, name=nil)
-    # Break apart command line at white spaces
-    cmdline_items = cmdline.split(/\s+/)
+  # Adds each dependency's include directories, headers, and sources to the collections
+  # test and release builds search
+  def add_headers_and_sources()
+    cfg = @ceedling[:configurator].project_config_hash
 
-    # Even though it may seem redundant to build a command line we already have,
-    # we do so for possible argument expansion/substitution and, more importantly, logging output.
+    @specs.each do |spec|
+      add_include_directories( cfg, spec.include_directories( path_collector ) )
 
-    # Construct a tool configuration
-    tool_config = { 
-      # Use tool name if provided, otherwise, grab something from the command line
-      :name => name.nil? ? cmdline_items[0] : name,
+      spec.include_files.each do |header|
+        cfg[:collection_all_headers] << header
+        ((cfg[:files] ||= {})[:include] ||= []) << header
+      end
 
-      # Extract executable as first item on the command line
-      :executable => cmdline_items[0],
+      spec.source_paths.each { |source| add_source_path( cfg, source ) }
+    end
+  end
 
-      # Extract remaining arguments if there are any
-      :arguments => (cmdline_items.length > 1) ? cmdline_items[1..-1] : []
-    }
+  ### Private ###
+
+  private
 
-    # Construct a command from our tool configuration
-    command = @ceedling[:tool_executor].build_command_line( tool_config, [] )
+  def log(message, verbosity = Verbosity::NORMAL)
+    @ceedling[:loginator].log( message, verbosity )
+  end
 
-    return command
+  # A dependency's :environment, in effect only while its own commands run. Named apart
+  # from Plugin#environment, which Ceedling reads when it loads a plugin.
+  def environment_for(spec)
+    return DependencyEnvironment.new( spec.environment, dependency: spec.name )
   end
 
-  def fetch_if_required(lib_path)
-    blob = @dependencies[lib_path]
+  # The commands that fetch and build dependencies, from the plugin's configured tools
+  def commands
+    tools = { zip: TOOLS_DEPS_ZIP, tar_gzip: TOOLS_DEPS_TARGZIP, git_clone: TOOLS_DEPS_GIT_CLONE,
+              git_checkout: TOOLS_DEPS_GIT_CHECKOUT, subversion: TOOLS_DEPS_SUBVERSION }
+    builder = ->( tool, *args ) { @ceedling[:tool_executor].build_command_line( tool, [], *args ) }
 
-    raise CeedlingException.new( "Could not find dependency '#{lib_path}'" ) if blob.nil?
+    return @commands ||= DependencyCommands.new( tools: tools, builder: builder )
+  end
 
-    if (blob[:fetch].nil?) || (blob[:fetch][:method].nil?)
-      @ceedling[:loginator].log("No fetch method for dependency '#{blob[:name]}'", Verbosity::COMPLAIN)
-      return
-    end
+  # The one place this plugin changes directory, around a dependency's own commands
+  def in_directory(path, &block)
+    Dir.chdir( path, &block )
+  end
 
-    unless (directory(get_source_path(blob)))
-      @ceedling[:loginator].log("Path #{get_source_path(blob)} is required", Verbosity::COMPLAIN)
+  # A fetch path that already holds files is taken as fetched, so fetching again, or
+  # building after a fetch, leaves it alone. Cleaning the dependency allows a fresh fetch.
+  def fetch_dependency(spec)
+    if spec.fetch_method.nil?
+      log( "No fetch method for dependency '#{spec.name}'", Verbosity::COMPLAIN )
       return
     end
 
-    FileUtils.mkdir_p(get_fetch_path(blob)) unless File.exist?(get_fetch_path(blob))
-
-    steps = []
-
-    # Tools already validated within `setup()`
-    case blob[:fetch][:method]
-    when :none
-      # Do nothing
-
-    when :zip
-      steps <<
-      @ceedling[:tool_executor].build_command_line(
-        TOOLS_DEPS_ZIP,
-        # No additional arguments
-        [],
-        # Argument replacement
-        blob[:fetch][:source]
-      )
-
-    when :tar_gzip
-      steps <<
-      @ceedling[:tool_executor].build_command_line(
-        TOOLS_DEPS_TARGZIP,
-        # No additional arguments
-        [],
-        # Argument replacement
-        blob[:fetch][:source]
-      )
-
-    when :git
-      branch = blob[:fetch][:tag] || blob[:fetch][:branch] || ''
-      branch = '-b ' + branch unless branch.empty?
-
-      unless blob[:fetch][:hash].nil?
-        # Do a deep clone to ensure the commit we want is available
-        steps <<
-        @ceedling[:tool_executor].build_command_line(
-          TOOLS_DEPS_GIT_CLONE,
-          # No additional arguments
-          [],
-          # Argument replacement
-          branch,
-          '', # No depth
-          blob[:fetch][:source]
-        )
+    # A dependency fetched by :none is already where its paths say
+    return if spec.fetch_method == :none
 
-        # Checkout the specified commit
-        steps <<
-        @ceedling[:tool_executor].build_command_line(
-          TOOLS_DEPS_GIT_CHECKOUT,
-          # No additional arguments
-          [],
-          # Argument replacement
-          blob[:fetch][:hash]
-        )
-      else
-        # Do a thin clone
-        steps <<
-        @ceedling[:tool_executor].build_command_line(
-          TOOLS_DEPS_GIT_CLONE,
-          # No additional arguments
-          [],
-          # Argument replacement
-          branch,
-          '--depth 1',
-          blob[:fetch][:source]
-        )
-      end
-    
-    when :svn
-      revision = blob[:fetch][:revision] || ''
-      revision = '--revision ' + revision unless revision.empty?
-
-      steps <<
-      @ceedling[:tool_executor].build_command_line(
-        TOOLS_DEPS_SUBVERSION,
-        # No additional arguments
-        [],
-        # Argument replacement
-        revision,
-        blob[:fetch][:source]
-      )
-    
-    when :custom
-      blob[:fetch][:executable].each.with_index(1) do |cmdline, index|
-        steps << generate_command_line( cmdline, "Dependencies custom command \##{index}" )
-      end
+    path = spec.fetch_path
+    if @ceedling[:file_wrapper].directory?( path ) and !@ceedling[:file_wrapper].directory_entries( path ).empty?
+      log( "Dependency #{spec.name} is already fetched in #{path}. Clean it to fetch it again." )
+      return
     end
 
-    # Perform the actual fetching
-    @ceedling[:loginator].log("Fetching dependency #{blob[:name]}...", Verbosity::NORMAL)
-    Dir.chdir(get_fetch_path(blob)) do
-      steps.each do |step|
-        @ceedling[:tool_executor].exec( step )
-      end
-    end
+    check_tools( *fetch_tools( spec.fetch_method ) )
+    log( "Fetching dependency #{spec.name}..." )
+    @ceedling[:file_wrapper].mkdir( path )
+    steps = commands.fetch( spec )
+    in_directory( path ) { steps.each { |step| @ceedling[:tool_executor].exec( step ) } }
   end
 
-  def build_if_required(lib_path)
-    blob = @dependencies[lib_path]
-    raise CeedlingException.new( "Could not find dependency '#{lib_path}'" ) if blob.nil?
-
-    # We don't clean anything unless we know how to fetch a new copy
-    if (blob[:build].nil? || blob[:build].empty?)
-      @ceedling[:loginator].log("Nothing to build for dependency #{blob[:name]}", Verbosity::NORMAL)
+  # Build commands run from the source path; built-in steps use project paths
+  def build_dependency(spec)
+    if spec.build_steps.empty?
+      log( "Nothing to build for dependency #{spec.name}" )
       return
     end
 
-    FileUtils.mkdir_p(get_source_path(blob)) unless File.exist?(get_source_path(blob))
-    FileUtils.mkdir_p(get_artifact_path(blob)) unless File.exist?(get_artifact_path(blob))
-
-    # Perform the build
-    @ceedling[:loginator].log("Building dependency #{blob[:name]}...", Verbosity::NORMAL)
-    Dir.chdir(get_source_path(blob)) do
-      blob[:build].each do |step|
-        if (step.class == Symbol)
-          exec_dependency_builtin_command(step, blob)
-        else
-          @ceedling[:tool_executor].exec( generate_command_line(step) )
-        end
-      end
-    end
-  end
+    [spec.source_path, spec.build_path, spec.artifact_path].uniq.each { |path| @ceedling[:file_wrapper].mkdir( path ) }
 
-  def clean_if_required(lib_path)
-    blob = @dependencies[lib_path]
-    raise CeedlingException.new( "Could not find dependency '#{lib_path}'" ) if blob.nil?
+    log( "Building dependency #{spec.name}..." )
+    commands.build( spec ).each do |step|
+      next build_builtin( step, spec ) if step.is_a?( Symbol )
 
-    # We don't clean anything unless we know how to fetch a new copy
-    if (blob[:fetch].nil? || blob[:fetch][:method].nil?)
-      @ceedling[:loginator].log("Nothing to clean for dependency #{blob[:name]}", Verbosity::NORMAL)
-      return
+      in_directory( spec.source_path ) { @ceedling[:tool_executor].exec( step ) }
     end
+  end
 
-    # We only need to clean the artifacts if the source isn't being fetched
-    artifacts_only = (blob[:fetch][:method] == :none)
+  def build_builtin(step, spec)
+    return build_lib( spec ) if step == :build_lib
 
-    # Perform the actual Cleaning
-    @ceedling[:loginator].log("Cleaning dependency #{blob[:name]}...", Verbosity::NORMAL)
-    get_working_paths(blob, artifacts_only).each do |path|
-      FileUtils.rm_rf(path) if File.directory?(path)
-    end
+    raise CeedlingException.new( "No such build action as #{step.inspect} for dependency #{spec.name}" )
   end
 
-  def deploy_if_required(lib_path)
-    blob = @dependencies[lib_path]
-    raise CeedlingException.new( "Could not find dependency '#{lib_path}'" ) if blob.nil?
+  # Compiles every C and assembly file under the source path, archives the objects into
+  # the dependency's first static library in the build path, and copies that library to
+  # the artifact path when the two differ
+  def build_lib(spec)
+    library = spec.static_library_entries.first or
+      raise CeedlingException.new( "Dependency `#{spec.name}` needs a :static_libraries entry for :build_lib to build." )
 
-    # We don't need to deploy anything if there isn't anything to deploy
-    if (blob[:artifacts].nil? || blob[:artifacts][:dynamic_libraries].nil? || blob[:artifacts][:dynamic_libraries].empty?)
-      @ceedling[:loginator].log("Nothing to deploy for dependency #{blob[:name]}", Verbosity::NORMAL)
-      return
-    end
+    sources, assembly, search_paths = build_lib_inputs( spec )
+    check_tools( *(sources.empty? ? [] : [TOOLS_DEPS_COMPILER]), *(assembly.empty? ? [] : [TOOLS_DEPS_ASSEMBLER]), TOOLS_DEPS_LINKER )
+    objects = sources.map { |source| compile( spec, source, search_paths ) } +
+              assembly.map { |source| assemble( spec, source ) }
 
-    # Perform the actual Deploying
-    @ceedling[:loginator].log("Deploying dependency #{blob[:name]}...", Verbosity::NORMAL)
-    FileUtils.cp( lib_path, File.dirname(PROJECT_RELEASE_BUILD_TARGET) )
+    built = File.join( spec.build_path, library )
+    @ceedling[:file_wrapper].mkdir( File.dirname( built ) )
+    @ceedling[:generator].generate_executable_file(
+      TOOLS_DEPS_LINKER, DEPENDENCIES_SYM, objects, [], built,
+      @ceedling[:file_path_utils].form_test_build_map_filepath( spec.artifact_path, library ),
+      spec.libraries, spec.libpaths
+    )
+
+    copy_library( built, File.join( spec.artifact_path, library ) ) unless spec.build_path == spec.artifact_path
   end
 
-  def add_headers_and_sources()
-    # Search for header file paths and files to add to our collections
-    cfg = @ceedling[:configurator].project_config_hash
+  # Sources, assembly files, and the search paths to compile them with: every directory
+  # holding a header under the source path, plus any the dependency names
+  def build_lib_inputs(spec)
+    sources  = listing( spec, EXTENSION_SOURCE )
+    assembly = (defined?( EXTENSION_ASSEMBLY ) and EXTENSION_ASSEMBLY.any?) ? listing( spec, EXTENSION_ASSEMBLY ) : []
+    headers  = listing( spec, EXTENSION_HEADER ).map { |header| File.dirname( header ) }.uniq
 
-    DEPENDENCIES_DEPS.each do |deplib|
-      get_include_directories_for_dependency(deplib).each do |header|
-        cfg[:collection_paths_include] << header
-        cfg[:collection_paths_source_and_include] << header
-        cfg[:collection_paths_test_support_source_include] << header
-        cfg[:collection_paths_test_support_source_include_vendor] << header
-        cfg[:collection_paths_release_toolchain_include] << header
-      end
+    raise CeedlingException.new( "Dependency `#{spec.name}` has nothing under #{spec.source_path} to build." ) if sources.empty? and assembly.empty?
+    raise CeedlingException.new( "No assembler specified for building dependency `#{spec.name}`." ) unless assembly.empty? or defined?( TOOLS_DEPS_ASSEMBLER )
 
-      get_include_files_for_dependency(deplib).each do |header|
-        cfg[:collection_all_headers] << header
+    search_paths = headers + spec.build_lib_search_paths
 
-        cfg[:files] ||= {}
-        cfg[:files][:include] ||= []
-        cfg[:files][:include] << header
-      end
+    # Custom compiler configurations may still read these, set once per dependency
+    replace_constant( :COLLECTION_PATHS_DEPS, search_paths )
+    replace_constant( :COLLECTION_DEFINES_DEPS, spec.defines )
 
-      get_source_files_for_dependency(deplib).each do |source|
-        cfg[:collection_paths_source_and_include] << source
-        cfg[:collection_paths_test_support_source_include] << source
-        cfg[:collection_paths_test_support_source_include_vendor] << source
-        cfg[:collection_paths_release_toolchain_include] << source
-        Dir[ File.join(source, "*#{EXTENSION_SOURCE}") ].each do |f|
-          cfg[:collection_all_source] << f
-        end
-      end
-    end
+    return sources, assembly, search_paths
   end
 
-  def exec_dependency_builtin_command(step, blob)
-    case step
-    when :build_lib # We are going to use our defined deps tools to build this library
-      build_lib(blob)
-    else 
-      raise CeedlingException.new( "No such build action as #{step.inspect} for dependency #{blob[:name]}" ) 
+  # Every file of a type anywhere under the dependency's source path
+  def listing(spec, extension)
+    return extension.glob_patterns( File.join( spec.source_path, '**' ) ).flat_map do |glob|
+      @ceedling[:file_wrapper].directory_listing( glob )
     end
   end
 
-  def build_lib(blob)
-    src = []
-    asm = []
-    hdr = []
-    obj = []
-
-    name = blob[:name] || ""
-    source_path = Pathname.new get_source_path(blob)
-    build_path = Pathname.new get_build_path(blob)
-    relative_build_path = begin
-      build_path.relative_path_from(source_path)
-    rescue StandardError
-      build_path 
-    end
-
-    # Verify there is an artifact that we're building that makes sense
-    libs = []
-    raise CeedlingException.new( "No library artifacts specified for dependency #{name}" ) unless blob.include?(:artifacts)
-    libs += blob[:artifacts][:static_libraries] if blob[:artifacts].include?(:static_libraries)
-    libs += blob[:artifacts][:static_libraries] if blob[:artifacts].include?(:static_libraries)
-    libs = libs.flatten.uniq
-    raise CeedlingException.new( "No library artifacts specified for dependency #{name}" ) if libs.empty?
-    lib = libs[0]
-
-    # Find all the source, header, and assembly files 
-    src = Dir["./**/*#{EXTENSION_SOURCE}"]
-    hdr = Dir["./**/*#{EXTENSION_HEADER}"].map{|f| File.dirname(f) }.uniq
-    if (EXTENSION_ASSEMBLY && !EXTENSION_ASSEMBLY.empty?)  
-      asm = Dir["./**/*#{EXTENSION_ASSEMBLY}"]
-    end
-
-    # Do we have what we need to do this?
-    raise CeedlingException.new( "Nothing to build" ) if (asm.empty? and src.empty?)
-    raise CeedlingException.new( "No assembler specified for building dependency #{name}" ) unless (defined?(TOOLS_DEPS_ASSEMBLER) || asm.empty?)
-    raise CeedlingException.new( "No compiler specified for building dependency #{name}" ) unless (defined?(TOOLS_DEPS_COMPILER) || src.empty?)
-    raise CeedlingException.new( "No linker specified for building dependency #{name}" ) unless defined?(TOOLS_DEPS_LINKER)
-
-    # Build all the source files
-    src.each do |src_file|
-      object_file = relative_build_path + File.basename(src_file).ext(EXTENSION_OBJECT)
-      @ceedling[DEPENDENCIES_SYM].replace_constant(:COLLECTION_PATHS_DEPS, find_my_paths(src_file, blob))
-      @ceedling[DEPENDENCIES_SYM].replace_constant(:COLLECTION_DEFINES_DEPS, find_my_defines(src_file, blob))
-      @ceedling[:generator].generate_object_file_c(
-        tool:         TOOLS_DEPS_COMPILER,
-        module_name:  File.basename(src_file).ext(),
-        context:      DEPENDENCIES_SYM,
-        source:       src_file,
-        object:       object_file,
-        search_paths: hdr,
-        flags:        (blob[:flags] || []),
-        defines:      (blob[:defines] || []),
-        list:         @ceedling[:file_path_utils].form_release_build_list_filepath( File.basename(src_file,EXTENSION_OBJECT) )
-      )
-      obj << object_file
-    end 
-
-    # Build all the assembly files
-    asm.each do |src_file|
-      object_file = relative_build_path + File.basename(src_file).ext(EXTENSION_OBJECT)
-      @ceedling[DEPENDENCIES_SYM].replace_constant(:COLLECTION_PATHS_DEPS, find_my_paths(src_file, blob))
-      @ceedling[DEPENDENCIES_SYM].replace_constant(:COLLECTION_DEFINES_DEPS, find_my_defines(src_file, blob))
-      @ceedling[:generator].generate_object_file_asm(
-        tool:        TOOLS_DEPS_ASSEMBLER,
-        module_name: File.basename(src_file).ext(),
-        context:     DEPENDENCIES_SYM,
-        source:      src_file,
-        object:      object_file
-      )
-      obj << object_file
-    end
-
-    # Link the library
-    @ceedling[:generator].generate_executable_file(
-      TOOLS_DEPS_LINKER,
-      DEPENDENCIES_SYM,
-      obj,
-      [],
-      relative_build_path+lib,
-      @ceedling[:file_path_utils].form_test_build_map_filepath(get_artifact_path(blob),lib),
-      (blob[:libraries] || []),
-      (blob[:libpaths] || [])
+  def compile(spec, source, search_paths)
+    object = object_for( spec, source )
+    @ceedling[:generator].generate_object_file_c(
+      tool:         TOOLS_DEPS_COMPILER,
+      module_name:  File.basename( source ).ext,
+      context:      DEPENDENCIES_SYM,
+      source:       source,
+      object:       object,
+      search_paths: search_paths,
+      flags:        spec.flags,
+      defines:      spec.defines,
+      list:         @ceedling[:file_path_utils].form_release_build_list_filepath( File.basename( source ).ext )
     )
-
-    # Move the library to the specifed artifact folder
-    unless get_build_path(blob) == get_artifact_path(blob)
-      src = File.expand_path(lib)
-      dst = File.expand_path(get_artifact_path(blob), Array.new(get_build_path(blob).split(/[\\\/]+/).length,"../").join()) + "/" + lib
-      FileUtils.cp_r(src, dst)
-    end
+    return object
   end
 
-  def find_my_paths( c_file, blob, file_type = :c )  
-    return ((blob[:source] || []) + (blob[:include] || [])).compact.uniq
-  end  
-
-  def find_my_defines( c_file, blob, file_type = :c )  
-    return (blob[:defines] || []).compact.uniq 
-  end  
-
-  def replace_constant(constant, new_value)  
-    Object.send(:remove_const, constant.to_sym) if (Object.const_defined? constant)  
-    Object.const_set(constant, new_value)  
+  def assemble(spec, source)
+    object = object_for( spec, source )
+    @ceedling[:generator].generate_object_file_asm(
+      tool: TOOLS_DEPS_ASSEMBLER, module_name: File.basename( source ).ext, context: DEPENDENCIES_SYM,
+      source: source, object: object
+    )
+    return object
   end
 
-  ### Private ###
+  def object_for(spec, source)
+    return File.join( spec.build_path, File.basename( source ).ext( EXTENSION_OBJECT.primary ) )
+  end
 
-  private
+  def copy_library(built, destination)
+    @ceedling[:file_wrapper].mkdir( File.dirname( destination ) )
+    @ceedling[:file_wrapper].cp( built, destination )
+  end
 
-  def validate_fetch_tools(blob)
-    return if blob[:fetch].nil? || blob[:fetch][:method].nil?
+  def replace_constant(constant, new_value)
+    Object.send( :remove_const, constant ) if Object.const_defined?( constant )
+    Object.const_set( constant, new_value )
+  end
 
-    case blob[:fetch][:method]
-    when :none
-      # Do nothing
+  INCLUDE_COLLECTIONS = %i[collection_paths_include collection_paths_source_and_include collection_paths_test_support_source_include
+                           collection_paths_test_support_source_include_vendor collection_paths_release_toolchain_include].freeze
 
-    when :zip
-      @ceedling[:tool_validator].validate( tool:TOOLS_DEPS_ZIP, boom:true )
+  def add_include_directories(cfg, directories)
+    directories.each { |directory| INCLUDE_COLLECTIONS.each { |key| cfg[key] << directory } }
+  end
 
-    when :tar_gzip
-      @ceedling[:tool_validator].validate( tool:TOOLS_DEPS_TARGZIP, boom:true )
+  # A source path joins the search collections, and its C files join the source collection
+  def add_source_path(cfg, source)
+    INCLUDE_COLLECTIONS.drop( 1 ).each { |key| cfg[key] << source }
 
-    when :git
-      @ceedling[:tool_validator].validate( tool:TOOLS_DEPS_GIT_CLONE, boom:true )
-      @ceedling[:tool_validator].validate( tool:TOOLS_DEPS_GIT_CHECKOUT, boom: true )
+    EXTENSION_SOURCE.glob_patterns( source ).each do |glob|
+      cfg[:collection_all_source].concat( @ceedling[:file_wrapper].directory_listing( glob ) )
+    end
+  end
 
-    when :svn
-      @ceedling[:tool_validator].validate( tool:TOOLS_DEPS_SUBVERSION, boom: true )
+  # The tools a fetch method runs. Unknown methods are already refused by DependencySpec.
+  def fetch_tools(method)
+    return { zip: [TOOLS_DEPS_ZIP], tar_gzip: [TOOLS_DEPS_TARGZIP], git: [TOOLS_DEPS_GIT_CLONE, TOOLS_DEPS_GIT_CHECKOUT],
+             svn: [TOOLS_DEPS_SUBVERSION] }.fetch( method, [] )
+  end
 
-    when :custom
-      # Do nothing
+  # Each tool is checked once, just before its first use, so a tool only some dependency
+  # or task needs never becomes a requirement of every Ceedling command
+  def check_tools(*tools)
+    @checked_tools ||= []
+    tools.each do |tool|
+      next if @checked_tools.include?( tool )
 
-    else
-      raise CeedlingException.new( "Unknown fetch method '#{blob[:fetch][:method]}' for dependency '#{blob[:name]}'" )
+      @ceedling[:tool_validator].validate( tool: tool, boom: true )
+      @checked_tools << tool
     end
   end
 
 end
-
-
-# end blocks always executed following rake run
-END {
-}