ceedling 0.0.1

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

@@ -0,0 +1,206 @@
+
+class GeneratorTestRunner
+
+  constructor :configurator, :file_path_utils, :file_wrapper
+
+  
+  def find_test_cases(test_file)
+    tests = []
+    tests_and_line_numbers = []
+    lines = []
+    
+    # if we don't have preprocessor assistance, do some basic preprocessing of our own
+    if (not @configurator.project_use_test_preprocessor)
+      source = @file_wrapper.read(test_file)
+    
+      # remove line comments
+      source = source.gsub(/\/\/.*$/, '')
+      # remove block comments
+      source = source.gsub(/\/\*.*?\*\//m, '')
+    
+      # treat preprocessor directives as a logical line
+      lines = source.split(/(^\s*\#.*$) | (;|\{|\}) /x) # match ;, {, and } as end of lines
+    # otherwise, read the preprocessed file raw
+    else
+      lines = @file_wrapper.read( @file_path_utils.form_preprocessed_file_filepath(test_file) ).split(/;|\{|\}/)
+    end
+    
+    # step 1. find test functions in (possibly preprocessed) file
+    # (note that lines are not broken up at end of lines)
+    lines.each do |line|
+      if (line =~ /^\s*void\s+((T|t)est.*)\s*\(\s*(void)?\s*\)/m)
+        tests << ($1.strip)
+      end
+    end
+    
+    # step 2. associate test functions with line numbers in (non-preprocessed) original file
+    # (note that this time we must scan file contents broken up by end of lines)
+    raw_lines = @file_wrapper.read(test_file).split("\n")
+    raw_index = 0
+    
+    tests.each do |test|
+      raw_lines[raw_index..-1].each_with_index do |line, index|
+        # test function might be declared across lines; look for it by its name followed
+        #  by a few tell-tale signs
+        if (line =~ /#{test}\s*($|\(|\()/)
+          raw_index += (index + 1)
+          tests_and_line_numbers << {:test => test, :line_number => raw_index}
+          break
+        end
+      end
+    end
+    
+    return tests_and_line_numbers
+  end
+  
+  
+  def create_header(output, mock_list)    
+    output << "/* AUTOGENERATED FILE. DO NOT EDIT. */\n"
+    output << "#include \"unity.h\"\n"
+    
+    @configurator.test_runner_includes.each do |include|
+      output << "#include \"#{include}\"\n"
+    end
+    
+    output << "#include <setjmp.h>\n"
+    output << "#include <stdio.h>\n"
+    
+    if (@configurator.project_use_exceptions == true)
+      output << "#include \"CException.h\"\n"
+    end
+        
+    unless (mock_list.empty?)
+      header_extension = @configurator.extension_header
+      mock_list.each do |mock|
+        output << "#include \"#{mock}#{header_extension}\"\n"
+      end
+      if (@configurator.cmock_enforce_strict_ordering == true)
+        output << "\n"
+        output << "int GlobalExpectCount;\n"
+        output << "int GlobalVerifyOrder;\n"
+        output << "char* GlobalOrderError;\n"
+      end
+    end
+    
+    output << "\n"
+    output << "char MessageBuffer[50];\n"
+  end
+  
+  
+  def create_externs(output, test_cases)
+    output << "\n"
+    output << "extern void setUp(void);\n"
+    output << "extern void tearDown(void);\n"
+    output << "\n" if not test_cases.empty?
+    
+    test_cases.each do |item|
+      output << "extern void #{item[:test]}(void);\n"
+    end    
+  end
+  
+  
+  def create_mock_management(output, mock_list)
+    
+    unless (mock_list.empty?)
+      header_extension = @configurator.extension_header
+
+      output << "\n"      
+      output << "static void CMock_Init(void)\n"
+      output << "{\n"
+      
+      if (@configurator.cmock_enforce_strict_ordering == true)
+        output << "  GlobalExpectCount = 0;\n"
+        output << "  GlobalVerifyOrder = 0;\n"
+        output << "  GlobalOrderError = NULL;\n"
+      end
+      
+      mock_list.each do |mock|
+        output << "  #{mock.sub(/#{'\\'+header_extension}/, '')}_Init();\n"
+      end
+      output << "}\n"
+      output << "\n"
+
+      output << "static void CMock_Verify(void)\n"
+      output << "{\n"
+      mock_list.each do |mock|
+        output << "  #{mock.sub(/#{'\\'+header_extension}/, '')}_Verify();\n"
+      end
+      output << "}\n"
+      output << "\n"
+
+      output << "static void CMock_Destroy(void)\n"
+      output << "{\n"
+      mock_list.each do |mock|
+        output << "  #{mock.sub(/#{'\\'+header_extension}/, '')}_Destroy();\n"
+      end
+      output << "}\n"
+      output << "\n"
+
+      output << "void CMock_VerifyAndReset(void)\n"
+      output << "{\n"
+      output << "  CMock_Verify();\n"
+      output << "  CMock_Destroy();\n"
+      output << "  CMock_Init();\n"
+      output << "}\n"
+      output << "\n"
+    end
+    
+  end
+  
+  
+  def create_runtest(output, mock_list, test_cases)
+    
+    unless(test_cases.empty?)
+      use_exceptions = @configurator.project_use_exceptions
+
+      tab = '    '   # default spacing
+      tab = '      ' if (use_exceptions)
+
+      output << "\n"
+      output << "static void TestRun(UnityTestFunction Func, const char* FuncName, const int FuncLineNum)\n"
+      output << "{\n"
+      output << "  Unity.CurrentTestName = FuncName;\n"
+      output << "  Unity.CurrentTestLineNumber = FuncLineNum;\n"
+      output << "  Unity.NumberOfTests++;\n"
+      output << "  if (TEST_PROTECT())\n"
+      output << "  {\n"
+      output << "    CEXCEPTION_T e;\n"   if use_exceptions
+      output << "    Try {\n"             if use_exceptions
+      output << "#{tab}CMock_Init();\n"   unless (mock_list.empty?) 
+      output << "#{tab}setUp();\n"
+      output << "#{tab}Func();\n"
+      output << "#{tab}CMock_Verify();\n" unless (mock_list.empty?)
+      output << "    } Catch(e) { TEST_FAIL_MESSAGE(\"Unhandled Exception!\"); }\n" if use_exceptions
+      output << "  }\n"
+      output << "  CMock_Destroy();\n"    unless (mock_list.empty?)
+      output << "  if (TEST_PROTECT() && !(Unity.CurrentTestIgnored))\n"
+      output << "  {\n"
+      output << "    tearDown();\n"
+      output << "  }\n"
+      output << "  UnityConcludeTest();\n"
+      output << "}\n"
+    end
+    
+  end
+    
+  
+  def create_main(output, module_name, test_cases)
+    output << "\n"
+    output << "int main(void)\n"
+    output << "{\n"
+    output << "  UnityBegin();\n"
+    output << "  Unity.TestFile = \"#{module_name}\";\n"
+    output << "\n"
+
+    output << "  // RUN_TEST calls runTest\n" unless (test_cases.empty?)
+    test_cases.each do |item|
+      output << "  RUN_TEST(#{item[:test]}, #{item[:line_number]});\n"
+    end
+
+    output << "\n"
+    output << "  return UnityEnd();\n"
+    output << "}\n"
+    output << "\n"
+  end
+  
+end

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

@@ -0,0 +1,31 @@
+
+class Loginator
+
+  constructor :configurator, :project_file_loader, :project_config_manager, :file_wrapper, :system_wrapper
+
+
+  def setup_log_filepath
+    config_files = []
+    config_files << @project_file_loader.main_file
+    config_files << @project_file_loader.user_file
+    config_files.concat( @project_config_manager.options_files )
+    config_files.compact!
+    config_files.map! { |file| file.ext('') }
+    
+    log_name = config_files.join( '_' )
+
+    @project_log_filepath = File.join( @configurator.project_log_path, log_name.ext('.log') )
+  end
+
+
+  def log(string, heading=nil)
+    return if (not @configurator.project_logging)
+  
+    output  = "\n[#{@system_wrapper.time_now}]"
+    output += " :: #{heading}" if (not heading.nil?)
+    output += "\n#{string.strip}\n"
+
+    @file_wrapper.write(@project_log_filepath, output, 'a')
+  end
+  
+end

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

@@ -0,0 +1,46 @@
+
+# modified version of Rake's provided make-style dependency loader
+# customizations: 
+#  (1) handles windows drives in paths -- colons don't confuse task demarcation
+#  (2) handles spaces in directory paths
+
+module Rake
+
+  # Makefile loader to be used with the import file loader.
+  class MakefileLoader
+
+    # Load the makefile dependencies in +fn+.
+    def load(fn)
+      open(fn) do |mf|
+        lines = mf.read
+        lines.gsub!(/#[^\n]*\n/m, "") # remove comments
+        lines.gsub!(/\\\n/, ' ')      # string together line continuations into single line
+        lines.split("\n").each do |line|
+          process_line(line)
+        end
+      end
+    end
+
+    private
+
+    # Process one logical line of makefile data.
+    def process_line(line)
+      # split on presence of task demaractor followed by space (i.e don't get confused by a colon in a win path)
+      file_tasks, args = line.split(/:\s/)
+
+      return if args.nil?
+      
+      # split at non-escaped space boundary between files (i.e. escaped spaces in paths are left alone)
+      dependents = args.split(/\b\s+/)
+      # replace escaped spaces and clean up any extra whitespace
+      dependents.map! { |path| path.gsub(/\\ /, ' ').strip }
+
+      file_tasks.strip.split.each do |file_task|
+        file file_task => dependents
+      end
+    end
+  end
+
+  # Install the handler
+  Rake.application.add_loader('mf', MakefileLoader.new)
+end

data/new_project_template/vendor/ceedling/lib/objects.yml

@@ -0,0 +1,278 @@
+
+file_wrapper:
+
+stream_wrapper:
+
+rake_wrapper:
+
+yaml_wrapper:
+
+system_wrapper:
+
+cmock_builder:
+
+reportinator:
+
+rake_utils:
+  compose:
+    - rake_wrapper  
+
+file_path_utils:
+  compose:
+    - configurator
+    - file_wrapper
+
+file_system_utils:
+  compose: file_wrapper
+
+project_file_loader:
+  compose:
+    - yaml_wrapper
+    - stream_wrapper
+    - system_wrapper
+    - file_wrapper
+
+project_config_manager:
+  compose:
+    - cacheinator
+    - yaml_wrapper
+
+cacheinator:
+  compose:
+    - cacheinator_helper
+    - file_path_utils
+    - file_wrapper
+    - yaml_wrapper
+
+cacheinator_helper:
+  compose:
+    - file_wrapper
+    - yaml_wrapper
+
+tool_executor:
+  compose:
+    - configurator
+    - tool_executor_helper
+    - streaminator
+    - system_wrapper
+
+tool_executor_helper:
+  compose:
+    - streaminator
+    - system_wrapper
+
+configurator:
+  compose:
+    - configurator_setup
+    - configurator_plugins
+    - configurator_builder
+    - cmock_builder
+    - yaml_wrapper
+    - system_wrapper
+
+configurator_setup:
+  compose:
+    - configurator_builder
+    - configurator_validator
+
+configurator_plugins:
+  compose:
+    - stream_wrapper
+    - file_wrapper
+    - system_wrapper
+
+configurator_validator:
+  compose:
+    - file_wrapper
+    - stream_wrapper
+    - system_wrapper
+
+configurator_builder:
+  compose:
+    - file_system_utils
+    - file_wrapper
+    - system_wrapper
+
+loginator:
+  compose:
+    - configurator
+    - project_file_loader
+    - project_config_manager
+    - file_wrapper
+    - system_wrapper
+
+streaminator:
+  compose:
+    - streaminator_helper
+    - verbosinator
+    - loginator
+    - stream_wrapper
+
+streaminator_helper:
+
+setupinator:
+
+plugin_manager:
+  compose:
+    - configurator
+    - plugin_manager_helper
+    - streaminator
+    - reportinator
+    - system_wrapper
+
+plugin_manager_helper:
+
+plugin_reportinator:
+  compose:
+    - plugin_reportinator_helper
+    - plugin_manager
+    - reportinator
+
+plugin_reportinator_helper:
+  compose:
+    - configurator
+    - streaminator
+    - yaml_wrapper
+    - file_wrapper
+
+verbosinator:
+  compose: configurator
+
+file_finder:
+  compose:
+    - configurator
+    - file_finder_helper
+    - cacheinator
+    - file_path_utils
+    - file_wrapper
+    - yaml_wrapper
+
+file_finder_helper:
+  compose: streaminator
+
+test_includes_extractor:
+  compose:
+    - configurator
+    - yaml_wrapper
+    - file_wrapper
+
+task_invoker:
+  compose:
+    - dependinator
+    - rake_utils
+    - rake_wrapper
+
+generator:
+  compose:
+    - configurator
+    - preprocessinator
+    - cmock_builder
+    - generator_test_runner
+    - generator_test_results
+    - test_includes_extractor
+    - tool_executor
+    - file_finder
+    - file_path_utils
+    - streaminator
+    - plugin_manager
+    - file_wrapper
+
+generator_test_results:
+  compose:
+    - configurator  
+    - generator_test_results_sanity_checker
+    - yaml_wrapper  
+
+generator_test_results_sanity_checker:
+  compose:
+    - configurator  
+    - streaminator
+
+generator_test_runner:
+  compose:
+    - configurator
+    - file_path_utils
+    - file_wrapper
+
+dependinator:
+  compose:
+    - configurator
+    - project_config_manager
+    - test_includes_extractor
+    - file_path_utils        
+    - rake_wrapper
+    - file_wrapper
+
+preprocessinator:
+  compose:
+    - preprocessinator_helper          
+    - preprocessinator_includes_handler
+    - preprocessinator_file_handler
+    - task_invoker    
+    - file_path_utils
+    - yaml_wrapper
+
+preprocessinator_helper:
+  compose:                    
+    - configurator            
+    - test_includes_extractor 
+    - task_invoker            
+    - file_finder             
+    - file_path_utils         
+
+preprocessinator_includes_handler:
+  compose:
+    - configurator    
+    - tool_executor   
+    - task_invoker    
+    - file_path_utils 
+    - yaml_wrapper    
+    - file_wrapper    
+
+preprocessinator_file_handler:
+  compose:
+    - preprocessinator_extractor
+    - configurator   
+    - tool_executor  
+    - file_path_utils
+    - file_wrapper   
+
+preprocessinator_extractor:
+  compose:
+    - file_wrapper
+
+test_invoker:
+  compose:
+    - configurator
+    - test_invoker_helper
+    - streaminator
+    - preprocessinator
+    - task_invoker
+    - dependinator
+    - project_config_manager
+    - file_path_utils
+
+test_invoker_helper:
+  compose:
+    - configurator
+    - task_invoker
+    - dependinator
+    - test_includes_extractor
+    - file_finder
+    - file_path_utils
+    - streaminator
+    - file_wrapper
+
+release_invoker:
+  compose:
+    - release_invoker_helper
+    - configurator
+    - dependinator
+    - task_invoker
+    - file_path_utils
+
+release_invoker_helper:
+  compose:
+    - configurator
+    - dependinator
+    - task_invoker

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

@@ -0,0 +1,63 @@
+
+class String
+  def left_margin(margin=0)
+    non_whitespace_column = 0
+    new_lines = []
+    
+    # find first line with non-whitespace and count left columns of whitespace
+    self.each_line do |line|
+      if (line =~ /^\s*\S/)
+        non_whitespace_column = $&.length - 1
+        break
+      end
+    end
+    
+    # iterate through each line, chopping off leftmost whitespace columns and add back the desired whitespace margin
+    self.each_line do |line|
+      columns = []
+      margin.times{columns << ' '}
+      # handle special case of line being narrower than width to be lopped off
+      if (non_whitespace_column < line.length)
+        new_lines << "#{columns.join}#{line[non_whitespace_column..-1]}"
+      else
+        new_lines << "\n"
+      end
+    end
+    
+    return new_lines.join
+  end
+end
+
+class Plugin
+  attr_reader :name
+
+  def initialize(system_objects, name)
+    @ceedling = system_objects
+    @name = name
+    self.setup
+  end
+
+  def setup; end
+
+  def pre_build; end
+
+  def pre_mock_execute(arg_hash); end
+  def post_mock_execute(arg_hash); end
+
+  def pre_runner_execute(arg_hash); end
+  def post_runner_execute(arg_hash); end
+
+  def pre_compile_execute(arg_hash); end
+  def post_compile_execute(arg_hash); end
+
+  def pre_link_execute(arg_hash); end
+  def post_link_execute(arg_hash); end
+
+  def pre_test_execute(arg_hash); end
+  def post_test_execute(arg_hash); end
+
+  def post_build; end
+  
+  def summary; end
+
+end

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

@@ -0,0 +1,85 @@
+require 'constants'
+require 'set'
+
+class PluginManager
+
+  constructor :configurator, :plugin_manager_helper, :streaminator, :reportinator, :system_wrapper
+
+  def setup
+    @build_fail_registry = []
+    @plugin_objects = [] # so we can preserve order
+  end
+  
+  def load_plugin_scripts(script_plugins, system_objects)
+    script_plugins.each do |plugin|
+      # protect against instantiating object multiple times due to processing config multiple times (options, etc)
+			next if (@plugin_manager_helper.include?(@plugin_objects, plugin))
+      @system_wrapper.require_file( "#{plugin}.rb" )
+      object = @plugin_manager_helper.instantiate_plugin_script( camelize(plugin), system_objects, plugin )
+      @plugin_objects << object
+      
+      # add plugins to hash of all system objects
+      system_objects[plugin.downcase.to_sym] = object
+    end
+  end
+  
+  def plugins_failed?
+    return (@build_fail_registry.size > 0)
+  end
+  
+  def print_plugin_failures
+    if (@build_fail_registry.size > 0)
+      report = @reportinator.generate_banner('BUILD FAILURE SUMMARY')
+      
+      @build_fail_registry.each do |failure|
+        report += "#{' - ' if (@build_fail_registry.size > 1)}#{failure}\n"
+      end
+      
+      report += "\n"
+      
+      @streaminator.stderr_puts(report, Verbosity::ERRORS)
+    end    
+  end
+  
+  def register_build_failure(message)
+    @build_fail_registry << message if (message and not message.empty?)
+  end
+
+  #### execute all plugin methods ####
+
+  def pre_build; execute_plugins(:pre_build); end
+
+  def pre_mock_execute(arg_hash); execute_plugins(:pre_mock_execute, arg_hash); end
+  def post_mock_execute(arg_hash); execute_plugins(:post_mock_execute, arg_hash); end
+
+  def pre_runner_execute(arg_hash); execute_plugins(:pre_runner_execute, arg_hash); end
+  def post_runner_execute(arg_hash); execute_plugins(:post_runner_execute, arg_hash); end
+
+  def pre_compile_execute(arg_hash); execute_plugins(:pre_compile_execute, arg_hash); end
+  def post_compile_execute(arg_hash); execute_plugins(:post_compile_execute, arg_hash); end
+
+  def pre_link_execute(arg_hash); execute_plugins(:pre_link_execute, arg_hash); end
+  def post_link_execute(arg_hash); execute_plugins(:post_link_execute, arg_hash); end
+
+  def pre_test_execute(arg_hash); execute_plugins(:pre_test_execute, arg_hash); end
+  def post_test_execute(arg_hash)
+    # special arbitration: raw test results are printed or taken over by plugins handling the job
+    @streaminator.stdout_puts(arg_hash[:shell_result][:output]) if (@configurator.plugins_display_raw_test_results)
+    execute_plugins(:post_test_execute, arg_hash)
+  end
+  
+  def post_build; execute_plugins(:post_build); end
+  
+  def summary; execute_plugins(:summary); end
+  
+  private ####################################
+  
+  def camelize(underscored_name)
+    return underscored_name.gsub(/(_|^)([a-z0-9])/) {$2.upcase}
+  end
+
+  def execute_plugins(method, *args)
+    @plugin_objects.each {|plugin| plugin.send(method, *args) }
+  end
+
+end