pancake 0.2.0 → 0.3.0

data/lib/pancake/vendor/hashie/spec/hashie/clash_spec.rb

@@ -0,0 +1,42 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Hashie::Clash do
+  before do
+    @c = Hashie::Clash.new
+  end
+  
+  it 'should be able to set an attribute via method_missing' do
+    @c.foo('bar')
+    @c[:foo].should == 'bar'
+  end
+  
+  it 'should be able to set multiple attributes' do
+    @c.foo('bar').baz('wok')
+    @c.should == {:foo => 'bar', :baz => 'wok'}
+  end
+  
+  it 'should convert multiple arguments into an array' do
+    @c.foo(1, 2, 3)
+    @c[:foo].should == [1,2,3]
+  end
+  
+  it 'should be able to use bang notation to create a new Clash on a key' do
+    @c.foo!
+    @c[:foo].should be_kind_of(Hashie::Clash)
+  end
+  
+  it 'should be able to chain onto the new Clash when using bang notation' do
+    @c.foo!.bar('abc').baz(123)
+    @c.should == {:foo => {:bar => 'abc', :baz => 123}}
+  end
+  
+  it 'should be able to jump back up to the parent in the chain with #_end!' do
+    @c.foo!.bar('abc')._end!.baz(123)
+    @c.should == {:foo => {:bar => 'abc'}, :baz => 123}
+  end
+  
+  it 'should merge rather than replace existing keys' do
+    @c.where(:abc => 'def').where(:hgi => 123)
+    @c.should == {:where => {:abc => 'def', :hgi => 123}}
+  end
+end

data/lib/pancake/vendor/hashie/spec/hashie/dash_spec.rb

@@ -0,0 +1,103 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+class DashTest < Hashie::Dash
+  property :first_name
+  property :email
+  property :count, :default => 0
+end
+
+class Subclassed < DashTest
+  property :last_name
+end
+
+describe Hashie::Dash do
+  it 'should be a subclass of Hashie::Hash' do
+    (Hashie::Dash < Hash).should be_true
+  end
+  
+  it '#inspect should be ok!' do
+    dash = DashTest.new
+    dash.email = "abd@abc.com"
+    dash.inspect.should == "<#DashTest count=0 email=\"abd@abc.com\" first_name=nil>"
+  end
+   
+  describe ' creating properties' do
+    it 'should add the property to the list' do
+      DashTest.property :not_an_att
+      DashTest.properties.include?('not_an_att').should be_true
+    end
+    
+    it 'should create a method for reading the property' do
+      DashTest.new.respond_to?(:first_name).should be_true
+    end
+    
+    it 'should create a method for writing the property' do
+      DashTest.new.respond_to?(:first_name=).should be_true
+    end
+  end
+  
+  describe 'reading properties' do
+    it 'should raise an error when reading a non-existent property' do 
+      lambda{@dash['abc']}.should raise_error(NoMethodError)
+    end
+  end
+  
+  describe ' writing to properties' do
+    before do
+      @dash = DashTest.new
+    end
+    
+    it 'should not be able to write to a non-existent property using []=' do
+      lambda{@dash['abc'] = 123}.should raise_error(NoMethodError)
+    end
+    
+    it 'should be able to write to an existing property using []=' do
+      lambda{@dash['first_name'] = 'Bob'}.should_not raise_error
+    end
+    
+    it 'should be able to read/write to an existing property using a method call' do
+      @dash.first_name = 'Franklin'
+      @dash.first_name.should == 'Franklin'
+    end
+  end
+  
+  describe ' initializing with a Hash' do
+    it 'should not be able to initialize non-existent properties' do
+      lambda{DashTest.new(:bork => 'abc')}.should raise_error(NoMethodError)
+    end
+    
+    it 'should set properties that it is able to' do
+      DashTest.new(:first_name => 'Michael').first_name.should == 'Michael'
+    end
+  end
+  
+  describe ' defaults' do
+    before do
+      @dash = DashTest.new
+    end
+    
+    it 'should return the default value for defaulted' do
+      DashTest.property :defaulted, :default => 'abc'
+      DashTest.new.defaulted.should == 'abc'
+    end
+  end
+end
+
+describe Subclassed do
+  it "should inherit all properties from DashTest" do
+    Subclassed.properties.size.should == 6
+  end
+  
+  it "should inherit all defaults from DashTest" do
+    Subclassed.defaults.size.should == 6
+  end
+  
+  it "should init without raising" do
+    lambda { Subclassed.new }.should_not raise_error
+    lambda { Subclassed.new(:first_name => 'Michael') }.should_not raise_error
+  end
+  
+  it "should share defaults from DashTest" do
+    Subclassed.new.count.should == 0
+  end
+end

data/lib/pancake/vendor/hashie/spec/hashie/hash_spec.rb

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Hash do
+  it "should be convertible to a Hashie::Mash" do
+    mash = Hashie::Hash[:some => "hash"].to_mash
+    mash.is_a?(Hashie::Mash).should be_true
+    mash.some.should == "hash"
+  end
+  
+  it "#stringify_keys! should turn all keys into strings" do
+    hash = Hashie::Hash[:a => "hey", 123 => "bob"]
+    hash.stringify_keys!
+    hash.should == Hashie::Hash["a" => "hey", "123" => "bob"]
+  end
+  
+  it "#stringify_keys should return a hash with stringified keys" do
+    hash = Hashie::Hash[:a => "hey", 123 => "bob"]
+    stringified_hash = hash.stringify_keys
+    hash.should == Hashie::Hash[:a => "hey", 123 => "bob"]
+    stringified_hash.should == Hashie::Hash["a" => "hey", "123" => "bob"]
+  end
+end

data/lib/pancake/vendor/hashie/spec/hashie/mash_spec.rb

@@ -0,0 +1,135 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Hashie::Mash do
+  before(:each) do
+    @mash = Hashie::Mash.new
+  end
+
+  it "should inherit from hash" do
+    @mash.is_a?(Hash).should be_true
+  end
+
+  it "should be able to set hash values through method= calls" do
+    @mash.test = "abc"
+    @mash["test"].should == "abc"
+  end
+
+  it "should be able to retrieve set values through method calls" do
+    @mash["test"] = "abc"
+    @mash.test.should == "abc"
+  end
+
+  it "should test for already set values when passed a ? method" do
+    @mash.test?.should be_false
+    @mash.test = "abc"
+    @mash.test?.should be_true
+  end
+
+  it "should make all [] and []= into strings for consistency" do
+    @mash["abc"] = 123
+    @mash.key?('abc').should be_true
+    @mash["abc"].should == 123
+  end
+
+  it "should have a to_s that is identical to its inspect" do
+    @mash.abc = 123
+    @mash.to_s.should == @mash.inspect
+  end
+
+  it "should return nil instead of raising an error for attribute-esque method calls" do
+    @mash.abc.should be_nil
+  end
+
+  it "should return a Hashie::Mash when passed a bang method to a non-existenct key" do
+    @mash.abc!.is_a?(Hashie::Mash).should be_true
+  end
+
+  it "should return the existing value when passed a bang method for an existing key" do
+    @mash.name = "Bob"
+    @mash.name!.should == "Bob"
+  end
+
+  it "#initializing_reader should return a Hashie::Mash when passed a non-existent key" do
+    @mash.initializing_reader(:abc).is_a?(Hashie::Mash).should be_true
+  end
+
+  it "should allow for multi-level assignment through bang methods" do
+    @mash.author!.name = "Michael Bleigh"
+    @mash.author.should == Hashie::Mash.new(:name => "Michael Bleigh")
+    @mash.author!.website!.url = "http://www.mbleigh.com/"
+    @mash.author.website.should == Hashie::Mash.new(:url => "http://www.mbleigh.com/")
+  end
+
+  it "#deep_update should recursively Hashie::Mash Hashie::Mashes and hashes together" do
+    @mash.first_name = "Michael"
+    @mash.last_name = "Bleigh"
+    @mash.details = Hashie::Hash[:email => "michael@asf.com"].to_mash
+    @mash.deep_update({:details => {:email => "michael@intridea.com"}})
+    @mash.details.email.should == "michael@intridea.com"
+  end
+
+  it "should convert hash assignments into Hashie::Mashes" do
+    @mash.details = {:email => 'randy@asf.com', :address => {:state => 'TX'} }
+    @mash.details.email.should == 'randy@asf.com'
+    @mash.details.address.state.should == 'TX'
+  end
+
+  it "should not convert the type of Hashie::Mashes childs to Hashie::Mash" do
+    class MyMash < Hashie::Mash
+    end
+
+    record = MyMash.new
+    record.son = MyMash.new
+    record.son.class.should == MyMash
+  end
+
+  context "#initialize" do
+    it "should convert an existing hash to a Hashie::Mash" do
+      converted = Hashie::Mash.new({:abc => 123, :name => "Bob"})
+      converted.abc.should == 123
+      converted.name.should == "Bob"
+    end
+
+    it "should convert hashes recursively into Hashie::Mashes" do
+      converted = Hashie::Mash.new({:a => {:b => 1, :c => {:d => 23}}})
+      converted.a.is_a?(Hashie::Mash).should be_true
+      converted.a.b.should == 1
+      converted.a.c.d.should == 23
+    end
+
+    it "should convert hashes in arrays into Hashie::Mashes" do
+      converted = Hashie::Mash.new({:a => [{:b => 12}, 23]})
+      converted.a.first.b.should == 12
+      converted.a.last.should == 23
+    end
+
+    it "should convert an existing Hashie::Mash into a Hashie::Mash" do
+      initial = Hashie::Mash.new(:name => 'randy', :address => {:state => 'TX'})
+      copy = Hashie::Mash.new(initial)
+      initial.name.should == copy.name
+      initial.object_id.should_not == copy.object_id
+      copy.address.state.should == 'TX'
+      copy.address.state = 'MI'
+      initial.address.state.should == 'TX'
+      copy.address.object_id.should_not == initial.address.object_id
+    end
+
+    it "should accept a default block" do
+      initial = Hashie::Mash.new { |h,i| h[i] = []}
+      initial.default_proc.should_not be_nil
+      initial.default.should be_nil
+      initial.test.should == []
+      initial.test?.should be_true
+    end
+
+    describe "to_json" do
+
+      it "should render to_json" do
+        @mash.foo = :bar
+        @mash.bar = {"homer" => "simpson"}
+        expected = {"foo" => "bar", "bar" => {"homer" => "simpson"}}
+        JSON.parse(@mash.to_json).should == expected
+      end
+    end
+  end
+end

data/lib/pancake/vendor/hashie/spec/spec.opts

@@ -0,0 +1,2 @@
+--colour
+--format progress

data/lib/pancake/{generators/templates/short/%stack_name%/spec/spec_helper.rb.tt → vendor/hashie/spec/spec_helper.rb}

@@ -1,13 +1,13 @@
-require 'spec'
-require 'rack/test'
-require 'pancake'
-
+require 'rubygems'
+require 'json'
 
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-require '<%= stack_name -%>'
+
+require 'hashie'
+require 'spec'
+require 'spec/autorun'
 
 Spec::Runner.configure do |config|
-  config.include(Rack::Test::Methods)
-  config.include(Pancake::Test::Matchers)
+
 end

data/spec/pancake/configuration_spec.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../spec_helper'
+require 'spec_helper'
 
 describe "Pancake::Configuration" do
 

data/spec/pancake/constants_spec.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../spec_helper'
+require 'spec_helper'
 
 describe Pancake::Constants do
   it "should have the ENV_LOGGER_KEY constant" do

data/spec/pancake/defaults/configuration_spec.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
+require 'spec_helper'
 
 describe "Pancake configuration defaults" do
   describe "logging defaults" do

data/spec/pancake/hooks/on_inherit_spec.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
+require 'spec_helper'
 
 describe "Pancake::Stack inheritance" do
   describe "inheritance hooks" do
@@ -11,17 +11,17 @@ describe "Pancake::Stack inheritance" do
         Pancake::Stack.on_inherit(&blk)
       end
     end
-  
+
     before(:each) do
       $collector = []
       clear_constants(:FooStack)
       Pancake::Stack.on_inherit.clear
     end
-  
+
     after(:each) do
       clear_constants(:FooStack)
     end
-  
+
     it "should be able to add inheritance hooks" do
       Pancake::Stack.on_inherit do |base, parent|
         $collector << base
@@ -29,32 +29,32 @@ describe "Pancake::Stack inheritance" do
       class ::FooStack < Pancake::Stack; end
       $collector.should == [FooStack]
     end
-  
+
     it "should be able to add multiple inheritance hooks" do
       Pancake::Stack.on_inherit{|b,p| $collector << b}
       Pancake::Stack.on_inherit{|b,p| $collector << :foo}
-    
+
       class ::FooStack < Pancake::Stack
       end
-    
+
       $collector.should == [FooStack, :foo]
     end
-    
+
   end
-  
+
   describe "Inheriting Stacks" do
-    before(:all) do 
+    before(:all) do
       clear_constants(:FooStack, :BarStack)
     end
-    
+
     before(:each) do
       class ::FooStack < Pancake::Stack; end
     end
-    
+
     after(:each) do
       clear_constants(:FooStack, :BarStack)
     end
-    
+
     describe "configuration" do
       it "should inherit the configuration with a stack" do
         class ::BarStack < ::FooStack; end

data/spec/pancake/inheritance_spec.rb

@@ -1,47 +1,47 @@
-require File.dirname(__FILE__) + '/../spec_helper'
+require 'spec_helper'
 
 describe "Pancake Inheritance" do
   describe "on inherit hook" do
-  
+
     before(:each) do
       clear_constants(:MyFoo, :OtherFoo, :FutherFoo, :SomeFoo, :DeeperFoo)
-      class ::MyFoo 
+      class ::MyFoo
         extend Pancake::Hooks::OnInherit
       end
-    
+
       ::MyFoo.on_inherit do |base, parent|
         $inherited_capture << {:base => base, :parent => parent}
       end
-      
+
       $inherited_capture = []
     end
-  
+
     it "should provide on_inherit callbacks" do
       class ::OtherFoo < MyFoo; end
       $inherited_capture.should  == [{:base => OtherFoo, :parent => MyFoo}]
     end
-    
+
     it "should inherit multiple times" do
       class ::OtherFoo < MyFoo; end
       class ::FurtherFoo < OtherFoo; end
       $inherited_capture.should == [{:base => OtherFoo, :parent => MyFoo}, {:base => FurtherFoo, :parent => OtherFoo}]
     end
-    
+
     it "should allow for multiple callbacks" do
       MyFoo.on_inherit{|base, parent| $inherited_capture << :second}
       class ::OtherFoo < MyFoo; end
       $inherited_capture.should == [{:base => OtherFoo, :parent => MyFoo}, :second]
     end
-    
+
     it "should allow for multiple callbacks that are inherited" do
       MyFoo.on_inherit{|base, parent| $inherited_capture << :second}
       class ::OtherFoo < MyFoo; end
       $inherited_capture = []
       OtherFoo.on_inherit{|base, parent| $inherited_capture << :inherited}
       class ::SomeFoo < OtherFoo; end
-      $inherited_capture.should == [{:base => SomeFoo, :parent => OtherFoo}, :second, :inherited]      
+      $inherited_capture.should == [{:base => SomeFoo, :parent => OtherFoo}, :second, :inherited]
     end
-    
+
     it "should not pollute the parent with the child inherited hooks" do
       class ::OtherFoo < MyFoo; end
       $inherited_capture = []
@@ -50,51 +50,51 @@ describe "Pancake Inheritance" do
       $inherited_capture.should == [{:base => SomeFoo, :parent => MyFoo}]
     end
   end # "on inherit hook"
-  
+
   describe "inheritable inner classes" do
-    
+
     before(:each) do
       clear_constants(:MyFoo, :OtherFoo, :InnerFoo, :SomeFoo, :DeeperFoo)
-      
+
       class ::MyFoo
         inheritable_inner_classes :InnerFoo
         class InnerFoo; end
       end
     end
-    
+
     it "should inherit the inner class along with the outer class" do
       class ::OtherFoo < MyFoo; end
       OtherFoo::InnerFoo.superclass.should equal(MyFoo::InnerFoo)
       OtherFoo::InnerFoo.should_not equal(MyFoo::InnerFoo)
     end
-    
+
     it "should inherit the inner class multiple times" do
       class ::OtherFoo < MyFoo; end
       class ::SomeFoo < OtherFoo; end
       class ::DeeperFoo < SomeFoo; end
-      
+
       SomeFoo::InnerFoo.superclass.should equal(OtherFoo::InnerFoo)
       SomeFoo::InnerFoo.should_not equal(OtherFoo::InnerFoo)
       DeeperFoo::InnerFoo.superclass.should equal(SomeFoo::InnerFoo)
       DeeperFoo::InnerFoo.should_not equal(OtherFoo::InnerFoo)
       DeeperFoo::InnerFoo.superclass.should equal(SomeFoo::InnerFoo)
     end
-    
+
     it "should allow additional inner classes to be declared without polluting the parent" do
       class ::OtherFoo < MyFoo
         inheritable_inner_classes :SomeDeepFoo
         class SomeDeepFoo; end
       end
-      
+
       class ::SomeFoo < MyFoo; end
       class ::DeeperFoo < ::OtherFoo; end
-      
+
       SomeFoo::InnerFoo.should inherit_from(MyFoo::InnerFoo)
       SomeFoo.const_defined?(:SomeDeepFoo).should be_false
-      
+
       DeeperFoo::InnerFoo.should inherit_from(OtherFoo::InnerFoo)
       DeeperFoo::SomeDeepFoo.should inherit_from(OtherFoo::SomeDeepFoo)
     end
 
   end # "inheritable inner classes"
-end
+end