ceedling 0.0.3 → 0.0.4

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

@@ -8,8 +8,8 @@ class PreprocessinatorFileHandler
   def preprocess_file(filepath, includes)
     preprocessed_filepath = @file_path_utils.form_preprocessed_file_filepath(filepath)
         
-    command_line = @tool_executor.build_command_line(@configurator.tools_test_file_preprocessor, filepath, preprocessed_filepath)
-    @tool_executor.exec(command_line)
+    command = @tool_executor.build_command_line(@configurator.tools_test_file_preprocessor, filepath, preprocessed_filepath)
+    @tool_executor.exec(command[:line], command[:options])
     
     contents = @preprocessinator_extractor.extract_base_file_from_preprocessed_expansion(preprocessed_filepath)
 

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

@@ -24,8 +24,8 @@ class PreprocessinatorIncludesHandler
     
     # extract the make-style dependency rule telling the preprocessor to 
     #  ignore the fact that it can't find the included files
-    command_line = @tool_executor.build_command_line(@configurator.tools_test_includes_preprocessor, temp_filepath)
-    shell_result = @tool_executor.exec(command_line)
+    command = @tool_executor.build_command_line(@configurator.tools_test_includes_preprocessor, temp_filepath)
+    shell_result = @tool_executor.exec(command[:line], command[:options])
     
     return shell_result[:output]
   end

data/new_project_template/vendor/ceedling/lib/rules_cmock.rake

@@ -5,5 +5,5 @@ rule(/#{CMOCK_MOCK_PREFIX}.+#{'\\'+EXTENSION_SOURCE}$/ => [
       @ceedling[:file_finder].find_header_input_for_mock_file(task_name)
     end  
   ]) do |mock|
-  @ceedling[:generator].generate_mock(TEST_CONTEXT, mock.source)
+  @ceedling[:generator].generate_mock(TEST_SYM, mock.source)
 end

data/new_project_template/vendor/ceedling/lib/rules_preprocess.rake

@@ -11,7 +11,7 @@ rule(/#{PROJECT_TEST_PREPROCESS_FILES_PATH}\/.+/ => [
   if (not @ceedling[:configurator].project_use_auxiliary_dependencies)
     raise 'ERROR: Ceedling preprocessing rule invoked though neccessary auxiliary dependency support not enabled.'
   end
-  @ceedling[:generator].generate_preprocessed_file(TEST_CONTEXT, file.source)
+  @ceedling[:generator].generate_preprocessed_file(TEST_SYM, file.source)
 end
 
 
@@ -21,6 +21,6 @@ rule(/#{PROJECT_TEST_PREPROCESS_INCLUDES_PATH}\/.+/ => [
       @ceedling[:file_finder].find_test_or_source_or_header_file(task_name)
     end  
   ]) do |file|
-  @ceedling[:generator].generate_shallow_includes_list(TEST_CONTEXT, file.source)
+  @ceedling[:generator].generate_shallow_includes_list(TEST_SYM, file.source)
 end
 

data/new_project_template/vendor/ceedling/lib/rules_release.rake

@@ -9,7 +9,7 @@ rule(/#{PROJECT_RELEASE_BUILD_OUTPUT_ASM_PATH}\/#{'.+\\'+EXTENSION_OBJECT}$/ =>
       @ceedling[:file_finder].find_assembly_file(task_name)
     end  
   ]) do |object|
-  @ceedling[:generator].generate_object_file(TOOLS_RELEASE_ASSEMBLER, RELEASE_CONTEXT, object.source, object.name)
+  @ceedling[:generator].generate_object_file(TOOLS_RELEASE_ASSEMBLER, RELEASE_SYM, object.source, object.name)
 end
 end
 
@@ -19,16 +19,16 @@ rule(/#{PROJECT_RELEASE_BUILD_OUTPUT_C_PATH}\/#{'.+\\'+EXTENSION_OBJECT}$/ => [
       @ceedling[:file_finder].find_compilation_input_file(task_name)
     end  
   ]) do |object|
-  @ceedling[:generator].generate_object_file(TOOLS_RELEASE_COMPILER, RELEASE_CONTEXT, object.source, object.name)
+  @ceedling[:generator].generate_object_file(TOOLS_RELEASE_COMPILER, RELEASE_SYM, object.source, object.name)
 end
 
 
 rule(/#{PROJECT_RELEASE_BUILD_TARGET}/) do |bin_file|
-  @ceedling[:generator].generate_executable_file(TOOLS_RELEASE_LINKER, RELEASE_CONTEXT, bin_file.prerequisites, bin_file.name)
+  @ceedling[:generator].generate_executable_file(TOOLS_RELEASE_LINKER, RELEASE_SYM, bin_file.prerequisites, bin_file.name)
 end
 
 
-namespace RELEASE_CONTEXT do
+namespace RELEASE_SYM do
   # use rules to increase efficiency for large projects (instead of iterating through all sources and creating defined tasks)
 
   namespace :compile do

data/new_project_template/vendor/ceedling/lib/rules_release_aux_dependencies.rake

@@ -7,7 +7,7 @@ rule(/#{PROJECT_RELEASE_DEPENDENCIES_PATH}\/#{'.+\\'+EXTENSION_DEPENDENCIES}$/ =
   ]) do |dep|
   @ceedling[:generator].generate_dependencies_file(
   	TOOLS_RELEASE_DEPENDENCIES_GENERATOR,
-  	RELEASE_CONTEXT,
+  	RELEASE_SYM,
   	dep.source,
   	@ceedling[:file_path_utils].form_release_build_c_object_filepath(dep.source),
   	dep.name)

data/new_project_template/vendor/ceedling/lib/rules_tests.rake

@@ -5,7 +5,7 @@ rule(/#{PROJECT_TEST_FILE_PREFIX}#{'.+'+TEST_RUNNER_FILE_SUFFIX}#{'\\'+EXTENSION
       @ceedling[:file_finder].find_test_input_for_runner_file(task_name)
     end
   ]) do |runner|
-  @ceedling[:generator].generate_test_runner(TEST_CONTEXT, runner.source, runner.name)
+  @ceedling[:generator].generate_test_runner(TEST_SYM, runner.source, runner.name)
 end
 
 
@@ -14,12 +14,12 @@ rule(/#{PROJECT_TEST_BUILD_OUTPUT_PATH}\/#{'.+\\'+EXTENSION_OBJECT}$/ => [
       @ceedling[:file_finder].find_compilation_input_file(task_name)
     end
   ]) do |object|
-  @ceedling[:generator].generate_object_file(TOOLS_TEST_COMPILER, TEST_CONTEXT, object.source, object.name)
+  @ceedling[:generator].generate_object_file(TOOLS_TEST_COMPILER, TEST_SYM, object.source, object.name)
 end
 
 
 rule(/#{PROJECT_TEST_BUILD_OUTPUT_PATH}\/#{'.+\\'+EXTENSION_EXECUTABLE}$/) do |bin_file|
-  @ceedling[:generator].generate_executable_file(TOOLS_TEST_LINKER, TEST_CONTEXT, bin_file.prerequisites, bin_file.name)
+  @ceedling[:generator].generate_executable_file(TOOLS_TEST_LINKER, TEST_SYM, bin_file.prerequisites, bin_file.name)
 end
 
 
@@ -28,11 +28,11 @@ rule(/#{PROJECT_TEST_RESULTS_PATH}\/#{'.+\\'+EXTENSION_TESTPASS}$/ => [
       @ceedling[:file_path_utils].form_test_executable_filepath(task_name)
     end
   ]) do |test_result|
-  @ceedling[:generator].generate_test_results(TOOLS_TEST_FIXTURE, TEST_CONTEXT, test_result.source, test_result.name)
+  @ceedling[:generator].generate_test_results(TOOLS_TEST_FIXTURE, TEST_SYM, test_result.source, test_result.name)
 end
 
 
-namespace TEST_CONTEXT do
+namespace TEST_SYM do
   # use rules to increase efficiency for large projects (instead of iterating through all sources and creating defined tasks)
   
   rule(/^#{TEST_TASK_ROOT}\S+$/ => [ # test task names by regex

data/new_project_template/vendor/ceedling/lib/rules_tests_aux_dependencies.rake

@@ -7,7 +7,7 @@ rule(/#{PROJECT_TEST_DEPENDENCIES_PATH}\/#{'.+\\'+EXTENSION_DEPENDENCIES}$/ => [
   ]) do |dep|
   @ceedling[:generator].generate_dependencies_file(
   	TOOLS_TEST_DEPENDENCIES_GENERATOR,
-    TEST_CONTEXT,
+    TEST_SYM,
   	dep.source,
   	@ceedling[:file_path_utils].form_test_build_object_filepath(dep.source),
   	dep.name)

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

@@ -24,15 +24,22 @@ class Setupinator
     @ceedling[:configurator].populate_unity_defines( config_hash )
     @ceedling[:configurator].populate_cmock_defaults( config_hash )
     @ceedling[:configurator].find_and_merge_plugins( config_hash )
-    @ceedling[:configurator].populate_tool_names_and_stderr_redirect( config_hash )
+    @ceedling[:configurator].tools_setup( config_hash )
     @ceedling[:configurator].eval_environment_variables( config_hash )
     @ceedling[:configurator].eval_paths( config_hash )
     @ceedling[:configurator].standardize_paths( config_hash )
     @ceedling[:configurator].validate( config_hash )
-    @ceedling[:configurator].build( config_hash )
+    @ceedling[:configurator].build( config_hash, :environment )
+    
     @ceedling[:configurator].insert_rake_plugins( @ceedling[:configurator].rake_plugins )
+    @ceedling[:configurator].tools_supplement_arguments( config_hash )
+    
+    # merge in any environment variables plugins specify, after the main build
+    @ceedling[:plugin_manager].load_plugin_scripts( @ceedling[:configurator].script_plugins, @ceedling ) do |env|
+      @ceedling[:configurator].eval_environment_variables( env )
+      @ceedling[:configurator].build_supplement( config_hash, env )
+    end
     
-    @ceedling[:plugin_manager].load_plugin_scripts( @ceedling[:configurator].script_plugins, @ceedling )
     @ceedling[:plugin_reportinator].set_system_objects( @ceedling )
     @ceedling[:file_finder].prepare_search_sources
     @ceedling[:loginator].setup_log_filepath

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

@@ -0,0 +1,32 @@
+
+class Object
+  def deep_clone
+    Marshal::load(Marshal.dump(self))
+  end
+end
+
+
+class SystemUtils
+
+  constructor :system_wrapper
+
+  def setup
+    @tcsh_shell = nil
+  end
+
+  def tcsh_shell?
+    # once run a single time, return state determined at that execution
+    return @tcsh_shell if not @tcsh_shell.nil?
+  
+    result = @system_wrapper.shell_backticks('echo $version')
+
+    if ((result[:exit_code] == 0) and (result[:output].strip =~ /^tcsh/))
+      @tcsh_shell = true
+    else
+      @tcsh_shell = false
+    end
+  
+    return @tcsh_shell
+  end
+
+end

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

@@ -3,13 +3,13 @@ require 'rbconfig'
 class SystemWrapper
 
   # static method for use in defaults
-  def self.is_windows?
+  def self.windows?
     return ((Config::CONFIG['host_os'] =~ /mswin|mingw/) ? true : false)
   end
 
   # class method so as to be mockable for tests
-  def is_windows?
-    return SystemWrapper.is_windows?
+  def windows?
+    return SystemWrapper.windows?
   end
   
   def module_eval(string)
@@ -40,9 +40,17 @@ class SystemWrapper
     return Time.now.asctime
   end
 
-  def shell_execute(command)
+  def shell_backticks(command)
     return {
-      :output =>  `#{command}`,
+      :output    => `#{command}`,
+      :exit_code => ($?.exitstatus)
+    }
+  end
+
+  def shell_system(command)
+    system( command )
+    return {
+      :output    => '',
       :exit_code => ($?.exitstatus)
     }
   end

data/new_project_template/vendor/ceedling/lib/tasks_base.rake

@@ -64,10 +64,10 @@ end
 
 
 # list expanded environment variables
-if (not COLLECTION_ENVIRONMENT.empty?)
+if (not ENVIRONMENT.empty?)
 desc "List all configured environment variables."
 task :environment do
-  COLLECTION_ENVIRONMENT.each do |env|
+  ENVIRONMENT.each do |env|
     env.each_key do |key|
       name = key.to_s.upcase
       puts " - #{name}: \"#{env[key]}\""

data/new_project_template/vendor/ceedling/lib/tasks_release.rake

@@ -3,7 +3,7 @@ require 'file_path_utils'
 
 
 desc "Build release target."
-task RELEASE_CONTEXT => [:directories] do
+task RELEASE_SYM => [:directories] do
   header = "Release build '#{File.basename(PROJECT_RELEASE_BUILD_TARGET)}'"
   @ceedling[:streaminator].stdout_puts("\n\n#{header}\n#{'-' * header.length}")  
   

data/new_project_template/vendor/ceedling/lib/tasks_tests.rake

@@ -1,5 +1,5 @@
 
-namespace TEST_CONTEXT do
+namespace TEST_SYM do
   
   desc "Run all unit tests."
   task :all => [:directories] do

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

@@ -15,27 +15,55 @@ class ToolExecutor
     @tool_name  = tool_config[:name]
     @executable = tool_config[:executable]
 
+    command = {}
+
     # basic premise is to iterate top to bottom through arguments using '$' as 
     #  a string replacement indicator to expand globals or inline yaml arrays
     #  into command line arguments via substitution strings
-    return [
+    command[:line] = [
       @tool_executor_helper.osify_path_separators( expandify_element(@executable, *args) ),
       build_arguments(tool_config[:arguments], *args),
-      @tool_executor_helper.stderr_redirect_addendum(tool_config) ].compact.join(' ')
+      ].join(' ').strip
+
+    command[:options] = {
+      :stderr_redirect => @tool_executor_helper.stderr_redirection(tool_config, @configurator.project_logging),
+      :background_exec => tool_config[:background_exec]
+      }
+    
+    return command
   end
 
 
   # shell out, execute command, and return response
-  def exec(command, args=[], options={:boom => true})
-    command_str = "#{command} #{args.join(' ')}".strip
+  def exec(command, options={}, args=[])
+    options[:boom] = true if (options[:boom].nil?)
+    options[:stderr_redirect] = StdErrRedirect::NONE if (options[:stderr_redirect].nil?)
+    options[:background_exec] = BackgroundExec::NONE if (options[:background_exec].nil?)
     
-    shell_result = @system_wrapper.shell_execute(command_str)
-
-    @tool_executor_helper.print_happy_results(command_str, shell_result)
-    @tool_executor_helper.print_error_results(command_str, shell_result) if (options[:boom])
-
+    # build command line
+    command_line = [
+      @tool_executor_helper.background_exec_cmdline_prepend( options ),
+      command.strip,
+      args,
+      @tool_executor_helper.stderr_redirect_cmdline_append( options ),
+      @tool_executor_helper.background_exec_cmdline_append( options ),
+      ].flatten.compact.join(' ')
+
+    shell_result = {}
+    
+    # depending on background exec option, we shell out differently
+    if (options[:background_exec] != BackgroundExec::NONE)
+      shell_result = @system_wrapper.shell_system( command_line )
+    else
+      shell_result = @system_wrapper.shell_backticks( command_line )
+    end
+    
+    @tool_executor_helper.print_happy_results( command_line, shell_result, options[:boom] )
+    @tool_executor_helper.print_error_results( command_line, shell_result, options[:boom] )
+    
+    # go boom if exit code isn't 0 (but in some cases we don't want a non-0 exit code to raise)
     raise if ((shell_result[:exit_code] != 0) and options[:boom])
-
+    
     return shell_result
   end
 

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

@@ -2,22 +2,61 @@ require 'constants' # for Verbosity enumeration & $stderr redirect enumeration
 
 class ToolExecutorHelper
 
-  constructor :streaminator, :system_wrapper
+  constructor :streaminator, :system_utils, :system_wrapper
+
+  def stderr_redirection(tool_config, logging)
+    # if there's no logging enabled, return :stderr_redirect unmodified
+    return tool_config[:stderr_redirect] if (not logging)
+    
+    # if there is logging enabled but the redirect is a custom value (not enum), return the custom string
+    return tool_config[:stderr_redirect] if (tool_config[:stderr_redirect].class == String)
+ 
+    # if logging is enabled but there's no custom string, return the AUTO enumeration so $stderr goes into the log
+    return StdErrRedirect::AUTO
+  end
+
+  def background_exec_cmdline_prepend(tool_config)
+    return nil if (tool_config[:background_exec].nil?)
+    
+    config_exec = tool_config[:background_exec]
+    
+    if ((config_exec == BackgroundExec::AUTO) and (@system_wrapper.windows?))
+      return 'start'
+    end
+
+    if (config_exec == BackgroundExec::WIN)
+      return 'start'
+    end
+
+    return nil
+  end
 
   def osify_path_separators(executable)
-    return executable.gsub(/\//, '\\') if (@system_wrapper.is_windows?)
+    return executable.gsub(/\//, '\\') if (@system_wrapper.windows?)
     return executable
   end
   
-  def stderr_redirect_addendum(tool_config)
+  def stderr_redirect_cmdline_append(tool_config)
     return nil if (tool_config[:stderr_redirect].nil?)
     
-    redirect = tool_config[:stderr_redirect]
+    config_redirect = tool_config[:stderr_redirect]
+    redirect        = StdErrRedirect::NONE
     
+    if (config_redirect == StdErrRedirect::AUTO)
+       if (@system_wrapper.windows?)
+         redirect = StdErrRedirect::WIN
+       else
+         if (@system_utils.tcsh_shell?)
+           redirect = StdErrRedirect::TCSH
+         else
+           redirect = StdErrRedirect::UNIX           
+         end
+       end
+    end
+
     case redirect
       # we may need more complicated processing after some learning with various environments
       when StdErrRedirect::NONE then nil
-      when StdErrRedirect::AUTO then '2>&1'
       when StdErrRedirect::WIN  then '2>&1'
       when StdErrRedirect::UNIX then '2>&1'
       when StdErrRedirect::TCSH then '|&'
@@ -25,22 +64,41 @@ class ToolExecutorHelper
     end
   end
 
+  def background_exec_cmdline_append(tool_config)
+    return nil if (tool_config[:background_exec].nil?)
+
+    config_exec = tool_config[:background_exec]
+    
+    # if :auto & windows, then we already prepended 'start' and should append nothing
+    return nil if ((config_exec == BackgroundExec::AUTO) and (@system_wrapper.windows?))
+
+    # if :auto & not windows, then we append standard '&'
+    return '&' if ((config_exec == BackgroundExec::AUTO) and (not @system_wrapper.windows?))
+
+    # if explicitly Unix, then append '&'
+    return '&' if (config_exec == BackgroundExec::UNIX)
+    
+    # all other cases, including :none, :win, & anything unrecognized, append nothing
+    return nil
+  end
+
   # if command succeeded and we have verbosity cranked up, spill our guts
-  def print_happy_results(command_str, shell_result)
-    if (shell_result[:exit_code] == 0)
+  def print_happy_results(command_str, shell_result, boom)
+    if ((shell_result[:exit_code] == 0) or ((shell_result[:exit_code] != 0) and not boom))
       output  = "> Shell executed command:\n"
       output += "#{command_str}\n"
       output += "> Produced response:\n"           if (not shell_result[:output].empty?)
       output += "#{shell_result[:output].strip}\n" if (not shell_result[:output].empty?)
+      output += "> And exited with status: [#{shell_result[:exit_code]}].\n" if (shell_result[:exit_code] != 0)
       output += "\n"
-    
+  
       @streaminator.stdout_puts(output, Verbosity::OBNOXIOUS)
     end
   end
 
   # if command failed and we have verbosity set to minimum error level, spill our guts
-  def print_error_results(command_str, shell_result)
-    if (shell_result[:exit_code] != 0)
+  def print_error_results(command_str, shell_result, boom)
+    if ((shell_result[:exit_code] != 0) and boom)
       output  = "ERROR: Shell command failed.\n"
       output += "> Shell executed command:\n"
       output += "'#{command_str}'\n"