ceedling 0.24.0 → 0.25.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 300e156b4f9cbd9bfbea4221b4773dbe3cf122f8
-  data.tar.gz: 823a00ec8ef37579f01e9d444d45d01b6a9cd0f0
+  metadata.gz: 373d6a4981555897351460b57dc82e3d90a96d6d
+  data.tar.gz: ff091c1e3c1934718eb19fcab984c3bc169f5b92
 SHA512:
-  metadata.gz: 8ffe3c8e7a34b6f1cbfd3571a6fd47af2312b7d11a2be722a95587e6cacc4282683614d7e976e7114d442ab0f2efd4ef4fc0a7e6868a7d050c21bb73e7ef84f9
-  data.tar.gz: c9fe93d947af1d5dea5d4f0b3af34f922ed21467364371bd6c2d83c2ec407f9d211baf71a2fe47578cbe7656147c6ed81435b0d0fd1a3ac13e003b211a93a05a
+  metadata.gz: 0feea9fe999980ad018ea2ec89fb0af54537d3ed1b9b029fa24148f4d7c25fabdf4392a896723046a7b0af46533b8187fa2be902cf3a7a3d6fa633863294122e
+  data.tar.gz: 790254af22bb0d7d28efd37ed3df4d5de2aba82589c0c52abf585ad7732ea43dbff283e861286f34d865acb21870f9aeb25456d6897253a1085a3271d9d718a6

data/bin/ceedling

@@ -193,7 +193,12 @@ else
 
       #if neither of these libraries were available, we can just shell out to the command and collect results
       def spawn_command(cmd, &block)
-        block.call( StringIO.new(`#{cmd}`) )
+        results = `#{cmd}`
+        if ($?.exitstatus != 0)
+          block.call( StringIO.new("ERROR: Aborted with Exit Code #{$?.exitstatus.to_s}") )
+        else
+          block.call( StringIO.new(results) )
+        end
       end
     end
 

data/docs/CeedlingPacket.md

@@ -322,6 +322,15 @@ Ceedling (more on this later).
   Sometimes you just need to assemble a single file doggonit. Example:
   ceedling release:assemble:foo.s
 
+* `ceedling module:create[Filename]`:
+
+  It's often helpful to create a file automatically. What's better than
+  that? Creating a source file, a header file, and a corresponding test
+  file all in one step!
+
+  There are also patterns which can be specified to automatically generate
+  a bunch of files. Try `ceedling module:create[Poodles,mch]` for example!
+
 * `ceedling logging <tasks...>`:
 
   Enable logging to <build path>/logs. Must come before test and release

data/lib/ceedling/generator.rb

@@ -95,7 +95,7 @@ class Generator
       shell_result = @tool_executor.exec( command[:line], command[:options] )
     rescue ShellExecutionException => ex
       shell_result = ex.shell_result
-      raise ''
+      raise ex
     ensure
       arg_hash[:shell_result] = shell_result
       @plugin_manager.post_compile_execute(arg_hash)
@@ -149,7 +149,7 @@ class Generator
     command = @tool_executor.build_command_line(arg_hash[:tool], [], arg_hash[:executable])
     command[:options][:boom] = false
     shell_result = @tool_executor.exec( command[:line], command[:options] )
-
+    shell_result[:exit_code] = 0 #Don't Let The Failure Count Make Us Believe Things Aren't Working
     @generator_helper.test_results_error_handler(executable, shell_result)
 
     processed = @generator_test_results.process_and_write_results( shell_result,

data/lib/ceedling/generator_test_runner.rb

@@ -4,13 +4,44 @@ class GeneratorTestRunner
   constructor :configurator, :file_path_utils, :file_wrapper
 
   def find_test_cases(test_file)
+
+    #Pull in Unity's Test Runner Generator
     require 'generate_test_runner.rb'
     @test_runner_generator ||= UnityTestRunnerGenerator.new( @configurator.get_runner_config )
-    return @test_runner_generator.find_tests(@file_wrapper.read(test_file))
+
+    if (@configurator.project_use_test_preprocessor)
+
+      #redirect to use the preprocessor file if we're doing that sort of thing
+      pre_test_file = @file_path_utils.form_preprocessed_file_filepath(test_file)
+
+      #actually look for the tests using Unity's test runner generator
+      tests_and_line_numbers = @test_runner_generator.find_tests(@file_wrapper.read(pre_test_file))
+
+      #look up the line numbers in the original file
+      source_lines = @file_wrapper.read(test_file).split("\n")
+      source_index = 0;
+      tests_and_line_numbers.size.times do |i|
+        source_lines[source_index..-1].each_with_index do |line, index|
+          if (line =~ /#{tests_and_line_numbers[i][:test]}/)
+            source_index += index
+            tests_and_line_numbers[i][:line_number] = source_index + 1
+            break
+          end
+        end
+      end
+    else
+      #Just look for the tests using Unity's test runner generator
+      tests_and_line_numbers   = @test_runner_generator.find_tests(@file_wrapper.read(test_file))
+    end
+
+    return tests_and_line_numbers
   end
 
   def generate(module_name, runner_filepath, test_cases, mock_list, test_file_includes=[])
     require 'generate_test_runner.rb'
+
+    #actually build the test runner using Unity's test runner generator
+    #(there is no need to use preprocessor here because we've already looked up test cases and are passing them in here)
     @test_runner_generator ||= UnityTestRunnerGenerator.new( @configurator.get_runner_config )
     @test_runner_generator.generate( module_name,
                                      runner_filepath,

data/lib/ceedling/rakefile.rb

@@ -73,6 +73,6 @@ END {
     # 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?)
+	  #exit(1) if (@ceedling[:plugin_manager].plugins_failed?) #do NOT call this. It will keep caller from reporting failures
 	end
 }

data/lib/ceedling/system_wrapper.rb

@@ -12,7 +12,7 @@ class SystemWrapper
   def windows?
     return SystemWrapper.windows?
   end
-  
+
   def module_eval(string)
     return Object.module_eval("\"" + string + "\"")
   end
@@ -32,7 +32,7 @@ class SystemWrapper
   def env_set(name, value)
     ENV[name] = value
   end
-  
+
   def env_get(name)
     return ENV[name]
   end
@@ -41,36 +41,39 @@ class SystemWrapper
     return Time.now.asctime
   end
 
-  def shell_backticks(command)
+  def shell_backticks(command, boom = true)
+    retval = `#{command}`.freeze
+    $exit_code = ($?.exitstatus).freeze if boom
     return {
-      :output    => `#{command}`.freeze,
+      :output    => retval.freeze,
       :exit_code => ($?.exitstatus).freeze
     }
   end
 
-  def shell_system(command)
+  def shell_system(command, boom = true)
     system( command )
+    $exit_code = ($?.exitstatus).freeze if boom
     return {
-      :output    => ''.freeze,
+      :output    => "".freeze,
       :exit_code => ($?.exitstatus).freeze
     }
   end
-  
+
   def add_load_path(path)
     $LOAD_PATH.unshift(path)
   end
-  
+
   def require_file(path)
     require(path)
   end
 
   def ruby_success
-    return ($!.nil? || $!.is_a?(SystemExit) && $!.success?)
+    return ($exit_code == 0) && ($!.nil? || $!.is_a?(SystemExit) && $!.success?)
   end
 
   def constants_include?(item)
     # forcing to strings provides consistency across Ruby versions
     return Object.constants.map{|constant| constant.to_s}.include?(item.to_s)
   end
-  
+
 end

data/lib/ceedling/tool_executor.rb

@@ -63,9 +63,9 @@ class ToolExecutor
 
     # depending on background exec option, we shell out differently
     if (options[:background_exec] != BackgroundExec::NONE)
-      shell_result = @system_wrapper.shell_system( command_line )
+      shell_result = @system_wrapper.shell_system( command_line, options[:boom] )
     else
-      shell_result = @system_wrapper.shell_backticks( command_line )
+      shell_result = @system_wrapper.shell_backticks( command_line, options[:boom] )
     end
 
     #scrub the string for illegal output

data/lib/ceedling/version.rb

@@ -2,7 +2,7 @@
 module Ceedling
   module Version
     # @private
-    GEM = "0.24.0"
+    GEM = "0.25.0"
     # @private
     CEEDLING = GEM
     # @private

data/plugins/command_hooks/README.md

@@ -0,0 +1,52 @@
+ceedling-command-hooks
+======================
+
+Plugin for easily calling command line tools at various points in the build process
+
+Define any of these sections in :tools: to provide additional hooks to be called on demand:
+
+```
+    :pre_mock_generate
+    :post_mock_generate
+    :pre_runner_generate
+    :post_runner_generate
+    :pre_compile_execute
+    :post_compile_execute
+    :pre_link_execute
+    :post_link_execute
+    :pre_test_fixture_execute
+    :pre_test_fixture_execute
+    :pre_test
+    :post_test
+    :pre_release
+    :post_release
+    :pre_build
+    :post_build
+```
+
+Each of these tools can support an :executable string and an :args list, like so:
+
+```
+:tools:
+  :post_link_execute:
+    :executable: objcopy.exe
+    :args:
+      - ${1} #This is replaced with the executable name
+      - output.srec
+      - --strip-all
+```
+
+You may also specify an array of executables to be called in a particular place, like so:
+
+```
+:tools:
+  :post_test:
+    -  :executable: echo
+       :args: "${1} was glorious!"
+    -  :executable: echo
+       :args:
+         - it kinda made me cry a little.
+         - you?
+```
+
+Happy Tweaking!

data/plugins/command_hooks/lib/command_hooks.rb

@@ -0,0 +1,71 @@
+require 'ceedling/plugin'
+require 'ceedling/constants'
+
+class CommandHooks < Plugin
+
+  attr_reader :config
+
+  def setup
+    @config = {
+      :pre_mock_generate         => ((defined? TOOLS_PRE_MOCK_GENERATE)         ? TOOLS_PRE_MOCK_GENERATE         : nil ),
+      :post_mock_generate        => ((defined? TOOLS_POST_MOCK_GENERATE)        ? TOOLS_POST_MOCK_GENERATE        : nil ),
+      :pre_runner_generate       => ((defined? TOOLS_PRE_RUNNER_GENERATE)       ? TOOLS_PRE_RUNNER_GENERATE       : nil ),
+      :post_runner_generate      => ((defined? TOOLS_POST_RUNNER_GENERATE)      ? TOOLS_POST_RUNNER_GENERATE      : nil ),
+      :pre_compile_execute       => ((defined? TOOLS_PRE_COMPILE_EXECUTE)       ? TOOLS_PRE_COMPILE_EXECUTE       : nil ),
+      :post_compile_execute      => ((defined? TOOLS_POST_COMPILE_EXECUTE)      ? TOOLS_POST_COMPILE_EXECUTE      : nil ),
+      :pre_link_execute          => ((defined? TOOLS_PRE_LINK_EXECUTE)          ? TOOLS_PRE_LINK_EXECUTE          : nil ),
+      :post_link_execute         => ((defined? TOOLS_POST_LINK_EXECUTE)         ? TOOLS_POST_LINK_EXECUTE         : nil ),
+      :pre_test_fixture_execute  => ((defined? TOOLS_PRE_TEST_FIXTURE_EXECUTE)  ? TOOLS_PRE_TEST_FIXTURE_EXECUTE  : nil ),
+      :post_test_fixture_execute => ((defined? TOOLS_POST_TEST_FIXTURE_EXECUTE) ? TOOLS_POST_TEST_FIXTURE_EXECUTE : nil ),
+      :pre_test                  => ((defined? TOOLS_PRE_TEST)                  ? TOOLS_PRE_TEST                  : nil ),
+      :post_test                 => ((defined? TOOLS_POST_TEST)                 ? TOOLS_POST_TEST                 : nil ),
+      :pre_release               => ((defined? TOOLS_PRE_RELEASE)               ? TOOLS_PRE_RELEASE               : nil ),
+      :post_release              => ((defined? TOOLS_POST_RELEASE)              ? TOOLS_POST_RELEASE              : nil ),
+      :pre_build                 => ((defined? TOOLS_PRE_BUILD)                 ? TOOLS_PRE_BUILD                 : nil ),
+      :post_build                => ((defined? TOOLS_POST_BUILD)                ? TOOLS_POST_BUILD                : nil ),
+    }
+    @plugin_root = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+  end
+
+  def pre_mock_generate(arg_hash);         run_hook(:pre_mock_generate,         arg_hash[:header_file] ); end
+  def post_mock_generate(arg_hash);        run_hook(:post_mock_generate,        arg_hash[:header_file] ); end
+  def pre_runner_generate(arg_hash);       run_hook(:pre_runner_generate,       arg_hash[:source     ] ); end
+  def post_runner_generate(arg_hash);      run_hook(:post_runner_generate,      arg_hash[:runner_file] ); end
+  def pre_compile_execute(arg_hash);       run_hook(:pre_compile_execute,       arg_hash[:source_file] ); end
+  def post_compile_execute(arg_hash);      run_hook(:post_compile_execute,      arg_hash[:object_file] ); end
+  def pre_link_execute(arg_hash);          run_hook(:pre_link_execute,          arg_hash[:executable]  ); end
+  def post_link_execute(arg_hash);         run_hook(:post_link_execute,         arg_hash[:executable]  ); end
+  def pre_test_fixture_execute(arg_hash);  run_hook(:pre_test_fixture_execute,  arg_hash[:executable]  ); end
+  def post_test_fixture_execute(arg_hash); run_hook(:post_test_fixture_execute, arg_hash[:executable]  ); end
+  def pre_test(test);                      run_hook(:pre_test,                  test                   ); end
+  def post_test(test);                     run_hook(:post_test,                 test                   ); end
+  def pre_release;                         run_hook(:pre_release                                       ); end
+  def post_release;                        run_hook(:post_release                                      ); end
+  def pre_build;                           run_hook(:pre_build                                         ); end
+  def post_build;                          run_hook(:post_build                                        ); end
+
+  private
+
+  def run_hook_step(hook, name)
+    if (hook[:executable])
+      cmd = @ceedling[:tool_executor].build_command_line( hook, [], name )
+      shell_result = @ceedling[:tool_executor].exec( cmd[:line], cmd[:options] )
+    end
+  end
+
+  def run_hook(which_hook, name="")
+    if (@config[which_hook])
+      @ceedling[:streaminator].stdout_puts("Running Hook #{which_hook}...", Verbosity::NORMAL)
+      if (@config[which_hook].is_a? Array)
+        @config[which_hook].each do |hook|
+          run_hook_step(hook, name)
+        end
+      elsif (@config[which_hook].is_a? Hash)
+        run_hook_step( @config[which_hook], name )
+      else
+        @ceedling[:streaminator].stdout_puts("Hook #{which_hook} was poorly formed", Verbosity::COMPLAINT)
+      end
+    end
+  end
+end
+

data/plugins/module_generator/lib/module_generator.rb

@@ -22,10 +22,16 @@ class ModuleGenerator < Plugin
 
   def divine_options(optz={})
     {
-      :path_src => MODULE_GENERATOR_SOURCE_ROOT.gsub('\\', '/').sub(/^\//, '').sub(/\/$/, ''),
-      :path_inc => MODULE_GENERATOR_SOURCE_ROOT.gsub('\\', '/').sub(/^\//, '').sub(/\/$/, ''),
-      :path_tst => MODULE_GENERATOR_TEST_ROOT.gsub('\\', '/').sub(/^\//, '').sub(/\/$/, ''),
-      :pattern => optz[:pattern],
+      :path_src     => ((defined? MODULE_GENERATOR_SOURCE_ROOT ) ? MODULE_GENERATOR_SOURCE_ROOT.gsub('\\', '/').sub(/^\//, '').sub(/\/$/, '') : "src" ),
+      :path_inc     => ((defined? MODULE_GENERATOR_SOURCE_ROOT ) ? MODULE_GENERATOR_SOURCE_ROOT.gsub('\\', '/').sub(/^\//, '').sub(/\/$/, '') : "src" ),
+      :path_tst     => ((defined? MODULE_GENERATOR_TEST_ROOT   ) ? MODULE_GENERATOR_TEST_ROOT.gsub(  '\\', '/').sub(/^\//, '').sub(/\/$/, '') : "test" ),
+      :pattern      => optz[:pattern],
+      :test_prefix  => ((defined? PROJECT_TEST_FILE_PREFIX     ) ? PROJECT_TEST_FILE_PREFIX : "Test" ),
+      :mock_prefix  => ((defined? CMOCK_MOCK_PREFIX            ) ? CMOCK_MOCK_PREFIX : "Mock" ),
+      :includes     => ((defined? MODULE_GENERATOR_INCLUDES    ) ? MODULE_GENERATOR_INCLUDES : {} ),
+      :boilerplates => ((defined? MODULE_GENERATOR_BOILERPLATES) ? MODULE_GENERATOR_BOILERPLATES : {} ),
+      :naming       => ((defined? MODULE_GENERATOR_NAMING      ) ? MODULE_GENERATOR_NAMING : "snake" ),
+      :update_svn   => ((defined? MODULE_GENERATOR_UPDATE_SVN  ) ? MODULE_GENERATOR_UPDATE_SVN : false ),
     }
   end
 

data/plugins/module_generator/module_generator.rake

@@ -5,7 +5,7 @@ namespace :module do
   task :create, :module_path do |t, args|
     files = [args[:module_path]] + (args.extras || [])
     optz = {}
-    ["dh", "dih", "mch", "mvp"].each do |pat|
+    ["dh", "dih", "mch", "mvp", "src", "test"].each do |pat|
       p = files.delete(pat)
       optz[:pattern] = p unless p.nil?
     end
@@ -16,7 +16,7 @@ namespace :module do
   task :destroy, :module_path do |t, args|
     files = [args[:module_path]] + (args.extras || [])
     optz = { :destroy => true }
-    ["dh", "dih", "mch", "mvp"].each do |pat|
+    ["dh", "dih", "mch", "mvp", "src", "test"].each do |pat|
       p = files.delete(pat)
       optz[:pattern] = p unless p.nil?
     end

data/spec/spec_system_helper.rb

@@ -168,14 +168,16 @@ module CeedlingTestCases
   def can_test_projects
     @c.with_context do
       Dir.chdir @proj_name do
-        FileUtils.cp test_asset_path("example_file.h"), 'src'
-        FileUtils.cp test_asset_path("example_file.c"), 'src'
-        FileUtils.cp test_asset_path("test_example_file.c"), 'test'
-
-        output = `bundle exec ruby -S rake test:all 2>&1`
-        expect(output).to match(/TESTED:\s+2/)
-        expect(output).to match(/PASSED:\s+1/)
-        expect(output).to match(/IGNORED:\s+0/)
+        FileUtils.cp test_asset_path("example_file.h"), 'src/'
+        FileUtils.cp test_asset_path("example_file.c"), 'src/'
+        FileUtils.cp test_asset_path("test_example_file.c"), 'test/'
+
+        output = `bundle exec ruby -S ceedling test:all`
+        expect($?.exitstatus).to match(0)
+        expect(output).to match(/TESTED:\s+\d/)
+        expect(output).to match(/PASSED:\s+\d/)
+        expect(output).to match(/FAILED:\s+\d/)
+        expect(output).to match(/IGNORED:\s+\d/)
       end
     end
   end
@@ -183,9 +185,12 @@ module CeedlingTestCases
   def can_use_the_module_plugin
     @c.with_context do
       Dir.chdir @proj_name do
-        `bundle exec ruby -S rake module:create[ponies] 2>&1`
-        output = `bundle exec ruby -S rake test:all 2>&1`
-        expect(output).to match(/No tests executed/i)
+        output = `bundle exec ruby -S ceedling module:create[ponies]`
+        expect($?.exitstatus).to match(0)
+        expect(output).to match(/Generate Complete/i)
+        output = `bundle exec ruby -S ceedling test:all`
+        expect($?.exitstatus).to match(0)
+        expect(output).to match(/Need to Implement ponies/)
       end
     end
   end

data/spec/system/deployment_spec.rb

@@ -81,7 +81,7 @@ describe "Ceedling" do
       it "should be testable" do
         @c.with_context do
           Dir.chdir "temp_sensor" do
-            @output = `bundle exec ruby -S rake test:all`
+            @output = `bundle exec ruby -S ceedling test:all`
             expect(@output).to match(/TESTED:\s+47/)
             expect(@output).to match(/PASSED:\s+47/)
           end
@@ -104,7 +104,7 @@ describe "Ceedling" do
     #   it "should be testable" do
     #     @c.with_context do
     #       Dir.chdir "blinky" do
-    #         @output = `bundle exec ruby -S rake test:all`
+    #         @output = `bundle exec ruby -S ceedling test:all`
     #         expect(@output).to match(/TESTED:\s+7/)
     #         expect(@output).to match(/PASSED:\s+7/)
     #       end

data/vendor/c_exception/vendor/unity/auto/generate_module.rb

@@ -10,6 +10,7 @@
 
 require 'rubygems'
 require 'fileutils'
+require 'pathname'
 
 #TEMPLATE_TST
 TEMPLATE_TST ||= %q[#include "unity.h"
@@ -35,7 +36,8 @@ TEMPLATE_SRC ||= %q[%2$s#include "%1$s.h"
 
 #TEMPLATE_INC
 TEMPLATE_INC ||= %q[#ifndef _%3$s_H
-#define _%3$s_H%2$s
+#define _%3$s_H
+%2$s
 
 #endif // _%3$s_H
 ]
@@ -65,19 +67,20 @@ class UnityModuleGenerator
 
     #Built in patterns
     @patterns = { 'src' => {''         => { :inc => [] } },
-                  'dh'  => {'Driver'   => { :inc => ['%1$sHardware.h'] },
+                  'test'=> {''         => { :inc => [] } },
+                  'dh'  => {'Driver'   => { :inc => [create_filename('%1$s','Hardware.h')] },
                             'Hardware' => { :inc => [] }
                            },
-                  'dih' => {'Driver'   => { :inc => ['%1$sHardware.h', '%1$sInterrupt.h'] },
-                            'Interrupt'=> { :inc => ['%1$sHardware.h'] },
+                  'dih' => {'Driver'   => { :inc => [create_filename('%1$s','Hardware.h'), create_filename('%1$s','Interrupt.h')] },
+                            'Interrupt'=> { :inc => [create_filename('%1$s','Hardware.h')] },
                             'Hardware' => { :inc => [] }
                            },
                   'mch' => {'Model'    => { :inc => [] },
-                            'Conductor'=> { :inc => ['%1$sModel.h', '%1$sHardware.h'] },
+                            'Conductor'=> { :inc => [create_filename('%1$s','Model.h'), create_filename('%1$s','Hardware.h')] },
                             'Hardware' => { :inc => [] }
                            },
                   'mvp' => {'Model'    => { :inc => [] },
-                            'Presenter'=> { :inc => ['%1$sModel.h', '%1$sView.h'] },
+                            'Presenter'=> { :inc => [create_filename('%1$s','Model.h'), create_filename('%1$s','View.h')] },
                             'View'     => { :inc => [] }
                            }
                 }
@@ -96,6 +99,7 @@ class UnityModuleGenerator
       :update_svn      => false,
       :boilerplates    => {},
       :test_prefix     => 'Test',
+      :mock_prefix     => 'Mock',
     }
   end
 
@@ -113,30 +117,42 @@ class UnityModuleGenerator
 
   ############################
   def files_to_operate_on(module_name, pattern=nil)
+    #strip any leading path information from the module name and save for later
+    subfolder = File.dirname(module_name)
+    module_name = File.basename(module_name)
+
     #create triad definition
     prefix = @options[:test_prefix] || 'Test'
-    triad = [ { :ext => '.c', :path => @options[:path_src],        :template => TEMPLATE_SRC, :inc => :src, :boilerplate => @options[:boilerplates][:src] },
-              { :ext => '.h', :path => @options[:path_inc],        :template => TEMPLATE_INC, :inc => :inc, :boilerplate => @options[:boilerplates][:inc] },
-              { :ext => '.c', :path => @options[:path_tst]+prefix, :template => TEMPLATE_TST, :inc => :tst, :boilerplate => @options[:boilerplates][:tst] },
+    triad = [ { :ext => '.c', :path => @options[:path_src], :prefix => "",     :template => TEMPLATE_SRC, :inc => :src, :boilerplate => @options[:boilerplates][:src] },
+              { :ext => '.h', :path => @options[:path_inc], :prefix => "",     :template => TEMPLATE_INC, :inc => :inc, :boilerplate => @options[:boilerplates][:inc] },
+              { :ext => '.c', :path => @options[:path_tst], :prefix => prefix, :template => TEMPLATE_TST, :inc => :tst, :boilerplate => @options[:boilerplates][:tst] },
             ]
 
     #prepare the pattern for use
-    patterns = @patterns[(pattern || @options[:pattern] || 'src').downcase]
+    pattern = (pattern || @options[:pattern] || 'src').downcase
+    patterns = @patterns[pattern]
     raise "ERROR: The design pattern '#{pattern}' specified isn't one that I recognize!" if patterns.nil?
 
+    #single file patterns (currently just 'test') can reject the other parts of the triad
+    if (pattern == 'test')
+      triad.reject!{|v| v[:inc] != :tst }
+    end
+
     # Assemble the path/names of the files we need to work with.
     files = []
-    triad.each do |triad|
+    triad.each do |cfg|
       patterns.each_pair do |pattern_file, pattern_traits|
+        submodule_name = create_filename(module_name, pattern_file)
+        filename = cfg[:prefix] + submodule_name + cfg[:ext]
         files << {
-          :path => "#{triad[:path]}#{module_name}#{pattern_file}#{triad[:ext]}",
-          :name => "#{module_name}#{pattern_file}",
-          :template => triad[:template],
-          :boilerplate => triad[:boilerplate],
-          :includes => case(triad[:inc])
-                         when :src then @options[:includes][:src] | pattern_traits[:inc].map{|f| f % [module_name]}
-                         when :inc then @options[:includes][:inc]
-                         when :tst then @options[:includes][:tst] | pattern_traits[:inc].map{|f| "Mock#{f}"% [module_name]}
+          :path => (Pathname.new("#{cfg[:path]}#{subfolder}") + filename).cleanpath,
+          :name => submodule_name,
+          :template => cfg[:template],
+          :boilerplate => cfg[:boilerplate],
+          :includes => case(cfg[:inc])
+                         when :src then (@options[:includes][:src] || []) | pattern_traits[:inc].map{|f| f % [module_name]}
+                         when :inc then (@options[:includes][:inc] || [])
+                         when :tst then (@options[:includes][:tst] || []) | pattern_traits[:inc].map{|f| "#{@options[:mock_prefix]}#{f}" % [module_name]}
                        end
         }
       end
@@ -145,6 +161,27 @@ class UnityModuleGenerator
     return files
   end
 
+  ############################
+  def create_filename(part1, part2="")
+    if part2.empty?
+      case(@options[:naming])
+      when 'bumpy' then part1
+      when 'camel' then part1
+      when 'snake' then part1.downcase
+      when 'caps'  then part1.upcase
+      else              part1.downcase
+      end
+    else
+      case(@options[:naming])
+      when 'bumpy' then part1 + part2
+      when 'camel' then part1 + part2
+      when 'snake' then part1.downcase + "_" + part2.downcase
+      when 'caps'  then part1.upcase + "_" + part2.upcase
+      else              part1.downcase + "_" + part2.downcase
+      end
+    end
+  end
+
   ############################
   def generate(module_name, pattern=nil)
 
@@ -157,8 +194,9 @@ class UnityModuleGenerator
 
     # Create Source Modules
     files.each_with_index do |file, i|
+      FileUtils.mkdir_p(File.dirname(file[:path]), :verbose => false) # Create the path first if necessary.
       File.open(file[:path], 'w') do |f|
-        f.write(file[:boilerplate] % [file[:name]]) unless file[:boilerplate].nil?
+        f.write("#{file[:boilerplate]}\n" % [file[:name]]) unless file[:boilerplate].nil?
         f.write(file[:template] % [ file[:name],
                                     file[:includes].map{|f| "#include \"#{f}\"\n"}.join,
                                     file[:name].upcase ]
@@ -210,13 +248,14 @@ if ($0 == __FILE__)
   # Parse the command line parameters.
   ARGV.each do |arg|
     case(arg)
-      when /^-d/      then destroy = true
-      when /^-u/      then options[:update_svn] = true
-      when /^-p(\w+)/ then options[:pattern] = $1
-      when /^-s(.+)/  then options[:path_src] = $1
-      when /^-i(.+)/  then options[:path_inc] = $1
-      when /^-t(.+)/  then options[:path_tst] = $1
-      when /^-y(.+)/  then options = UnityModuleGenerator.grab_config($1)
+      when /^-d/            then destroy = true
+      when /^-u/            then options[:update_svn] = true
+      when /^-p\"?(\w+)\"?/ then options[:pattern] = $1
+      when /^-s\"?(.+)\"?/  then options[:path_src] = $1
+      when /^-i\"?(.+)\"?/  then options[:path_inc] = $1
+      when /^-t\"?(.+)\"?/  then options[:path_tst] = $1
+      when /^-n\"?(.+)\"?/  then options[:naming] = $1
+      when /^-y\"?(.+)\"?/  then options = UnityModuleGenerator.grab_config($1)
       when /^(\w+)/
         raise "ERROR: You can't have more than one Module name specified!" unless module_name.nil?
         module_name = arg
@@ -234,12 +273,18 @@ if ($0 == __FILE__)
            "  -s\"../src\"  sets the path to output source to '../src'   (DEFAULT ../src)",
            "  -t\"C:/test\" sets the path to output source to 'C:/test'  (DEFAULT ../test)",
            "  -p\"MCH\"     sets the output pattern to MCH.",
-           "              dh  - driver hardware.",
-           "              dih - driver interrupt hardware.",
-           "              mch - model conductor hardware.",
-           "              mvp - model view presenter.",
-           "              src - just a single source module. (DEFAULT)",
+           "              dh   - driver hardware.",
+           "              dih  - driver interrupt hardware.",
+           "              mch  - model conductor hardware.",
+           "              mvp  - model view presenter.",
+           "              src  - just a source module, header and test. (DEFAULT)",
+           "              test - just a test file.",
            "  -d          destroy module instead of creating it.",
+           "  -n\"camel\"   sets the file naming convention.",
+           "              bumpy - BumpyCaseFilenames.",
+           "              camel - camelCaseFilenames.",
+           "              snake - snake_case_filenames. (DEFAULT)",
+           "              caps  - CAPS_CASE_FILENAMES.",
            "  -u          update subversion too (requires subversion command line)",
            "  -y\"my.yml\"  selects a different yaml config file for module generation",
            "" ].join("\n")
@@ -254,5 +299,3 @@ if ($0 == __FILE__)
   end
 
 end
-
-

data/vendor/c_exception/vendor/unity/extras/fixture/src/unity_fixture.c

@@ -9,7 +9,7 @@
 #include "unity_fixture.h"
 #include "unity_internals.h"
 
-struct _UnityFixture UnityFixture;
+struct UNITY_FIXTURE_T UnityFixture;
 
 /* If you decide to use the function pointer approach.
  * Build with -D UNITY_OUTPUT_CHAR=outputChar and include <stdio.h>