ceedling 0.0.1

data/new_project_template/vendor/ceedling/vendor/constructor/specs/constructor_spec.rb

@@ -0,0 +1,407 @@
+require File.expand_path(File.dirname(__FILE__) + '/../lib/constructor') 
+
+describe 'standard constructor usage' do
+  it 'allows for object construction using a hash of named arguments' do
+    fuh = TestingClass.new( 
+      :foo => 'my foo',
+      :bar => 'my bar',
+      :qux => 'my qux',
+      :why => 'lucky'
+    )
+
+    fuh.foo.should eql('my foo')
+    fuh.bar.should eql('my bar') 
+    fuh.qux.should eql('my qux')
+    fuh.why.should eql('lucky')
+    fuh.to_pretty_pretty.should eql('my foo my bar')
+  end
+
+  it 'calls setup method if defined' do
+    ralph = Llamma.new :hair => 'red'
+    ralph.hungry.should be_true
+    ralph.hair.should eql('red')
+  end
+end
+
+describe "constructor's accessor option" do
+  it 'provides accessors for constructor arguments when accessor option is true' do
+    fuh = TestingAutoAccessors.new( 
+      :foo => 'my foo',
+      :bar => 'my bar',
+      :qux => 'my qux',
+      :why => 'lucky'
+    )
+    fuh.foo.should eql('my foo')
+    fuh.bar.should eql('my bar')
+    fuh.qux.should eql('my qux')
+    fuh.why.should eql('lucky')
+    fuh.to_pretty_pretty.should eql('my foo my bar')
+  end
+
+  it 'does not provide accessors for constructor arguments when accessor option is false' do
+    fuh = TestingBlockedAccessors.new :foo => 'my foo', :bar => 'my bar'
+    lambda {fuh.foo}.should raise_error(NoMethodError)
+    lambda {fuh.bar}.should raise_error(NoMethodError)
+    fuh.to_pretty_pretty.should eql('my foo my bar')
+  end
+end
+
+describe "constructor's reader option" do
+  it 'provides readers for constructor arguments when reader option is true' do
+    fuh = TestingAutoReaders.new( 
+      :foo => 'my foo',
+      :why => 'lucky'
+    )
+    fuh.foo.should eql('my foo')
+    fuh.why.should eql('lucky')
+    fuh.to_pretty_pretty.should eql('my foo lucky')
+
+    lambda {fuh.why = 'no way'}.should raise_error(NoMethodError)
+    lambda {fuh.foo = 'uh uh'}.should raise_error(NoMethodError)
+  end
+
+  it 'does not provide reader for constructor arguments when reader option is false' do
+    fuh = TestingBlockedReaders.new :foo => 'my foo', :why => 'my why'
+    lambda {fuh.foo}.should raise_error(NoMethodError)
+    lambda {fuh.bar}.should raise_error(NoMethodError)
+    fuh.to_pretty_pretty.should eql('my foo my why')
+
+    lambda {fuh.why = 'no way'}.should raise_error(NoMethodError)
+    lambda {fuh.foo = 'uh uh'}.should raise_error(NoMethodError)
+  end
+end
+
+describe 'using constructor with inheritance' do
+  it 'allows for inheritance of constructor arguments using a non-constructor defined subclass' do
+    fuh = SubclassOfTestingClass.new :foo => 'whu?'
+    fuh.foo.should eql('whu?')
+    fuh.bar.should be_nil
+    fuh.qux.should be_nil
+    fuh.why.should be_nil
+  end
+
+  it 'allows for standard construction of a non-constructor subclass of a non-strict constuctor superclass' do
+    fuh = SubclassOfTestingClass2.new 
+    fuh.foo.should be_nil
+  end
+
+  it 'runs initialize method of a sublcass' do
+    fuh = SubclassOfTestingClass3.new
+    fuh.my_new_var.should eql('something')
+    fuh.foo.should be_nil
+    fuh.bar.should be_nil
+    fuh.qux.should be_nil
+    fuh.why.should be_nil
+  end
+
+  it 'passes named constructor args to superclass when subclass calls super' do
+    fuh = SubclassOfTestingClass3.new :foo => 12
+    fuh.my_new_var.should eql('something')
+    fuh.foo.should eql(12)
+    fuh.bar.should be_nil
+    fuh.qux.should be_nil
+    fuh.why.should be_nil
+  end
+
+  it 'allows for inheritance of constructor arguments using a constructor defined subclass' do
+    s = Sonny.new :car => 'Nissan', :saw => 'Dewalt', :computer => 'Dell'
+    s.computer.should eql('Dell')
+    s.saw.should eql('Dewalt')
+    s.car.should eql('Nissan')
+  end
+  
+  it 'calls the setup method on superclass if subclass does not define a setup method' do
+    baby = Baby.new :cuteness => 'little', :age => 1
+    baby.fat.should eql('much')
+  end 
+
+  it 'calls parent class setup when super is called from subclass setup'  do
+    m = Mama.new :age => 55
+    m.age.should eql(55)
+    m.fat.should eql('much')
+    
+    s = Sissy.new :age => 19, :beauty => 'medium', :fat => 'yeah'
+    s.age.should eql(19)
+    s.beauty.should eql('medium')
+    s.fat.should eql('much')
+    s.friends.should eql('many')
+  end
+
+  it 'passes arguments given in the super option to the initializer of a non-constructor defined superclass' do
+    tsc = TestingSuperConstructor.new(:far => 'oo', :away => 'kk')
+    tsc.far.should eql('oo')
+    tsc.away.should eql('kk')
+    tsc.a.should eql("once")
+    tsc.b.should eql(:twice)
+  end 
+
+  it 'calls non-constructor defined superclass constructor when the super option is an empty array' do
+    tsc = TestingSuperConstructor2.new(:some => 'thing')
+    tsc.some.should eql('thing')
+    tsc.c.should eql('what a')
+    tsc.d.should eql('day for')
+  end
+  
+  it "raises an error if subclass tries to build a constructor with the keys as its parents" do
+    class1 = constructor_class(Object, :star, :wars)
+    class2 = constructor_class(class1, :space, :balls)
+    lambda { constructor_class(class2, :star, :space, :chewy) }.should raise_error("Base class already has keys [:space, :star]")
+  end
+  
+  it 'does not create accessors for superclass constructor arguments' do
+    tas = TestingAccessorSubclass.new(:far => 'thing')
+    tas.respond_to?(:cuteness).should be_false
+  end
+  
+  it 'does not create a reader for superclass constructor arguments' do
+    t1 = TestingReaderSubclass.new(:foo => 'thing')
+    t1.respond_to?(:foo).should be_false
+  end
+end
+
+describe 'stict mode usage' do
+  it 'allows omission of arguments when strict is off' do
+    fuh = TestingClass.new :foo => 'my foo' 
+    
+    fuh.foo.should eql('my foo')
+    fuh.bar.should be_nil
+    fuh.qux.should be_nil
+    fuh.why.should be_nil
+  end
+
+  it 'allows no arguments to a constructor when strict is off' do
+    fuh = TestingClass.new
+    fuh.foo.should be_nil
+    fuh.bar.should be_nil
+    fuh.qux.should be_nil
+    fuh.why.should be_nil
+  end
+
+  it 'does not interfere with normal object construction' do
+    require 'rexml/document'
+    d = REXML::Document.new '<base/>'
+    d.should_not be_nil
+    d.root.name.should eql('base')
+  end
+
+  def see_strict_args_in_effect_for(clazz)
+    fuh = clazz.new :foo => 'my foo', :bar => 'my bar'
+    fuh.to_pretty_pretty.should eql('my foo my bar')
+
+    # Omit foo
+    lambda {
+      TestingStrictArgsDefault.new :bar => 'ok,yeah'
+    }.should raise_error(ConstructorArgumentError, /foo/)
+    
+    # Omit bar
+    lambda {
+      TestingStrictArgsDefault.new :foo => 'ok,yeah'
+    }.should raise_error(ConstructorArgumentError, /bar/)
+  end
+
+  it 'defaults to strict argument enforcement' do
+    see_strict_args_in_effect_for TestingStrictArgsDefault
+  end
+
+  it 'enforces strict arguments when strict option is true' do
+    see_strict_args_in_effect_for TestingStrictArgs
+  end
+
+  it 'does not allow empty constructor arguments when strict option is true' do
+    lambda {TestingStrictArgs.new {}}.should raise_error(ConstructorArgumentError,/foo,bar/)
+    lambda {TestingStrictArgs.new}.should raise_error(ConstructorArgumentError,/foo,bar/)
+    lambda {TestingStrictArgs.new nil}.should raise_error(ConstructorArgumentError,/foo,bar/)
+  end
+
+  it 'does not allow extraneous arguments when strict option is true' do
+    [ /thing/, /other/ ].each do |rejected_arg|
+      lambda {
+        TestingStrictArgs.new(:foo => 1, :bar => 2, :other => 3, :thing => 4)
+      }.should raise_error(ConstructorArgumentError, rejected_arg)
+    end
+  end
+
+  it 'allows for setting accessors option while in strict mode' do
+    t2 = TestingStrictArgs2.new :foo => 1, :bar => 2
+    
+    # See that accessors work
+    t2.foo.should eql(1)
+    t2.bar.should eql(2)
+
+    # See that strictness still applies
+    lambda {TestingStrictArgs2.new :no => 'good'}.should raise_error(ConstructorArgumentError)
+  end
+end
+
+describe 'catching ConstructorArgumentError' do
+  it 'allows for generic rescuing of constructor argument errors' do
+    begin
+      TestingStrictArgs.new :broken => 'yoobetcha'
+    rescue => bad_news
+      bad_news.should be_kind_of(ConstructorArgumentError)
+    end
+  end
+end
+
+describe 'block yielding' do
+  it 'executes a specified block after instantiating' do
+    TestingBlockYield.new(:a => false).a.should == true
+  end
+end
+
+def constructor_class(base, *keys)
+  Class.new(base) do
+    constructor *keys
+  end
+end
+
+class TestingClass
+  attr_accessor :foo, :bar, :why, :qux
+  constructor :foo, :bar, :why, :qux, :strict => false
+
+  def to_pretty_pretty
+    "#{@foo} #{@bar}"
+  end
+
+end
+
+class Mama
+  attr_accessor :fat, :age
+  constructor :age, :strict => false
+  def setup
+    @fat = "much"
+  end
+end
+
+class Baby < Mama
+  constructor :cuteness
+end
+
+class Sissy < Mama
+  attr_accessor :friends, :beauty
+  constructor :beauty, :strict => false
+  def setup
+    super #IMPORTANT!
+    @friends = "many"
+  end
+end
+
+class TestingStrictArgsDefault
+  constructor :foo, :bar
+  def to_pretty_pretty
+    "#{@foo} #{@bar}"
+  end
+end
+
+class TestingStrictArgs
+  constructor :foo, :bar, :strict => true
+  def to_pretty_pretty
+    "#{@foo} #{@bar}"
+  end
+end
+
+class TestingStrictArgs2
+  constructor :foo, :bar, :accessors => true
+end
+
+class SubclassOfTestingClass < TestingClass
+end
+
+class SubclassOfTestingClass2 < TestingClass
+  def initialize; end
+end
+
+class SubclassOfTestingClass3 < TestingClass
+  attr_reader :my_new_var
+  def initialize(hash = nil)
+    super
+    @my_new_var = "something"
+  end
+end
+
+class TestingAutoAccessors
+  constructor :foo, :bar, :why, :qux, :accessors => true, :strict => false
+  def to_pretty_pretty
+    "#{@foo} #{@bar}"
+  end
+end
+
+class TestingAutoReaders
+  constructor :foo, :why, :readers => true, :strict => false
+  def to_pretty_pretty
+    "#{@foo} #{@why}"
+  end
+end
+
+class TestingReaderSuperclass
+  constructor :foo
+end
+
+class TestingReaderSubclass < TestingReaderSuperclass
+  constructor :bar,  :readers => true, :strict => false
+end  
+
+class TestingSuperConstructorBase
+  attr_reader :a, :b
+  def initialize(a,b)
+    @a = a
+    @b = b
+  end
+end
+
+class TestingSuperConstructor < TestingSuperConstructorBase
+  constructor :far, :away, :accessors => true, :super => ["once", :twice], :strict => false
+end
+
+class TestingSuperConstructorBase2
+  attr_reader :c, :d
+  def initialize
+    @c = 'what a'
+    @d = 'day for'
+  end
+end
+
+class TestingSuperConstructor2 < TestingSuperConstructorBase2
+  constructor :some, :accessors => true, :super => [], :strict => false
+end
+
+class TestingAccessorSubclass < Baby
+  constructor :foo, :accessors => true, :strict => false
+end
+
+class TestingBlockedAccessors
+  constructor :foo, :bar, :accessors => false
+  def to_pretty_pretty
+    "#{@foo} #{@bar}"
+  end
+end
+
+class TestingBlockedReaders
+  constructor :foo, :why, :readers => false
+  def to_pretty_pretty
+    "#{@foo} #{@why}"
+  end
+end
+
+class Papa
+  constructor :car, :saw
+end
+
+class Sonny < Papa
+  attr_accessor :car, :saw, :computer
+  constructor :computer
+end
+
+class Llamma
+  attr_accessor :hungry, :hair
+  constructor :hair
+  def setup
+    @hungry = true
+  end
+end
+  
+class TestingBlockYield
+  constructor :a, :accessors => true do
+    @a = true
+  end
+end

data/new_project_template/vendor/ceedling/vendor/constructor/specs/constructor_struct_spec.rb

@@ -0,0 +1,84 @@
+require File.dirname(__FILE__) + '/../lib/constructor_struct'
+
+describe ConstructorStruct, "#new" do
+  def struct(*accessors)
+    ConstructorStruct.new(*accessors)
+  end
+  
+  def instance_of(clazz, args=nil)
+    args = [args] || []
+    clazz.new(*args)
+  end
+  
+  before do
+    AClass = struct(:hello, :world) unless defined?(AClass)
+  end
+  
+  it "creates a new class with accessors given a set of symbols or strings" do
+    instance_of(AClass, {:hello => "foo", :world => "bar"}).hello.should == "foo"
+    instance_of(AClass, {:hello => "foo", :world => "bar"}).world.should == "bar"
+  end
+  
+  it "creates a real class" do
+    instance_of(AClass).class.should == AClass
+  end
+  
+  it "has the option of creating a strict accessors" do
+    lambda { instance_of(struct(:foo, :strict => true)) }.should raise_error
+  end
+  
+  it "does not have the option of not creating accessors" do
+    instance_of(struct(:foo, :accessors => false), :foo => "bar").foo.should == "bar"
+  end
+
+  describe "equivalence" do
+    before do
+      @hello = "Hello"
+      @world = "World"
+      @args = { :hello => @hello, :world => @world }
+      @target = AClass.new(@args)
+    end
+
+    it "uses all accessors" do
+      [ nil, :hello, :world ].each do |field_to_alter|
+        alt = AClass.new(:hello => @hello, :world => @world)
+
+        unless field_to_alter
+          # Base case: they should be equal
+          @target.should == alt
+          @target.eql?(alt).should be_true #should eql(alt)
+        else
+          # Change 1 field and see not equal
+          alt.send("#{field_to_alter}=", "other data")
+          @target.should_not == alt
+          @target.should_not eql(alt)
+        end
+      end
+    end
+
+    it "will not compare to another class with same fields" do
+      BClass = ConstructorStruct.new(:hello, :world)
+      alt = BClass.new(:hello => @hello, :world => @world)
+      @target.should_not == alt
+      @target.should_not eql(alt)
+    end
+  end
+
+  describe "extra method definitions" do
+    NightTrain = ConstructorStruct.new(:beer, :conductor) do
+      def setup
+        @conductor ||= "Bill"
+      end
+    end
+
+    it "lets you declare instance methods within a block" do
+      night_train = NightTrain.new(:beer => "Founders")
+      night_train.beer.should == "Founders"
+      night_train.conductor.should == "Bill"
+
+      other_train = NightTrain.new(:beer => "Bells", :conductor => "Dave")
+      other_train.conductor.should == "Dave"
+    end
+  end
+
+end

data/new_project_template/vendor/ceedling/vendor/deep_merge/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 [name of plugin creator]
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/new_project_template/vendor/ceedling/vendor/deep_merge/README

@@ -0,0 +1,94 @@
+DeepMerge Overview
+==================
+
+Deep Merge is a simple set of utility functions for Hash. It permits
+you to merge elements inside a hash together recursively. The manner
+by which it does this is somewhat arbitrary (since there is no defining 
+standard for this) but it should end up being pretty intuitive and do what
+you expect.
+
+You can learn a lot more about this by reading the test file. It's pretty
+well documented and has many examples of various merges from very simple
+to pretty complex.
+
+The primary need that caused me to write this library is the merging of elements
+coming from HTTP parameters and related stored parameters in session. This lets
+a user build up a set of parameters over time, modifying individual items.
+
+Deep Merge Core Documentation
+=============================
+ There are three key methods that are added to Hash when you require deep_merge:
+ 
+ deep_merge!(new_hash[, opts]) -- merges and new_hash wins unmergeable situations
+ deep_merge(new_hash[, opts]) -- merges and "self" hash wins unmergeable situations
+ ko_deep_merge!(new_hash[, opts]) -- same as deep_merge! but "--" provides "knockout" functions
+ 
+ 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
+
+
+Simple Example Code
+===================
+
+require 'deep_merge'
+x = {:x => [3,4,5]}
+y = {:x => [1,2,3]}
+y.deep_merge!(x)
+# results: y = {:x => [1,2,3,4,5]}
+
+Availablility
+=============
+SVN Repo here:  http://trac.misuse.org/science/wiki/DeepMerge
+Contact author: http://www.misuse.org/science
+
+Copyright (c) 2008 Steve Midgley, released under the MIT license

data/new_project_template/vendor/ceedling/vendor/deep_merge/Rakefile

@@ -0,0 +1,28 @@
+require 'rubygems'
+require 'lib/deep_merge'
+Gem::manage_gems
+require 'rake/gempackagetask'
+
+spec = Gem::Specification.new do |s|
+    s.platform  =   Gem::Platform::RUBY
+    s.name      =   "deep_merge"
+    s.version   =   DeepMerge::VERSION
+    s.author    =   "Steve Midgley"
+    s.email     =   "public@misuse.org"
+    s.summary   =   "Permits recursive/deep merges of arrays and hashes."
+    s.files     =   FileList['lib/*.rb', 'test/*'].to_a
+    s.require_path  =   "lib"
+    s.autorequire   =   "deep_merge"
+    s.test_files = Dir.glob('tests/*.rb')
+    s.has_rdoc  =   true
+    s.extra_rdoc_files  =   ["README"]
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+    pkg.need_tar = true
+end
+
+task :default => "pkg/#{spec.name}-#{spec.version}.gem" do
+    puts "generated latest version"
+end
+