ceedling 0.0.1

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

@@ -0,0 +1,36 @@
+require 'constants'
+require 'file_path_utils'
+
+# create file dependencies to ensure C-based components of vendor tools are recompiled when they are updated with new versions
+# forming these explicitly rather than depend on auxiliary dependencies so all scenarios are explicitly covered
+
+file( @ceedling[:file_path_utils].form_test_build_object_filepath( UNITY_C_FILE ) => [
+  FilePathUtils.form_ceedling_vendor_path( UNITY_LIB_PATH, UNITY_C_FILE ),
+  FilePathUtils.form_ceedling_vendor_path( UNITY_LIB_PATH, UNITY_H_FILE ),
+  FilePathUtils.form_ceedling_vendor_path( UNITY_LIB_PATH, UNITY_INTERNALS_H_FILE ) ]
+  )
+
+
+if (PROJECT_USE_MOCKS)
+file( @ceedling[:file_path_utils].form_test_build_object_filepath( CMOCK_C_FILE ) => [
+  FilePathUtils.form_ceedling_vendor_path( CMOCK_LIB_PATH, CMOCK_C_FILE ),
+  FilePathUtils.form_ceedling_vendor_path( CMOCK_LIB_PATH, CMOCK_H_FILE ) ]
+  )
+end
+
+
+if (PROJECT_USE_EXCEPTIONS)
+file( @ceedling[:file_path_utils].form_test_build_object_filepath( CEXCEPTION_C_FILE ) => [
+  FilePathUtils.form_ceedling_vendor_path( CEXCEPTION_LIB_PATH, CEXCEPTION_C_FILE ),
+  FilePathUtils.form_ceedling_vendor_path( CEXCEPTION_LIB_PATH, CEXCEPTION_H_FILE ) ]
+  )
+end
+
+
+if (PROJECT_USE_EXCEPTIONS and PROJECT_RELEASE_BUILD)
+file( @ceedling[:file_path_utils].form_release_build_c_object_filepath( CEXCEPTION_C_FILE ) => [
+  FilePathUtils.form_ceedling_vendor_path( CEXCEPTION_LIB_PATH, CEXCEPTION_C_FILE ),
+  FilePathUtils.form_ceedling_vendor_path( CEXCEPTION_LIB_PATH, CEXCEPTION_H_FILE ) ]
+  )
+end
+

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

@@ -0,0 +1,81 @@
+
+class TestIncludesExtractor
+
+  constructor :configurator, :yaml_wrapper, :file_wrapper
+
+
+  def setup
+    @includes  = {}
+    @mocks     = {}
+  end
+
+
+  # for includes_list file, slurp up array from yaml file and sort & store includes
+  def parse_includes_list(includes_list)
+    gather_and_store_includes( includes_list, @yaml_wrapper.load(includes_list) )
+  end
+
+  # open, scan for, and sort & store includes of test file
+  def parse_test_file(test)
+    gather_and_store_includes( test, extract_from_file(test) )
+  end
+
+  # mocks with no file extension
+  def lookup_raw_mock_list(test)
+    file_key = form_file_key(test)
+    return [] if @mocks[file_key].nil?
+    return @mocks[file_key]
+  end
+  
+  # includes with file extension
+  def lookup_includes_list(file)
+    file_key = form_file_key(file)
+    return [] if (@includes[file_key]).nil?
+    return @includes[file_key]
+  end
+  
+  private #################################
+  
+  def form_file_key(filepath)
+    return File.basename(filepath).to_sym
+  end
+
+  def extract_from_file(file)
+    includes = []
+    header_extension = @configurator.extension_header
+    
+    contents = @file_wrapper.read(file)
+
+    # remove line comments
+    contents = contents.gsub(/\/\/.*$/, '')
+    # remove block comments
+    contents = contents.gsub(/\/\*.*?\*\//m, '')
+    
+    contents.split("\n").each do |line|
+      # look for include statement
+      scan_results = line.scan(/#include\s+\"\s*(.+#{'\\'+header_extension})\s*\"/)
+      
+      includes << scan_results[0][0] if (scan_results.size > 0)
+    end
+    
+    return includes.uniq
+  end
+
+  def gather_and_store_includes(file, includes)
+    mock_prefix      = @configurator.cmock_mock_prefix
+    header_extension = @configurator.extension_header
+    file_key         = form_file_key(file)
+    @mocks[file_key] = []
+      
+    # add includes to lookup hash
+    @includes[file_key] = includes
+      
+    includes.each do |include_file|          
+      # check if include is a mock
+      scan_results = include_file.scan(/(#{mock_prefix}.+)#{'\\'+header_extension}/)
+      # add mock to lookup hash
+      @mocks[file_key] << scan_results[0][0] if (scan_results.size > 0)
+    end
+  end
+  
+end

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

@@ -0,0 +1,72 @@
+require 'rubygems'
+require 'rake' # for ext()
+
+
+class TestInvoker
+
+  attr_reader :sources, :tests, :mocks
+
+  constructor :configurator, :test_invoker_helper, :streaminator, :preprocessinator, :task_invoker, :dependinator, :project_config_manager, :file_path_utils
+
+  def setup
+    @sources = []
+    @tests   = []
+    @mocks   = []
+  end
+  
+  def setup_and_invoke(tests, options={:force_run => true})
+  
+    @tests = tests
+
+    @project_config_manager.process_test_config_change
+  
+    @tests.each do |test|
+      # announce beginning of test run
+      header = "Test '#{File.basename(test)}'"
+      @streaminator.stdout_puts("\n\n#{header}\n#{'-' * header.length}")
+
+      begin      
+        # collect up test fixture pieces & parts
+        runner       = @file_path_utils.form_runner_filepath_from_test( test )
+        mock_list    = @preprocessinator.preprocess_test_and_invoke_test_mocks( test )
+        sources      = @test_invoker_helper.extract_sources( test )
+        extras       = @configurator.collection_test_fixture_extra_link_objects
+        core         = [test] + mock_list + sources
+        objects      = @file_path_utils.form_test_build_objects_filelist( [runner] + core + extras )
+        results_pass = @file_path_utils.form_pass_results_filepath( test )
+        results_fail = @file_path_utils.form_fail_results_filepath( test )
+        
+        # clean results files so we have a missing file with which to kick off rake's dependency rules
+        @test_invoker_helper.clean_results( {:pass => results_pass, :fail => results_fail}, options )
+
+        # load up auxiliary dependencies so deep changes cause rebuilding appropriately
+        @test_invoker_helper.process_auxiliary_dependencies( core )
+
+        # tell rake to create test runner if needed
+        @task_invoker.invoke_test_runner( runner )
+
+        # enhance object file dependencies to capture externalities influencing regeneration
+        @dependinator.enhance_test_build_object_dependencies( objects )
+
+        # associate object files with executable
+        @dependinator.setup_test_executable_dependencies( test, objects )
+
+        # 3, 2, 1... launch
+        @task_invoker.invoke_test_results( results_pass )
+      rescue => e
+        @test_invoker_helper.process_exception(e)
+      end
+      
+      # store away what's been processed
+      @mocks.concat( mock_list )
+      @sources.concat( sources )
+    end
+
+    # post-process collected mock list
+    @mocks.uniq!
+    
+    # post-process collected sources list
+    @sources.uniq!
+  end
+
+end

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

@@ -0,0 +1,41 @@
+require 'rubygems'
+require 'rake' # for ext()
+
+
+class TestInvokerHelper
+
+  constructor :configurator, :task_invoker, :dependinator, :test_includes_extractor, :file_finder, :file_path_utils, :streaminator, :file_wrapper
+
+  def clean_results(results, options)
+    @file_wrapper.rm_f( results[:fail] )
+    @file_wrapper.rm_f( results[:pass] ) if (options[:force_run])
+  end
+
+  def process_auxiliary_dependencies(files)
+    return if (not @configurator.project_use_auxiliary_dependencies)
+
+    dependencies_list = @file_path_utils.form_test_dependencies_filelist( files )
+    @task_invoker.invoke_test_dependencies_files( dependencies_list )
+    @dependinator.load_test_object_deep_dependencies( dependencies_list )
+  end
+  
+  def extract_sources(test)
+    sources  = []
+    includes = @test_includes_extractor.lookup_includes_list(test)
+    
+    includes.each { |include| sources << @file_finder.find_source_file(include, :ignore) }
+    
+    return sources.compact
+  end
+  
+  def process_exception(exception)
+    if (exception.message =~ /Don't know how to build task '(.+)'/i)
+      @streaminator.stderr_puts("ERROR: Rake could not find file referenced in source or test: '#{$1}'.")
+      @streaminator.stderr_puts("Possible stale dependency due to a file name change, etc. Execute 'clean' task and try again.") if (@configurator.project_use_auxiliary_dependencies)
+      raise ''
+    else
+      raise exception
+    end
+  end
+  
+end

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

@@ -0,0 +1,178 @@
+require 'constants'
+
+
+class ToolExecutor
+
+  constructor :configurator, :tool_executor_helper, :streaminator, :system_wrapper
+
+  def setup
+    @tool_name  = ''
+    @executable = ''
+  end
+
+  # build up a command line from yaml provided config
+  def build_command_line(tool_config, *args)
+    @tool_name  = tool_config[:name]
+    @executable = tool_config[:executable]
+
+    # 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 [
+      @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(' ')
+  end
+
+
+  # shell out, execute command, and return response
+  def exec(command, args=[], options={:boom => true})
+    command_str = "#{command} #{args.join(' ')}".strip
+    
+    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])
+
+    raise if ((shell_result[:exit_code] != 0) and options[:boom])
+
+    return shell_result
+  end
+
+  
+  private #############################
+
+  
+  def build_arguments(config, *args)
+    build_string = ''
+    
+    return nil if (config.nil?)
+    
+    # iterate through each argument
+
+    # the yaml blob array needs to be flattened so that yaml substitution
+    # is handled correctly, since it creates a nested array when an anchor is
+    # dereferenced
+    config.flatten.each do |element|
+      argument = ''
+      
+      case(element)
+        # if we find a simple string then look for string replacement operators
+        #  and expand with the parameters in this method's argument list
+        when String then argument = expandify_element(element, *args)
+        # if we find a hash, then we grab the key as a substitution string and expand the
+        #  hash's value(s) within that substitution string
+        when Hash   then argument = dehashify_argument_elements(element)
+      end
+
+      build_string.concat("#{argument} ") if (argument.length > 0)
+    end
+    
+    build_string.strip!
+    return build_string if (build_string.length > 0)
+    return nil
+  end
+
+
+  # handle simple text string argument & argument array string replacement operators
+  def expandify_element(element, *args)
+    match = //
+    to_process = nil
+    args_index = 0
+
+    # handle ${#} input replacement
+    if (element =~ TOOL_EXECUTOR_ARGUMENT_REPLACEMENT_PATTERN)
+      args_index = ($2.to_i - 1)
+
+      if (args.nil? or args[args_index].nil?)
+        @streaminator.stderr_puts("ERROR: Tool '#{@tool_name}' expected valid argument data to accompany replacement operator #{$1}.", Verbosity::ERRORS)
+        raise
+      end
+
+      match = /#{Regexp.escape($1)}/
+      to_process = args[args_index]
+    end
+      
+    # simple string argument: replace escaped '\$' and strip
+    element.sub!(/\\\$/, '$')
+    element.strip!
+
+    # handle inline ruby execution
+    if (element =~ RUBY_EVAL_REPLACEMENT_PATTERN)
+      element.replace(eval($1))
+    end
+
+    build_string = ''
+
+    # handle array or anything else passed into method to be expanded in place of replacement operators
+    case (to_process)
+      when Array then to_process.each {|value| build_string.concat( "#{element.sub(match, value.to_s)} " ) } if (to_process.size > 0)
+      else build_string.concat( element.sub(match, to_process.to_s) )
+    end
+
+    # handle inline ruby string substitution
+    if (build_string =~ RUBY_STRING_REPLACEMENT_PATTERN)
+      build_string.replace(@system_wrapper.module_eval(build_string))
+    end
+    
+    return build_string.strip
+  end
+
+  
+  # handle argument hash: keys are substitution strings, values are data to be expanded within substitution strings
+  def dehashify_argument_elements(hash)
+    build_string = ''
+    elements = []
+
+    # grab the substitution string (hash key)
+    substitution = hash.keys[0].to_s
+    # grab the string(s) to squirt into the substitution string (hash value)
+    expand = hash[hash.keys[0]]
+
+    if (expand.nil?)
+      @streaminator.stderr_puts("ERROR: Tool '#{@tool_name}' could not expand nil elements for substitution string '#{substitution}'.", Verbosity::ERRORS)
+      raise
+    end
+    
+    # array-ify expansion input if only a single string
+    expansion = ((expand.class == String) ? [expand] : expand)
+    
+    expansion.each do |item|
+      # code eval substitution
+      if (item =~ RUBY_EVAL_REPLACEMENT_PATTERN)
+        elements << eval($1)
+      # string eval substitution
+      elsif (item =~ RUBY_STRING_REPLACEMENT_PATTERN)
+        elements << @system_wrapper.module_eval(item)
+      # global constants
+      elsif (@system_wrapper.constants_include?(item))
+        const = Object.const_get(item)
+        if (const.nil?)
+          @streaminator.stderr_puts("ERROR: Tool '#{@tool_name}' found constant '#{item}' to be nil.", Verbosity::ERRORS)
+          raise
+        else
+          elements << const
+        end
+      elsif (item.class == Array)
+        elements << item
+      elsif (item.class == String)
+        @streaminator.stderr_puts("ERROR: Tool '#{@tool_name}' cannot expand nonexistent value '#{item}' for substitution string '#{substitution}'.", Verbosity::ERRORS)
+        raise        
+      else
+        @streaminator.stderr_puts("ERROR: Tool '#{@tool_name}' cannot expand value having type '#{item.class}' for substitution string '#{substitution}'.", Verbosity::ERRORS)
+        raise        
+      end
+    end
+    
+    # expand elements (whether string or array) into substitution string & replace escaped '\$'
+    elements.flatten!
+    elements.each do |element|
+      build_string.concat( substitution.sub(/([^\\]*)\$/, "\\1#{element}") ) # don't replace escaped '\$' but allow us to replace just a lonesome '$'
+      build_string.gsub!(/\\\$/, '$')
+      build_string.concat(' ')
+    end
+
+    return build_string.strip
+  end
+
+end

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

@@ -0,0 +1,57 @@
+require 'constants' # for Verbosity enumeration & $stderr redirect enumeration
+
+class ToolExecutorHelper
+
+  constructor :streaminator, :system_wrapper
+
+  def osify_path_separators(executable)
+    return executable.gsub(/\//, '\\') if (@system_wrapper.is_windows?)
+    return executable
+  end
+  
+  def stderr_redirect_addendum(tool_config)
+    return nil if (tool_config[:stderr_redirect].nil?)
+    
+    redirect = tool_config[:stderr_redirect]
+    
+    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 '|&'
+      else redirect.to_s
+    end
+  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)
+      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 += "\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)
+      output  = "ERROR: Shell command failed.\n"
+      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] != nil)
+      output += "> And then likely crashed.\n"                               if (shell_result[:exit_code] == nil)
+      output += "\n"
+
+      @streaminator.stderr_puts(output, Verbosity::ERRORS)
+    end
+  end
+  
+end

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

@@ -0,0 +1,10 @@
+
+class Verbosinator
+
+  constructor :configurator
+
+  def should_output?(level)
+    return (level <= @configurator.project_verbosity)
+  end
+
+end

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

@@ -0,0 +1,16 @@
+require 'yaml'
+
+
+class YamlWrapper
+
+  def load(filepath)
+    return YAML.load(File.read(filepath))
+  end
+
+  def dump(filepath, structure)
+    File.open(filepath, 'w') do |output|
+      YAML.dump(structure, output)
+    end
+  end
+
+end

data/new_project_template/vendor/ceedling/plugins/stdout_ide_tests_report/stdout_ide_tests_report.rb

@@ -0,0 +1,44 @@
+require 'plugin'
+require 'defaults'
+
+class StdoutIdeTestsReport < Plugin
+  
+  def setup
+    @result_list = []
+  end
+    
+  def post_test_execute(arg_hash)
+    return if not (arg_hash[:context] == TEST_CONTEXT)
+
+    @result_list << arg_hash[:result_file]
+  end
+  
+  def post_build
+    return if (not @ceedling[:task_invoker].test_invoked?)
+    
+    results = @ceedling[:plugin_reportinator].assemble_test_results(@result_list)
+    hash = {
+      :header => '',
+      :results => results
+    }
+    
+    @ceedling[:plugin_reportinator].run_test_results_report(hash) do
+      message = ''
+      message = 'Unit test failures.' if (hash[:results][:counts][:failed] > 0)
+      message
+    end
+  end
+
+  def summary
+    result_list = @ceedling[:file_path_utils].form_pass_results_filelist( PROJECT_TEST_RESULTS_PATH, COLLECTION_ALL_TESTS )
+
+    # get test results for only those tests in our configuration and of those only tests with results on disk
+    hash = {
+      :header => '',
+      :results => @ceedling[:plugin_reportinator].assemble_test_results(result_list, {:boom => false})
+    }
+
+    @ceedling[:plugin_reportinator].run_test_results_report(hash)
+  end
+
+end

data/new_project_template/vendor/ceedling/plugins/stdout_ide_tests_report/stdout_ide_tests_report.yml

@@ -0,0 +1,4 @@
+---
+:plugins:
+  # tell Ceedling we got results display taken care of
+  :display_raw_test_results: FALSE

data/new_project_template/vendor/ceedling/plugins/stdout_pretty_tests_report/stdout_pretty_tests_report.rb

@@ -0,0 +1,108 @@
+require 'plugin'
+require 'defaults'
+
+class StdoutPrettyTestsReport < Plugin
+  
+  def setup
+    @result_list = []
+    
+    template = %q{
+      % ignored      = hash[:results][:counts][:ignored]
+      % failed       = hash[:results][:counts][:failed]
+      % stdout_count = hash[:results][:counts][:stdout]
+      % header_prepend = ((hash[:header].length > 0) ? "#{hash[:header]}: " : '')
+      % banner_width   = 25 + header_prepend.length # widest message
+      
+      % if (ignored > 0)
+      <%=@ceedling[:plugin_reportinator].generate_banner(header_prepend + 'IGNORED UNIT TEST SUMMARY')%>
+      %   hash[:results][:ignores].each do |ignore|
+      [<%=ignore[:source][:file]%>]
+      %     ignore[:collection].each do |item|
+        Test: <%=item[:test]%>
+      % if (not item[:message].empty?)
+        At line (<%=item[:line]%>): "<%=item[:message]%>"
+      % else
+        At line (<%=item[:line]%>)
+      % end
+
+      %     end
+      %   end
+      % end
+      % if (failed > 0)
+      <%=@ceedling[:plugin_reportinator].generate_banner(header_prepend + 'FAILED UNIT TEST SUMMARY')%>
+      %   hash[:results][:failures].each do |failure|
+      [<%=failure[:source][:file]%>]
+      %     failure[:collection].each do |item|
+        Test: <%=item[:test]%>
+      % if (not item[:message].empty?)
+        At line (<%=item[:line]%>): "<%=item[:message]%>"
+      % else
+        At line (<%=item[:line]%>)
+      % end
+
+      %     end
+      %   end
+      % end
+      % if (stdout_count > 0)
+      <%=@ceedling[:plugin_reportinator].generate_banner(header_prepend + 'UNIT TEST OTHER OUTPUT')%>
+      %   hash[:results][:stdout].each do |string|
+      [<%=string[:source][:file]%>]
+      %     string[:collection].each do |item|
+        - "<%=item%>"
+      %     end
+
+      %   end
+      % end
+      % total_string = hash[:results][:counts][:total].to_s
+      % format_string = "%#{total_string.length}i"
+      <%=@ceedling[:plugin_reportinator].generate_banner(header_prepend + 'OVERALL UNIT TEST SUMMARY')%>
+      % if (hash[:results][:counts][:total] > 0)
+      TESTED:  <%=hash[:results][:counts][:total].to_s%>
+      PASSED:  <%=sprintf(format_string, hash[:results][:counts][:passed])%>
+      FAILED:  <%=sprintf(format_string, failed)%>
+      IGNORED: <%=sprintf(format_string, ignored)%>
+      % else
+
+      No tests executed.
+      % end
+
+      }.left_margin
+      
+      @ceedling[:plugin_reportinator].register_test_results_template( template )
+  end
+  
+  def post_test_execute(arg_hash)
+    return if not (arg_hash[:context] == TEST_CONTEXT)
+  
+    @result_list << arg_hash[:result_file]
+  end
+  
+  def post_build
+    return if not (@ceedling[:task_invoker].test_invoked?)
+
+    results = @ceedling[:plugin_reportinator].assemble_test_results(@result_list)
+    hash = {
+      :header => '',
+      :results => results
+    }
+
+    @ceedling[:plugin_reportinator].run_test_results_report(hash) do
+      message = ''
+      message = 'Unit test failures.' if (results[:counts][:failed] > 0)
+      message
+    end
+  end
+
+  def summary
+    result_list = @ceedling[:file_path_utils].form_pass_results_filelist( PROJECT_TEST_RESULTS_PATH, COLLECTION_ALL_TESTS )
+
+    # get test results for only those tests in our configuration and of those only tests with results on disk
+    hash = {
+      :header => '',
+      :results => @ceedling[:plugin_reportinator].assemble_test_results(result_list, {:boom => false})
+    }
+
+    @ceedling[:plugin_reportinator].run_test_results_report(hash)
+  end
+
+end

data/new_project_template/vendor/ceedling/plugins/stdout_pretty_tests_report/stdout_pretty_tests_report.yml

@@ -0,0 +1,4 @@
+---
+:plugins:
+  # tell Ceedling we got results display taken care of
+  :display_raw_test_results: FALSE