ceedling 0.31.1 → 1.0.1

data/lib/ceedling/rakefile.rb

@@ -1,85 +1,145 @@
-require 'fileutils'
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
 
-# get directory containing this here file, back up one directory, and expand to full path
-CEEDLING_ROOT    = File.expand_path(File.dirname(__FILE__) + '/../..')
-CEEDLING_LIB     = File.join(CEEDLING_ROOT, 'lib')
-CEEDLING_VENDOR  = File.join(CEEDLING_ROOT, 'vendor')
-CEEDLING_RELEASE = File.join(CEEDLING_ROOT, 'release')
+require 'fileutils'
 
-$LOAD_PATH.unshift( CEEDLING_LIB )
-$LOAD_PATH.unshift( File.join(CEEDLING_VENDOR, 'unity/auto') )
-$LOAD_PATH.unshift( File.join(CEEDLING_VENDOR, 'diy/lib') )
-$LOAD_PATH.unshift( File.join(CEEDLING_VENDOR, 'cmock/lib') )
+# Add Unity and CMock's Ruby code paths to $LOAD_PATH for runner generation and mocking
+$LOAD_PATH.unshift( File.join( CEEDLING_APPCFG[:ceedling_vendor_path], 'unity/auto') )
+$LOAD_PATH.unshift( File.join( CEEDLING_APPCFG[:ceedling_vendor_path], 'cmock/lib') )
 
 require 'rake'
 
-#Let's make sure we remember the task descriptions in case we need them
+# Let's make sure we remember the task descriptions in case we need them
 Rake::TaskManager.record_task_metadata = true
 
-require 'diy'
-require 'constructor'
-
-require 'ceedling/constants'
-require 'ceedling/target_loader'
-
-
-# construct all our objects
-# ensure load path contains all libraries needed first
-lib_ceedling_load_path_temp = File.join(CEEDLING_LIB, 'ceedling')
-$LOAD_PATH.unshift( lib_ceedling_load_path_temp )
-@ceedling = DIY::Context.from_yaml( File.read( File.join(lib_ceedling_load_path_temp, 'objects.yml') ) )
-@ceedling.build_everything
-# now that all objects are built, delete 'lib/ceedling' from load path
-$LOAD_PATH.delete(lib_ceedling_load_path_temp)
-# one-stop shopping for all our setup and such after construction
-@ceedling[:setupinator].ceedling = @ceedling
-
-project_config =
-  begin
-    cfg = @ceedling[:setupinator].load_project_files
-    TargetLoader.inspect(cfg, ENV['TARGET'])
-  rescue TargetLoader::NoTargets
-    cfg
-  rescue TargetLoader::RequestReload
-    @ceedling[:setupinator].load_project_files
+require 'ceedling/system_wrapper'
+require 'ceedling/reportinator'
+
+# Operation duration logging
+def log_runtime(run, start_time_s, end_time_s, enabled)
+  return if !enabled
+  return if !defined?(PROJECT_VERBOSITY)
+  return if (PROJECT_VERBOSITY < Verbosity::NORMAL)
+
+  duration = Reportinator.generate_duration( start_time_s: start_time_s, end_time_s: end_time_s )
+
+  return if duration.empty?
+
+  @ceedling[:loginator].log() # Blank line
+  @ceedling[:loginator].log( "Ceedling #{run} completed in #{duration}", Verbosity::NORMAL)
+end
+
+start_time = nil # Outside scope of exception handling
+
+# Top-level exception handling for any otherwise un-handled exceptions, particularly around startup
+begin
+  # Redefine start_time with actual timestamp before set up begins
+  start_time = SystemWrapper.time_stopwatch_s()
+
+  # Construct all objects
+  #  1. Add full path to $LOAD_PATH to simplify objects.yml
+  #  2. Perform object construction + dependency injection
+  #  3. Remove full path from $LOAD_PATH
+  $LOAD_PATH.unshift( CEEDLING_APPCFG[:ceedling_lib_path] )
+  objects_filepath = File.join( CEEDLING_APPCFG[:ceedling_lib_path], 'objects.yml' )
+  
+  # Create object hash and dependency injection context
+  @ceedling = {} # Empty hash to be redefined if all goes well
+  @ceedling = DIY::Context.from_yaml( File.read( objects_filepath ) )
+
+  # Inject objects already insatantiated from bin/ bootloader before building the rest
+  CEEDLING_HANDOFF_OBJECTS.each_pair {|name,obj| @ceedling.set_object( name.to_s, obj )}
+
+  # Build Ceedling application's objects
+  @ceedling.build_everything()
+
+  # Simplify load path after construction
+  $LOAD_PATH.delete( CEEDLING_APPCFG[:ceedling_lib_path] )
+
+  # One-stop shopping for all our setup and such after construction
+  @ceedling[:setupinator].ceedling = @ceedling
+  @ceedling[:setupinator].do_setup( CEEDLING_APPCFG )
+
+  setup_done = SystemWrapper.time_stopwatch_s()
+  log_runtime( 'set up', start_time, setup_done, CEEDLING_APPCFG.build_tasks? )
+
+  # Configure high-level verbosity
+  unless defined?(PROJECT_DEBUG) and PROJECT_DEBUG
+    # Configure Ruby's default reporting for Thread exceptions.
+    # In Ceedling's case thread scenarios will fall into these buckets:
+    #  1. Jobs shut down cleanly
+    #  2. Jobs shut down at garbage collected after a build step terminates with an error
+    #
+    # Since Ceedling is not a daemon, server app, or something to run continuously,
+    # we can safely disable forced exception reporting.
+    Thread.report_on_exception = false
+
+    # Tell Rake to shut up by default unless we're in DEBUG
+    verbose(false)
+    Rake.application.options.silent = true
+
+    # Remove all Rake backtrace
+    Rake.application.options.suppress_backtrace_pattern = /.*/
   end
 
-@ceedling[:setupinator].do_setup( project_config )
-
-
-# tell all our plugins we're about to do something
-@ceedling[:plugin_manager].pre_build
+  # Reset start_time before operations begins
+  start_time = SystemWrapper.time_stopwatch_s()
 
-# load rakefile component files (*.rake)
-PROJECT_RAKEFILE_COMPONENT_FILES.each { |component| load(component) }
+  # Tell all our plugins we're about to do something
+  @ceedling[:plugin_manager].pre_build if CEEDLING_APPCFG.build_tasks?
 
-# tell rake to shut up by default (overridden in verbosity / debug tasks as appropriate)
-verbose(false)
+  # load rakefile component files (*.rake)
+  PROJECT_RAKEFILE_COMPONENT_FILES.each { |component| load(component) }
+rescue StandardError => ex
+  boom_handler( @ceedling[:loginator], ex )
+  exit(1)
+end
 
+def test_failures_handler()
+  # $stdout test reporting plugins store test failures
+  exit(1) if @ceedling[:plugin_manager].plugins_failed? && !CEEDLING_APPCFG.tests_graceful_fail?
+end
 
-# end block always executed following rake run
+# End block always executed following rake run
 END {
   $stdout.flush unless $stdout.nil?
   $stderr.flush unless $stderr.nil?
 
-  # cache our input configurations to use in comparison upon next execution
-  @ceedling[:cacheinator].cache_test_config( @ceedling[:setupinator].config_hash )    if (@ceedling[:task_invoker].test_invoked?)
-  @ceedling[:cacheinator].cache_release_config( @ceedling[:setupinator].config_hash ) if (@ceedling[:task_invoker].release_invoked?)
-
-  # delete all temp files unless we're in debug mode
-  if (not @ceedling[:configurator].project_debug)
-    @ceedling[:file_wrapper].rm_f( @ceedling[:file_wrapper].directory_listing( File.join(@ceedling[:configurator].project_temp_path, '*') ))
-  end
-
-  # only perform these final steps if we got here without runtime exceptions or errors
-  if (@ceedling[:system_wrapper].ruby_success)
-
-    # tell all our plugins the build is done and process results
-    @ceedling[:plugin_manager].post_build
-    @ceedling[:plugin_manager].print_plugin_failures
-    exit(1) if (@ceedling[:plugin_manager].plugins_failed? && !@ceedling[:setupinator].config_hash[:graceful_fail])
+  # Only perform these final steps if we got here without runtime exceptions or errors
+  if @ceedling[:application].build_succeeded?
+    # Tell all our plugins the build is done and process results
+    begin
+      if CEEDLING_APPCFG.build_tasks?
+        @ceedling[:plugin_manager].post_build
+        @ceedling[:plugin_manager].print_plugin_failures
+      end
+      ops_done = SystemWrapper.time_stopwatch_s()
+      log_runtime( 'operations', start_time, ops_done, CEEDLING_APPCFG.build_tasks? )
+      test_failures_handler() if (@ceedling[:task_invoker].test_invoked? || @ceedling[:task_invoker].invoked?(/^gcov:/))
+    rescue => ex
+      ops_done = SystemWrapper.time_stopwatch_s()
+      log_runtime( 'operations', start_time, ops_done, CEEDLING_APPCFG.build_tasks? )
+      boom_handler( @ceedling[:loginator], ex )
+      @ceedling[:loginator].wrapup
+      exit(1)
+    end
+
+    @ceedling[:loginator].wrapup
+    exit(0)
   else
-    puts "ERROR: Ceedling Failed"
-    @ceedling[:plugin_manager].post_error
+    msg = "Ceedling could not complete operations because of errors"
+    @ceedling[:loginator].log( msg, Verbosity::ERRORS, LogLabels::TITLE )
+    begin
+      @ceedling[:plugin_manager].post_error if CEEDLING_APPCFG.build_tasks?
+    rescue => ex
+      boom_handler( @ceedling[:loginator], ex)
+    ensure
+      @ceedling[:loginator].wrapup
+      exit(1)
+    end
   end
 }

data/lib/ceedling/release_invoker.rb

@@ -1,54 +1,24 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
 require 'ceedling/constants'
 
 
 class ReleaseInvoker
 
-  constructor :configurator, :release_invoker_helper, :build_invoker_utils, :dependinator, :task_invoker, :file_path_utils, :file_wrapper
-
-
-  def setup_and_invoke_c_objects( c_files )
-    objects = @file_path_utils.form_release_build_c_objects_filelist( c_files )
-
-    begin
-      @release_invoker_helper.process_deep_dependencies( @file_path_utils.form_release_dependencies_filelist( c_files ) )
-
-      @dependinator.enhance_release_file_dependencies( objects )
-      @task_invoker.invoke_release_objects( objects )
-    rescue => e
-      @build_invoker_utils.process_exception( e, RELEASE_SYM, false )
-    end
-
-    return objects
-  end
-
-
-  def setup_and_invoke_asm_objects( asm_files )
-    objects = @file_path_utils.form_release_build_asm_objects_filelist( asm_files )
+  constructor :configurator, :release_invoker_helper, :dependinator, :task_invoker, :file_path_utils, :file_wrapper
 
-    begin
-      @dependinator.enhance_release_file_dependencies( objects )
-      @task_invoker.invoke_release_objects( objects )
-    rescue => e
-      @build_invoker_utils.process_exception( e, RELEASE_SYM, false )
-    end
 
+  def setup_and_invoke_objects( files )
+    objects = @file_path_utils.form_release_build_objects_filelist( files )
+    @task_invoker.invoke_release_objects( objects )
     return objects
   end
 
-
-  def refresh_c_deep_dependencies
-    return if (not @configurator.project_use_deep_dependencies)
-
-    @file_wrapper.rm_f(
-      @file_wrapper.directory_listing(
-        File.join( @configurator.project_release_dependencies_path, '*' + @configurator.extension_dependencies ) ) )
-
-    @release_invoker_helper.process_deep_dependencies(
-      @file_path_utils.form_release_dependencies_filelist(
-        @configurator.collection_all_source ) )
-  end
-
-
   def artifactinate( *files )
     files.flatten.each do |file|
       @file_wrapper.cp( file, @configurator.project_release_artifacts_path ) if @file_wrapper.exist?( file )

data/lib/ceedling/release_invoker_helper.rb

@@ -1,19 +1,12 @@
-
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
 
 class ReleaseInvokerHelper
 
   constructor :configurator, :dependinator, :task_invoker
 
-
-  def process_deep_dependencies(dependencies_list)
-    return if (not @configurator.project_use_deep_dependencies)
-
-    if @configurator.project_generate_deep_dependencies
-      @dependinator.enhance_release_file_dependencies( dependencies_list )
-      @task_invoker.invoke_release_dependencies_files( dependencies_list )
-    end
-
-    @dependinator.load_release_object_deep_dependencies( dependencies_list )
-  end
-
 end

data/lib/ceedling/reportinator.rb

@@ -1,7 +1,74 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
+
+require 'unicode/display_width'
+
 ##
 # Pretifies reports
 class Reportinator
 
+  # Generate human readable string of days, hours, minutes, seconds (and 
+  # milliseconds) from a start count of seconds and end count of seconds.
+  def self.generate_duration(start_time_s:, end_time_s:)
+    return '' if start_time_s.nil? or end_time_s.nil?
+
+    # Calculate duration as integer milliseconds
+    duration_ms = ((end_time_s - start_time_s) * 1000).to_i
+
+    # Collect human readable time string tidbits
+    duration = []
+
+    # Singular / plural whole days
+    if duration_ms >= DurationCounts::DAY_MS
+      days = duration_ms / DurationCounts::DAY_MS
+      duration << "#{days} day#{'s' if days > 1}"
+      duration_ms -= (days * DurationCounts::DAY_MS)
+      # End duration string if remainder is less than 1 second (e.g. no 2 days 13 milliseconds)
+      duration_ms = 0 if duration_ms < 1000
+    end
+
+    # Singular / plural whole hours
+    if duration_ms >= DurationCounts::HOUR_MS
+      hours = duration_ms / DurationCounts::HOUR_MS
+      duration << "#{hours} hour#{'s' if hours > 1}"
+      duration_ms -= (hours * DurationCounts::HOUR_MS)
+      # End duration string if remainder is less than 1 second (e.g. no 2 days 13 milliseconds)
+      duration_ms = 0 if duration_ms < 1000
+    end
+
+    # Singular / plural whole minutes
+    if duration_ms >= DurationCounts::MINUTE_MS
+      minutes = duration_ms / DurationCounts::MINUTE_MS
+      duration << "#{minutes} minute#{'s' if minutes > 1}"
+      duration_ms -= (minutes * DurationCounts::MINUTE_MS)
+      # End duration string if remainder is less than 1 second (e.g. no 2 days 13 milliseconds)
+      duration_ms = 0 if duration_ms < 1000
+    end
+
+    # Plural fractional seconds (rounded)
+    if duration_ms >= DurationCounts::SECOND_MS
+      seconds = (duration_ms.to_f() / 1000.0).round(2)
+      duration << "#{seconds} seconds"
+      # End duration string
+      duration_ms = 0
+    end
+
+    # Singular / plural whole milliseconds (only if orginal duration less than 1 second)
+    if duration_ms > 0
+      duration << "#{duration_ms} millisecond#{'s' if duration_ms > 1}"
+    end
+
+    return duration.join(' ')
+  end
+
+  def generate_duration(start_time_s:, end_time_s:)
+    return Reportinator.generate_duration( start_time_s: start_time_s, end_time_s: end_time_s )
+  end
+
   ##
   # Generates a banner for a message based on the length of the message or a
   # given width.
@@ -19,8 +86,39 @@ class Reportinator
   #
   #
   def generate_banner(message, width=nil)
-    dash_count = ((width.nil?) ? message.strip.length : width)
+    # ---------
+    # <Message>
+    # ---------
+    dash_count = ((width.nil?) ? Unicode::DisplayWidth.of( message.strip ) : width)
     return "#{'-' * dash_count}\n#{message}\n#{'-' * dash_count}\n"
   end
 
+  def generate_heading(message)
+    # <Message>
+    # ---------
+    return "\n#{message}\n#{'-' * Unicode::DisplayWidth.of( message.strip )}"
+  end
+
+  def generate_progress(message)
+    # <Message>...
+    return "#{message}..."
+  end
+
+  def generate_module_progress(module_name:, filename:, operation:)
+    # <Operation [module_name::]filename>..."
+
+    # If filename is the module name, don't add the module label
+    label = (File.basename(filename).ext('') == module_name.to_s) ? '' : "#{module_name}::"
+    return generate_progress("#{operation} #{label}#{filename}")
+  end
+
+  def generate_config_walk(keys, depth=0)
+    # :key ↳ :key ↳ :key
+
+    _keys = keys.clone
+    _keys = _keys.slice(0, depth) if depth > 0
+    _keys.reject! { |key| key.nil? }
+    return _keys.map{|key| ":#{key}"}.join(' ↳ ')
+  end
+
 end

data/lib/ceedling/rules_release.rake

@@ -1,3 +1,9 @@
+# =========================================================================
+#   Ceedling - Test-Centered Build System for C
+#   ThrowTheSwitch.org
+#   Copyright (c) 2010-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+#   SPDX-License-Identifier: MIT
+# =========================================================================
 
 RELEASE_COMPILE_TASK_ROOT  = RELEASE_TASK_ROOT + 'compile:'  unless defined?(RELEASE_COMPILE_TASK_ROOT)
 RELEASE_ASSEMBLE_TASK_ROOT = RELEASE_TASK_ROOT + 'assemble:' unless defined?(RELEASE_ASSEMBLE_TASK_ROOT)
@@ -14,48 +20,51 @@ if (TOOLS_RELEASE_COMPILER[:executable] == DEFAULT_RELEASE_COMPILER_TOOL[:execut
   end
 end
 
-if (RELEASE_BUILD_USE_ASSEMBLY)
-rule(/#{PROJECT_RELEASE_BUILD_OUTPUT_ASM_PATH}\/#{'.+\\'+EXTENSION_OBJECT}$/ => [
+rule(/#{PROJECT_RELEASE_BUILD_OUTPUT_PATH}\/#{'.+' + Regexp.escape(EXTENSION_OBJECT)}$/ => [
     proc do |task_name|
-      @ceedling[:file_finder].find_assembly_file(task_name)
+      @ceedling[:file_finder].find_build_input_file(filepath: task_name, complain: :error, context: RELEASE_SYM)
     end
   ]) do |object|
-  @ceedling[:generator].generate_object_file(
-    TOOLS_RELEASE_ASSEMBLER,
-    OPERATION_ASSEMBLE_SYM,
-    RELEASE_SYM,
-    object.source,
-    object.name )
-end
-end
 
-
-rule(/#{PROJECT_RELEASE_BUILD_OUTPUT_C_PATH}\/#{'.+\\'+EXTENSION_OBJECT}$/ => [
-    proc do |task_name|
-      @ceedling[:file_finder].find_compilation_input_file(task_name, :error, true)
-    end
-  ]) do |object|
-  @ceedling[:generator].generate_object_file(
-    TOOLS_RELEASE_COMPILER,
-    OPERATION_COMPILE_SYM,
-    RELEASE_SYM,
-    object.source,
-    object.name,
-    @ceedling[:file_path_utils].form_release_build_c_list_filepath( object.name ),
-    @ceedling[:file_path_utils].form_release_dependencies_filepath( object.name ) )
+  if @ceedling[:file_wrapper].extname(object.source) != EXTENSION_ASSEMBLY
+    @ceedling[:generator].generate_object_file_c(
+      tool:         TOOLS_RELEASE_COMPILER,
+      module_name:  File.basename(object.source).ext(), # Source filename as module name
+      context:      RELEASE_SYM,
+      source:       object.source,
+      object:       object.name,
+      search_paths: COLLECTION_PATHS_INCLUDE,
+      flags:        @ceedling[:flaginator].flag_down( context:RELEASE_SYM, operation:OPERATION_COMPILE_SYM ),
+      defines:      @ceedling[:defineinator].defines( subkey:RELEASE_SYM ),
+      list:         @ceedling[:file_path_utils].form_release_build_list_filepath( object.name ),
+      dependencies: @ceedling[:file_path_utils].form_release_dependencies_filepath( object.name ) )
+  else
+    @ceedling[:generator].generate_object_file_asm(
+      tool:         TOOLS_RELEASE_ASSEMBLER,
+      module_name:  File.basename(object.source).ext(), # Source filename as module name
+      context:      RELEASE_SYM,
+      source:       object.source,
+      object:       object.name,
+      search_paths: COLLECTION_PATHS_INCLUDE,
+      flags:        @ceedling[:flaginator].flag_down( context:RELEASE_SYM, operation:OPERATION_ASSEMBLE_SYM ),
+      defines:      @ceedling[:defineinator].defines( subkey:RELEASE_SYM ),
+      list:         @ceedling[:file_path_utils].form_release_build_list_filepath( object.name ),
+      dependencies: @ceedling[:file_path_utils].form_release_dependencies_filepath( object.name ) )
+  end
 end
 
-
 rule(/#{PROJECT_RELEASE_BUILD_TARGET}/) do |bin_file|
   objects, libraries = @ceedling[:release_invoker].sort_objects_and_libraries(bin_file.prerequisites)
   tool      = TOOLS_RELEASE_LINKER.clone
   lib_args  = @ceedling[:release_invoker].convert_libraries_to_arguments(libraries)
   lib_paths = @ceedling[:release_invoker].get_library_paths_to_arguments()
   map_file  = @ceedling[:configurator].project_release_build_map
+
   @ceedling[:generator].generate_executable_file(
     tool,
     RELEASE_SYM,
     objects,
+    [], # Flags
     bin_file.name,
     map_file,
     lib_args,
@@ -63,34 +72,33 @@ rule(/#{PROJECT_RELEASE_BUILD_TARGET}/) do |bin_file|
   @ceedling[:release_invoker].artifactinate( bin_file.name, map_file, @ceedling[:configurator].release_build_artifacts )
 end
 
-
 namespace RELEASE_SYM do
-  # use rules to increase efficiency for large projects (instead of iterating through all sources and creating defined tasks)
+  # Use rules to increase efficiency for large projects (instead of iterating through all sources and creating defined tasks)
 
+  # Unadvertised Rake tasks to execute source file compilation
   namespace :compile do
-    rule(/^#{RELEASE_COMPILE_TASK_ROOT}\S+#{'\\'+EXTENSION_SOURCE}$/ => [ # compile task names by regex
+    rule(/^#{RELEASE_COMPILE_TASK_ROOT}\S+(#{Regexp.escape(EXTENSION_SOURCE)}|#{Regexp.escape(EXTENSION_CORE_SOURCE)})$/ => [ # compile task names by regex
         proc do |task_name|
           source = task_name.sub(/#{RELEASE_COMPILE_TASK_ROOT}/, '')
-          @ceedling[:file_finder].find_source_file(source, :error)
+          @ceedling[:file_finder].find_source_file(source)
         end
     ]) do |compile|
-      @ceedling[:rake_wrapper][:directories].invoke
-      @ceedling[:project_config_manager].process_release_config_change
-      @ceedling[:release_invoker].setup_and_invoke_c_objects( [compile.source] )
+      @ceedling[:rake_wrapper][:prepare].invoke
+      @ceedling[:release_invoker].setup_and_invoke_objects( [compile.source] )
     end
   end
 
+  # Unadvertised Rake tasks to execute source file assembly
   if (RELEASE_BUILD_USE_ASSEMBLY)
   namespace :assemble do
-    rule(/^#{RELEASE_ASSEMBLE_TASK_ROOT}\S+#{'\\'+EXTENSION_ASSEMBLY}$/ => [ # assemble task names by regex
+    rule(/^#{RELEASE_ASSEMBLE_TASK_ROOT}\S+#{Regexp.escape(EXTENSION_ASSEMBLY)}$/ => [ # assemble task names by regex
         proc do |task_name|
           source = task_name.sub(/#{RELEASE_ASSEMBLE_TASK_ROOT}/, '')
           @ceedling[:file_finder].find_assembly_file(source)
         end
     ]) do |assemble|
-      @ceedling[:rake_wrapper][:directories].invoke
-      @ceedling[:project_config_manager].process_release_config_change
-      @ceedling[:release_invoker].setup_and_invoke_asm_objects( [assemble.source] )
+      @ceedling[:rake_wrapper][:prepare].invoke
+      @ceedling[:release_invoker].setup_and_invoke_objects( [assemble.source] )
     end
   end
   end