ceedling 0.9.0 → 1.0.1

data/new_project_template/vendor/ceedling/vendor/cmock/src/cmock.c

@@ -1,186 +0,0 @@
-/* ==========================================
-    CMock Project - Automatic Mock Generation for C
-    Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
-    [Released under MIT License. Please refer to license.txt for details]
-========================================== */
-
-#include "unity.h"
-#include "cmock.h"
-
-//define CMOCK_MEM_DYNAMIC to grab memory as needed with malloc
-//when you do that, CMOCK_MEM_SIZE is used for incremental size instead of total
-#ifdef CMOCK_MEM_STATIC
-#undef CMOCK_MEM_DYNAMIC
-#endif
-
-#ifdef CMOCK_MEM_DYNAMIC
-#include <stdlib.h>
-#endif
-
-//this is used internally during pointer arithmetic. make sure this type is the same size as the target's pointer type
-#ifndef CMOCK_MEM_PTR_AS_INT
-#define CMOCK_MEM_PTR_AS_INT unsigned long
-#endif
-
-//0 for no alignment, 1 for 16-bit, 2 for 32-bit, 3 for 64-bit
-#ifndef CMOCK_MEM_ALIGN
-#define CMOCK_MEM_ALIGN (2)
-#endif
-
-//amount of memory to allow cmock to use in its internal heap
-#ifndef CMOCK_MEM_SIZE
-#define CMOCK_MEM_SIZE (32768)
-#endif
-
-//automatically calculated defs for easier reading
-#define CMOCK_MEM_ALIGN_SIZE  (1u << CMOCK_MEM_ALIGN)
-#define CMOCK_MEM_ALIGN_MASK  (CMOCK_MEM_ALIGN_SIZE - 1)
-#define CMOCK_MEM_INDEX_SIZE  ((sizeof(CMOCK_MEM_INDEX_TYPE) > CMOCK_MEM_ALIGN_SIZE) ? sizeof(CMOCK_MEM_INDEX_TYPE) : CMOCK_MEM_ALIGN_SIZE)
-
-//private variables
-#ifdef CMOCK_MEM_DYNAMIC
-static unsigned char*         CMock_Guts_Buffer = NULL;
-static CMOCK_MEM_INDEX_TYPE   CMock_Guts_BufferSize = CMOCK_MEM_ALIGN_SIZE;
-static CMOCK_MEM_INDEX_TYPE   CMock_Guts_FreePtr;
-#else
-static unsigned char          CMock_Guts_Buffer[CMOCK_MEM_SIZE + CMOCK_MEM_ALIGN_SIZE];
-static CMOCK_MEM_INDEX_TYPE   CMock_Guts_BufferSize = CMOCK_MEM_SIZE + CMOCK_MEM_ALIGN_SIZE;
-static CMOCK_MEM_INDEX_TYPE   CMock_Guts_FreePtr;
-#endif
-//-------------------------------------------------------
-// CMock_Guts_MemNew
-//-------------------------------------------------------
-CMOCK_MEM_INDEX_TYPE CMock_Guts_MemNew(CMOCK_MEM_INDEX_TYPE size)
-{
-  CMOCK_MEM_INDEX_TYPE index;
-
-  //verify arguments valid (we must be allocating space for at least 1 byte, and the existing chain must be in memory somewhere)
-  if (size < 1)
-    return CMOCK_GUTS_NONE;
-
-  //verify we have enough room
-  size = size + CMOCK_MEM_INDEX_SIZE;
-  if (size & CMOCK_MEM_ALIGN_MASK)
-    size = (size + CMOCK_MEM_ALIGN_MASK) & ~CMOCK_MEM_ALIGN_MASK;
-  if ((CMock_Guts_BufferSize - CMock_Guts_FreePtr) < size)
-  {
-#ifdef CMOCK_MEM_DYNAMIC
-    CMock_Guts_BufferSize += CMOCK_MEM_SIZE + size;
-    CMock_Guts_Buffer = realloc(CMock_Guts_Buffer, CMock_Guts_BufferSize);
-    if (CMock_Guts_Buffer == NULL)
-#endif //yes that if will continue to the return below if TRUE
-      return CMOCK_GUTS_NONE;
-  }
-
-  //determine where we're putting this new block, and init its pointer to be the end of the line
-  index = CMock_Guts_FreePtr + CMOCK_MEM_INDEX_SIZE;
-  *(CMOCK_MEM_INDEX_TYPE*)(&CMock_Guts_Buffer[CMock_Guts_FreePtr]) = CMOCK_GUTS_NONE;
-  CMock_Guts_FreePtr += size;
-
-  return index;
-}
-
-//-------------------------------------------------------
-// CMock_Guts_MemChain
-//-------------------------------------------------------
-CMOCK_MEM_INDEX_TYPE CMock_Guts_MemChain(CMOCK_MEM_INDEX_TYPE root_index, CMOCK_MEM_INDEX_TYPE obj_index)
-{
-  CMOCK_MEM_INDEX_TYPE index;
-  void* root;
-  void* obj;
-  void* next;
-
-  if (root_index == CMOCK_GUTS_NONE)
-  {
-    //if there is no root currently, we return this object as the root of the chain
-    return obj_index;
-  }
-  else
-  {
-    //reject illegal nodes
-    if ((root_index < CMOCK_MEM_ALIGN_SIZE) || (root_index >= CMock_Guts_FreePtr))
-    {
-      return CMOCK_GUTS_NONE;
-    }
-    if ((obj_index < CMOCK_MEM_ALIGN_SIZE) || (obj_index >= CMock_Guts_FreePtr))
-    {
-      return CMOCK_GUTS_NONE;
-    }
-    
-    root = (void*)(&CMock_Guts_Buffer[root_index]);
-    obj  = (void*)(&CMock_Guts_Buffer[obj_index]);
-
-    //find the end of the existing chain and add us
-    next = root;
-    do {
-      index = *(CMOCK_MEM_INDEX_TYPE*)((CMOCK_MEM_PTR_AS_INT)next - CMOCK_MEM_INDEX_SIZE);
-      if (index >= CMock_Guts_FreePtr)
-        return CMOCK_GUTS_NONE;
-      if (index > 0)
-        next = (void*)(&CMock_Guts_Buffer[index]);
-    } while (index > 0);
-    *(CMOCK_MEM_INDEX_TYPE*)((CMOCK_MEM_PTR_AS_INT)next - CMOCK_MEM_INDEX_SIZE) = ((CMOCK_MEM_PTR_AS_INT)obj - (CMOCK_MEM_PTR_AS_INT)CMock_Guts_Buffer);
-    return root_index;
-  }
-}
-
-//-------------------------------------------------------
-// CMock_Guts_MemNext
-//-------------------------------------------------------
-CMOCK_MEM_INDEX_TYPE CMock_Guts_MemNext(CMOCK_MEM_INDEX_TYPE previous_item_index)
-{
-  CMOCK_MEM_INDEX_TYPE index;
-  void* previous_item;
-
-  //There is nothing "next" if the pointer isn't from our buffer
-  if ((previous_item_index < CMOCK_MEM_ALIGN_SIZE) || (previous_item_index  >= CMock_Guts_FreePtr))
-    return CMOCK_GUTS_NONE;
-  previous_item = (void*)(&CMock_Guts_Buffer[previous_item_index]);
-
-  //if the pointer is good, then use it to look up the next index
-  //(we know the first element always goes in zero, so NEXT must always be > 1)
-  index = *(CMOCK_MEM_INDEX_TYPE*)((CMOCK_MEM_PTR_AS_INT)previous_item - CMOCK_MEM_INDEX_SIZE);
-  if ((index > 1) && (index < CMock_Guts_FreePtr))
-    return index;
-  else
-    return CMOCK_GUTS_NONE;
-}
-
-//-------------------------------------------------------
-// CMock_GetAddressFor
-//-------------------------------------------------------
-void* CMock_Guts_GetAddressFor(CMOCK_MEM_INDEX_TYPE index)
-{
-  if ((index >= CMOCK_MEM_ALIGN_SIZE) && (index < CMock_Guts_FreePtr))
-  {
-    return (void*)(&CMock_Guts_Buffer[index]);
-  }
-  else
-  {
-    return NULL;
-  }
-}
-
-//-------------------------------------------------------
-// CMock_Guts_MemBytesFree
-//-------------------------------------------------------
-CMOCK_MEM_INDEX_TYPE CMock_Guts_MemBytesFree(void)
-{
-  return CMock_Guts_BufferSize - CMock_Guts_FreePtr;
-}
-
-//-------------------------------------------------------
-// CMock_Guts_MemBytesUsed
-//-------------------------------------------------------
-CMOCK_MEM_INDEX_TYPE CMock_Guts_MemBytesUsed(void)
-{
-  return CMock_Guts_FreePtr - CMOCK_MEM_ALIGN_SIZE;
-}
-
-//-------------------------------------------------------
-// CMock_Guts_MemFreeAll
-//-------------------------------------------------------
-void CMock_Guts_MemFreeAll(void)
-{
-  CMock_Guts_FreePtr = CMOCK_MEM_ALIGN_SIZE; //skip the very beginning
-}

data/new_project_template/vendor/ceedling/vendor/cmock/src/cmock.h

@@ -1,30 +0,0 @@
-/* ==========================================
-    CMock Project - Automatic Mock Generation for C
-    Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
-    [Released under MIT License. Please refer to license.txt for details]
-========================================== */
-
-#ifndef CMOCK_FRAMEWORK_H
-#define CMOCK_FRAMEWORK_H
-
-//should be big enough to index full range of CMOCK_MEM_MAX
-#ifndef CMOCK_MEM_INDEX_TYPE
-#define CMOCK_MEM_INDEX_TYPE  unsigned int
-#endif
-
-#define CMOCK_GUTS_NONE (0)
-
-//-------------------------------------------------------
-// Memory API
-//-------------------------------------------------------
-CMOCK_MEM_INDEX_TYPE  CMock_Guts_MemNew(CMOCK_MEM_INDEX_TYPE size);
-CMOCK_MEM_INDEX_TYPE  CMock_Guts_MemChain(CMOCK_MEM_INDEX_TYPE root_index, CMOCK_MEM_INDEX_TYPE obj_index);
-CMOCK_MEM_INDEX_TYPE  CMock_Guts_MemNext(CMOCK_MEM_INDEX_TYPE previous_item_index);
-
-void*                 CMock_Guts_GetAddressFor(CMOCK_MEM_INDEX_TYPE index);
-
-CMOCK_MEM_INDEX_TYPE  CMock_Guts_MemBytesFree(void);
-CMOCK_MEM_INDEX_TYPE  CMock_Guts_MemBytesUsed(void);
-void                  CMock_Guts_MemFreeAll(void);
-
-#endif //CMOCK_FRAMEWORK

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

@@ -1,127 +0,0 @@
-CONSTRUCTOR_VERSION = '1.0.4' #:nodoc:#
-
-class Class #:nodoc:#
-  def constructor(*attrs, &block)
-    call_block = ''
-    if block_given?
-      @constructor_block = block
-      call_block = 'self.instance_eval(&self.class.constructor_block)'
-    end
-    # Look for embedded options in the listing:
-    opts = attrs.find { |a| a.kind_of?(Hash) and attrs.delete(a) } 
-    do_acc = opts.nil? ? false : opts[:accessors] == true
-    do_reader = opts.nil? ? false : opts[:readers] == true
-    require_args = opts.nil? ? true : opts[:strict] != false
-    super_args = opts.nil? ? nil : opts[:super]
-
-    # Incorporate superclass's constructor keys, if our superclass
-    if superclass.constructor_keys
-      similar_keys = superclass.constructor_keys & attrs
-      raise "Base class already has keys #{similar_keys.inspect}" unless similar_keys.empty?
-      attrs = [attrs,superclass.constructor_keys].flatten
-    end
-    # Generate ivar assigner code lines
-    assigns = ''
-    attrs.each do |k|
-      assigns += "@#{k.to_s} = args[:#{k.to_s}]\n"
-    end 
-
-    # If accessors option is on, declare accessors for the attributes:
-    if do_acc
-      add_accessors = "attr_accessor " + attrs.reject {|x| superclass.constructor_keys.include?(x.to_sym)}.map {|x| ":#{x.to_s}"}.join(',')
-      #add_accessors = "attr_accessor " + attrs.map {|x| ":#{x.to_s}"}.join(',')
-      self.class_eval add_accessors
-    end
-
-    # If readers option is on, declare readers for the attributes:
-    if do_reader
-      self.class_eval "attr_reader " + attrs.reject {|x| superclass.constructor_keys.include?(x.to_sym)}.map {|x| ":#{x.to_s}"}.join(',')
-    end
-    
-    # If user supplied super-constructor hints:
-    super_call = ''
-    if super_args
-      list = super_args.map do |a|
-        case a
-        when String
-          %|"#{a}"|
-        when Symbol
-          %|:#{a}|
-        end
-      end
-      super_call  = %|super(#{list.join(',')})|
-    end
-
-    # If strict is on, define the constructor argument validator method,
-    # and setup the initializer to invoke the validator method.
-    # Otherwise, insert lax code into the initializer.
-    validation_code = "return if args.nil?"
-    if require_args
-      self.class_eval do 
-        def _validate_constructor_args(args)
-          # First, make sure we've got args of some kind
-          unless args and args.keys and args.keys.size > 0 
-            raise ConstructorArgumentError.new(self.class.constructor_keys)
-          end
-          # Scan for missing keys in the argument hash
-          a_keys = args.keys
-          missing = []
-          self.class.constructor_keys.each do |ck|
-            unless a_keys.member?(ck)
-              missing << ck
-            end
-            a_keys.delete(ck) # Delete inbound keys as we address them
-          end
-          if missing.size > 0 || a_keys.size > 0
-            raise ConstructorArgumentError.new(missing,a_keys)
-          end
-        end
-      end
-      # Setup the code to insert into the initializer:
-      validation_code = "_validate_constructor_args args "
-    end
-
-    # Generate the initializer code
-    self.class_eval %{
-      def initialize(args=nil)
-        #{super_call}
-        #{validation_code}
-        #{assigns}
-        setup if respond_to?(:setup)
-        #{call_block}
-      end
-    }
-
-    # Remember our constructor keys
-    @_ctor_keys = attrs
-  end
-
-  # Access the constructor keys for this class
-  def constructor_keys; @_ctor_keys ||=[]; end
-
-  def constructor_block #:nodoc:#
-    @constructor_block
-  end
-
-end
-
-# Fancy validation exception, based on missing and extraneous keys.
-class ConstructorArgumentError < RuntimeError #:nodoc:#
-  def initialize(missing,rejected=[])
-    err_msg = ''
-    if missing.size > 0
-      err_msg = "Missing constructor args [#{missing.join(',')}]"
-    end
-    if rejected.size > 0
-      # Some inbound keys were not addressed earlier; this means they're unwanted
-      if err_msg
-        err_msg << "; " # Appending to earlier message about missing items
-      else
-        err_msg = ''
-      end
-      # Enumerate the rejected key names
-      err_msg << "Rejected constructor args [#{rejected.join(',')}]"
-    end
-    super err_msg
-  end
-end

data/new_project_template/vendor/ceedling/vendor/constructor/lib/constructor_struct.rb

@@ -1,33 +0,0 @@
-class ConstructorStruct
-  def self.new(*accessors, &block)
-    defaults = {:accessors => true, :strict => false}
-    
-    accessor_names = accessors.dup
-    if accessors.last.is_a? Hash
-      accessor_names.pop
-      user_opts = accessors.last
-      user_opts.delete(:accessors)
-      defaults.each do |k,v|
-        user_opts[k] ||= v
-      end
-    else
-      accessors << defaults
-    end
-    
-    Class.new do
-      constructor *accessors
-
-      class_eval(&block) if block
-
-      comparator_code = accessor_names.map { |fname| "self.#{fname} == o.#{fname}" }.join(" && ")
-      eval %|
-        def ==(o)
-          (self.class == o.class) && #{comparator_code}
-        end
-        def eql?(o)
-          (self.class == o.class) && #{comparator_code}
-        end
-      |
-    end
-  end
-end

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

@@ -1,211 +0,0 @@
-module DeepMerge
-
-  MAJOR_VERSION = 0
-  MINOR_VERSION = 1
-  FIX_VERSION = 0
-  VERSION = "#{MAJOR_VERSION}.#{MINOR_VERSION}.#{FIX_VERSION}"
-
-  class InvalidParameter < StandardError; end
-  
-  DEFAULT_FIELD_KNOCKOUT_PREFIX = '--'
-
-  module DeepMergeHash
-    # ko_hash_merge! will merge and knockout elements prefixed with DEFAULT_FIELD_KNOCKOUT_PREFIX
-    def ko_deep_merge!(source, options = {})
-      default_opts = {:knockout_prefix => "--", :preserve_unmergeables => false}
-      DeepMerge::deep_merge!(source, self, default_opts.merge(options))
-    end
-
-    # deep_merge! will merge and overwrite any unmergeables in destination hash
-    def deep_merge!(source, options = {})
-      default_opts = {:preserve_unmergeables => false}
-      DeepMerge::deep_merge!(source, self, default_opts.merge(options))
-    end
-
-    # deep_merge will merge and skip any unmergeables in destination hash
-    def deep_merge(source, options = {})
-      default_opts = {:preserve_unmergeables => true}
-      DeepMerge::deep_merge!(source, self, default_opts.merge(options))
-    end
-
-  end # DeepMergeHashExt
-  
-  # Deep Merge core documentation.
-  # deep_merge! method permits merging of arbitrary child elements. The two top level
-  # elements must be hashes. These hashes can contain unlimited (to stack limit) levels
-  # of child elements. These child elements to not have to be of the same types.
-  # Where child elements are of the same type, deep_merge will attempt to merge them together.
-  # Where child elements are not of the same type, deep_merge will skip or optionally overwrite
-  # the destination element with the contents of the source element at that level.
-  # So if you have two hashes like this:
-  #   source = {:x => [1,2,3], :y => 2}
-  #   dest =   {:x => [4,5,'6'], :y => [7,8,9]}
-  #   dest.deep_merge!(source)
-  #   Results: {:x => [1,2,3,4,5,'6'], :y => 2}
-  # By default, "deep_merge!" will overwrite any unmergeables and merge everything else.
-  # To avoid this, use "deep_merge" (no bang/exclamation mark)
-  # 
-  # Options:
-  #   Options are specified in the last parameter passed, which should be in hash format:
-  #   hash.deep_merge!({:x => [1,2]}, {:knockout_prefix => '--'})
-  #   :preserve_unmergeables  DEFAULT: false
-  #      Set to true to skip any unmergeable elements from source
-  #   :knockout_prefix        DEFAULT: nil
-  #      Set to string value to signify prefix which deletes elements from existing element
-  #   :sort_merged_arrays     DEFAULT: false
-  #      Set to true to sort all arrays that are merged together
-  #   :unpack_arrays          DEFAULT: nil
-  #      Set to string value to run "Array::join" then "String::split" against all arrays
-  #   :merge_debug            DEFAULT: false
-  #      Set to true to get console output of merge process for debugging
-  #
-  # Selected Options Details:
-  # :knockout_prefix => The purpose of this is to provide a way to remove elements 
-  #   from existing Hash by specifying them in a special way in incoming hash
-  #    source = {:x => ['--1', '2']}
-  #    dest   = {:x => ['1', '3']}
-  #    dest.ko_deep_merge!(source)
-  #    Results: {:x => ['2','3']}
-  #   Additionally, if the knockout_prefix is passed alone as a string, it will cause
-  #   the entire element to be removed:
-  #    source = {:x => '--'}
-  #    dest   = {:x => [1,2,3]}
-  #    dest.ko_deep_merge!(source)
-  #    Results: {:x => ""}
-  # :unpack_arrays => The purpose of this is to permit compound elements to be passed
-  #   in as strings and to be converted into discrete array elements
-  #   irsource = {:x => ['1,2,3', '4']}
-  #   dest   = {:x => ['5','6','7,8']}
-  #   dest.deep_merge!(source, {:unpack_arrays => ','})
-  #   Results: {:x => ['1','2','3','4','5','6','7','8'}
-  #   Why: If receiving data from an HTML form, this makes it easy for a checkbox 
-  #    to pass multiple values from within a single HTML element
-  # 
-  # There are many tests for this library - and you can learn more about the features
-  # and usages of deep_merge! by just browsing the test examples
-  def DeepMerge.deep_merge!(source, dest, options = {})
-    # turn on this line for stdout debugging text
-    merge_debug = options[:merge_debug] || false
-    overwrite_unmergeable = !options[:preserve_unmergeables]
-    knockout_prefix = options[:knockout_prefix] || nil
-    if knockout_prefix == "" then raise InvalidParameter, "knockout_prefix cannot be an empty string in deep_merge!"; end
-    if knockout_prefix && !overwrite_unmergeable then raise InvalidParameter, "overwrite_unmergeable must be true if knockout_prefix is specified in deep_merge!"; end
-    # if present: we will split and join arrays on this char before merging
-    array_split_char = options[:unpack_arrays] || false
-    # request that we sort together any arrays when they are merged
-    sort_merged_arrays = options[:sort_merged_arrays] || false
-    di = options[:debug_indent] || ''
-    # do nothing if source is nil
-    if source.nil? || (source.respond_to?(:blank?) && source.blank?) then return dest; end
-    # if dest doesn't exist, then simply copy source to it
-    if dest.nil? && overwrite_unmergeable then dest = source; return dest; end
-
-    puts "#{di}Source class: #{source.class.inspect} :: Dest class: #{dest.class.inspect}" if merge_debug
-    if source.kind_of?(Hash)
-      puts "#{di}Hashes: #{source.inspect} :: #{dest.inspect}" if merge_debug
-      source.each do |src_key, src_value|
-        if dest.kind_of?(Hash)
-          puts "#{di} looping: #{src_key.inspect} => #{src_value.inspect} :: #{dest.inspect}" if merge_debug
-          if not dest[src_key].nil?
-            puts "#{di} ==>merging: #{src_key.inspect} => #{src_value.inspect} :: #{dest[src_key].inspect}" if merge_debug
-            dest[src_key] = deep_merge!(src_value, dest[src_key], options.merge(:debug_indent => di + '  '))
-          else # dest[src_key] doesn't exist so we want to create and overwrite it (but we do this via deep_merge!)
-            puts "#{di} ==>merging over: #{src_key.inspect} => #{src_value.inspect}" if merge_debug
-            # note: we rescue here b/c some classes respond to "dup" but don't implement it (Numeric, TrueClass, FalseClass, NilClass among maybe others)
-            begin
-              src_dup = src_value.dup # we dup src_value if possible because we're going to merge into it (since dest is empty)
-            rescue TypeError
-              src_dup = src_value
-            end
-            dest[src_key] = deep_merge!(src_value, src_dup, options.merge(:debug_indent => di + '  '))
-          end
-        else # dest isn't a hash, so we overwrite it completely (if permitted)
-          if overwrite_unmergeable
-            puts "#{di}  overwriting dest: #{src_key.inspect} => #{src_value.inspect} -over->  #{dest.inspect}" if merge_debug
-            dest = overwrite_unmergeables(source, dest, options)
-          end
-        end
-      end
-    elsif source.kind_of?(Array)
-      puts "#{di}Arrays: #{source.inspect} :: #{dest.inspect}" if merge_debug
-      # if we are instructed, join/split any source arrays before processing
-      if array_split_char
-        puts "#{di} split/join on source: #{source.inspect}" if merge_debug
-        source = source.join(array_split_char).split(array_split_char)
-        if dest.kind_of?(Array) then dest = dest.join(array_split_char).split(array_split_char); end
-      end
-      # if there's a naked knockout_prefix in source, that means we are to truncate dest
-      if source.index(knockout_prefix) then dest = clear_or_nil(dest); source.delete(knockout_prefix); end
-      if dest.kind_of?(Array)
-        if knockout_prefix
-          print "#{di} knocking out: " if merge_debug
-          # remove knockout prefix items from both source and dest
-          source.delete_if do |ko_item|
-            retval = false
-            item = ko_item.respond_to?(:gsub) ? ko_item.gsub(%r{^#{knockout_prefix}}, "") : ko_item
-            if item != ko_item
-              print "#{ko_item} - " if merge_debug
-              dest.delete(item)
-              dest.delete(ko_item)
-              retval = true
-            end
-            retval
-          end
-          puts if merge_debug
-        end
-        puts "#{di} merging arrays: #{source.inspect} :: #{dest.inspect}" if merge_debug
-        dest = dest | source
-        if sort_merged_arrays then dest.sort!; end
-      elsif overwrite_unmergeable
-        puts "#{di} overwriting dest: #{source.inspect} -over-> #{dest.inspect}" if merge_debug
-        dest = overwrite_unmergeables(source, dest, options)
-      end
-    else # src_hash is not an array or hash, so we'll have to overwrite dest
-      puts "#{di}Others: #{source.inspect} :: #{dest.inspect}" if merge_debug
-      dest = overwrite_unmergeables(source, dest, options)
-    end
-    puts "#{di}Returning #{dest.inspect}" if merge_debug
-    dest
-  end # deep_merge!
-
-  # allows deep_merge! to uniformly handle overwriting of unmergeable entities
-  def DeepMerge::overwrite_unmergeables(source, dest, options)
-    merge_debug = options[:merge_debug] || false
-    overwrite_unmergeable = !options[:preserve_unmergeables]
-    knockout_prefix = options[:knockout_prefix] || false
-    di = options[:debug_indent] || ''
-    if knockout_prefix && overwrite_unmergeable
-      if source.kind_of?(String) # remove knockout string from source before overwriting dest
-        src_tmp = source.gsub(%r{^#{knockout_prefix}},"")
-      elsif source.kind_of?(Array) # remove all knockout elements before overwriting dest
-        src_tmp = source.delete_if {|ko_item| ko_item.kind_of?(String) && ko_item.match(%r{^#{knockout_prefix}}) }
-      else
-        src_tmp = source
-      end
-      if src_tmp == source # if we didn't find a knockout_prefix then we just overwrite dest
-        puts "#{di}#{src_tmp.inspect} -over-> #{dest.inspect}" if merge_debug
-        dest = src_tmp
-      else # if we do find a knockout_prefix, then we just delete dest
-        puts "#{di}\"\" -over-> #{dest.inspect}" if merge_debug
-        dest = ""
-      end
-    elsif overwrite_unmergeable
-      dest = source
-    end
-    dest
-  end
-
-  def DeepMerge::clear_or_nil(obj)
-    if obj.respond_to?(:clear)
-      obj.clear
-    else
-      obj = nil
-    end
-    obj
-  end
-
-end # module DeepMerge
-
-class Hash
-  include DeepMerge::DeepMergeHash
-end

data/new_project_template/vendor/ceedling/vendor/diy/lib/diy/factory.rb

@@ -1,36 +0,0 @@
-module DIY #:nodoc:#
-  class FactoryDef #:nodoc:
-    attr_accessor :name, :target, :class_name, :library
-    
-    def initialize(opts)
-      @name, @target, @library, @auto_require =
-        opts[:name], opts[:target], opts[:library], opts[:auto_require]
-
-			@class_name = Infl.camelize(@target)
-			@library ||= Infl.underscore(@class_name) if @auto_require
-    end
-  end
-  
-	class Context
-    def construct_factory(key)
-      factory_def = @defs[key]
-#      puts "requiring #{factory_def.library}"
-      require factory_def.library	if factory_def.library
-
-			big_c = get_class_for_name_with_module_delimeters(factory_def.class_name)
-
-      FactoryFactory.new(big_c)
-    end
-  end
-
-  class FactoryFactory
-    def initialize(clazz)
-      @class_to_create = clazz
-    end
-
-    def create(*args)
-      @class_to_create.new(*args)
-    end
-  end
-end
-