cascading_classes 0.6.1 → 0.6.2

data/spec/preset_classes/array_spec.rb

@@ -27,50 +27,50 @@ describe "array syntax" do
 
       props = Parent.singleton_class.properties
 
-      props[:colors_a][:type].must_equal :Array
-      props[:colors_b][:type].must_equal :Array
-      props[:colors_c][:type].must_equal :undefined_type
-      Parent.colors_a.must_equal [:red, :blue, :yellow]
-      Parent.colors_b.must_equal []
-      Parent.colors_c.must_equal nil
+      props[:colors_a][:type].should == :Array
+      props[:colors_b][:type].should == :Array
+      props[:colors_c][:type].should == :undefined_type
+      Parent.colors_a.should == [:red, :blue, :yellow]
+      Parent.colors_b.should == []
+      Parent.colors_c.should == nil
 
       Parent.colors_b << :red << :blue << :yellow
       Parent.colors_c = [:red, :blue, :yellow]
 
-      props[:colors_c][:type].must_equal :Array
-      Parent.colors_b.must_equal [:red, :blue, :yellow]
-      Parent.colors_c.must_equal [:red, :blue, :yellow]
+      props[:colors_c][:type].should == :Array
+      Parent.colors_b.should == [:red, :blue, :yellow]
+      Parent.colors_c.should == [:red, :blue, :yellow]
 
       Parent.cascade [:colors_d, [:red, :blue, :yellow]], :colors_e
       Parent.cascade [:colors_f, [:red, :blue, :yellow]]
       Parent.cascade :colors_g
 
-      props[:colors_d][:type].must_equal :Array
-      props[:colors_e][:type].must_equal :undefined_type
-      props[:colors_f][:type].must_equal :Array
-      props[:colors_g][:type].must_equal :undefined_type
-      Parent.colors_d.must_equal [:red, :blue, :yellow]
-      Parent.colors_e.must_equal nil
-      Parent.colors_f.must_equal [:red, :blue, :yellow]
-      Parent.colors_g.must_equal nil
+      props[:colors_d][:type].should == :Array
+      props[:colors_e][:type].should == :undefined_type
+      props[:colors_f][:type].should == :Array
+      props[:colors_g][:type].should == :undefined_type
+      Parent.colors_d.should == [:red, :blue, :yellow]
+      Parent.colors_e.should == nil
+      Parent.colors_f.should == [:red, :blue, :yellow]
+      Parent.colors_g.should == nil
 
       Parent.colors_e = [:red, :blue, :yellow]
       Parent.colors_g = [:red, :blue, :yellow]
 
-      props[:colors_e][:type].must_equal :Array
-      props[:colors_g][:type].must_equal :Array
-      Parent.colors_e.must_equal [:red, :blue, :yellow]
-      Parent.colors_g.must_equal [:red, :blue, :yellow]
+      props[:colors_e][:type].should == :Array
+      props[:colors_g][:type].should == :Array
+      Parent.colors_e.should == [:red, :blue, :yellow]
+      Parent.colors_g.should == [:red, :blue, :yellow]
     end
 
     it "is all the same" do
-      Parent.colors_a.must_equal [:red, :blue, :yellow]
-      Parent.colors_b.must_equal [:red, :blue, :yellow]
-      Parent.colors_c.must_equal [:red, :blue, :yellow]
-      Parent.colors_d.must_equal [:red, :blue, :yellow]
-      Parent.colors_e.must_equal [:red, :blue, :yellow]
-      Parent.colors_f.must_equal [:red, :blue, :yellow]
-      Parent.colors_g.must_equal [:red, :blue, :yellow]
+      Parent.colors_a.should == [:red, :blue, :yellow]
+      Parent.colors_b.should == [:red, :blue, :yellow]
+      Parent.colors_c.should == [:red, :blue, :yellow]
+      Parent.colors_d.should == [:red, :blue, :yellow]
+      Parent.colors_e.should == [:red, :blue, :yellow]
+      Parent.colors_f.should == [:red, :blue, :yellow]
+      Parent.colors_g.should == [:red, :blue, :yellow]
     end
   end
 end
@@ -94,32 +94,32 @@ describe "array syntax" do
 
   describe "by default" do
     it "is set to not 'inherit' by default" do
-      @props[:fruit][:inherit].must_equal(false)
-      Child.fruit.must_equal []
+      @props[:fruit][:inherit].should ==(false)
+      Child.fruit.should == []
     end
 
     it "descendents (including instances) do not inherit" do
-      Parent.new.fruit.must_equal []
-      Child.fruit.must_equal []
-      Child.new.fruit.must_equal []
-      GrandChild.fruit.must_equal []
-      GrandChild.new.fruit.must_equal []
+      Parent.new.fruit.should == []
+      Child.fruit.should == []
+      Child.new.fruit.should == []
+      GrandChild.fruit.should == []
+      GrandChild.new.fruit.should == []
     end
 
     it "'Parent' has default value" do
-      Parent.fruit.must_equal [:orange, :apple, :pear]
+      Parent.fruit.should == [:orange, :apple, :pear]
     end
 
     it "has type ':Array'" do
-      @props[:fruit][:type].must_equal :Array
+      @props[:fruit][:type].should == :Array
     end
 
     it "has blank value of empty array" do
-      @props[:fruit][:blank].call([]).must_equal true
+      @props[:fruit][:blank].call([]).should == true
     end
 
     it "has new value of empty array" do
-      @props[:fruit][:new].call.must_equal []
+      @props[:fruit][:new].call.should == []
     end
 
     it "nonblank values never inherit" do

data/spec/preset_classes/hash_spec.rb

@@ -29,46 +29,46 @@ describe "hash syntax" do
 
       props = Parent.singleton_class.properties
 
-      props[:person_a][:type].must_equal :Hash
-      props[:person_b][:type].must_equal :Hash
-      props[:person_c][:type].must_equal :undefined_type
-      Parent.person_a.must_equal({:name => ['williamson', 'charles']})
-      Parent.person_b.must_equal({})
-      Parent.person_c.must_equal nil
+      props[:person_a][:type].should == :Hash
+      props[:person_b][:type].should == :Hash
+      props[:person_c][:type].should == :undefined_type
+      Parent.person_a.should ==({:name => ['williamson', 'charles']})
+      Parent.person_b.should ==({})
+      Parent.person_c.should == nil
 
       Parent.person_b[:name] = ['williamson', 'charles']
       Parent.person_c = {:name => ['williamson', 'charles']}
-      props[:person_c][:type].must_equal :Hash
-      Parent.person_b.must_equal({:name => ['williamson', 'charles']})
-      Parent.person_c.must_equal({:name => ['williamson', 'charles']})
+      props[:person_c][:type].should == :Hash
+      Parent.person_b.should ==({:name => ['williamson', 'charles']})
+      Parent.person_c.should ==({:name => ['williamson', 'charles']})
 
       Parent.cascade [:person_d, {:name => ['williamson', 'charles']}], :person_e
       Parent.cascade [:person_f, {:name => ['williamson', 'charles']}]
       Parent.cascade :person_g
-      props[:person_d][:type].must_equal :Hash
-      props[:person_e][:type].must_equal :undefined_type
-      props[:person_f][:type].must_equal :Hash
-      props[:person_g][:type].must_equal :undefined_type
-      Parent.person_d.must_equal({:name => ['williamson', 'charles']})
-      Parent.person_e.must_equal nil
-      Parent.person_f.must_equal({:name => ['williamson', 'charles']})
-      Parent.person_g.must_equal nil
+      props[:person_d][:type].should == :Hash
+      props[:person_e][:type].should == :undefined_type
+      props[:person_f][:type].should == :Hash
+      props[:person_g][:type].should == :undefined_type
+      Parent.person_d.should ==({:name => ['williamson', 'charles']})
+      Parent.person_e.should == nil
+      Parent.person_f.should ==({:name => ['williamson', 'charles']})
+      Parent.person_g.should == nil
 
       Parent.person_e = Parent.person_g = {:name => ['williamson', 'charles']}
-      props[:person_e][:type].must_equal :Hash
-      props[:person_g][:type].must_equal :Hash
-      Parent.person_e.must_equal({:name => ['williamson', 'charles']})
-      Parent.person_g.must_equal({:name => ['williamson', 'charles']})
+      props[:person_e][:type].should == :Hash
+      props[:person_g][:type].should == :Hash
+      Parent.person_e.should ==({:name => ['williamson', 'charles']})
+      Parent.person_g.should ==({:name => ['williamson', 'charles']})
     end
 
     it 'is all the same' do
-      Parent.person_a.must_equal({:name => ['williamson', 'charles']})
-      Parent.person_b.must_equal({:name => ['williamson', 'charles']})
-      Parent.person_c.must_equal({:name => ['williamson', 'charles']})
-      Parent.person_d.must_equal({:name => ['williamson', 'charles']})
-      Parent.person_e.must_equal({:name => ['williamson', 'charles']})
-      Parent.person_f.must_equal({:name => ['williamson', 'charles']})
-      Parent.person_g.must_equal({:name => ['williamson', 'charles']})
+      Parent.person_a.should ==({:name => ['williamson', 'charles']})
+      Parent.person_b.should ==({:name => ['williamson', 'charles']})
+      Parent.person_c.should ==({:name => ['williamson', 'charles']})
+      Parent.person_d.should ==({:name => ['williamson', 'charles']})
+      Parent.person_e.should ==({:name => ['williamson', 'charles']})
+      Parent.person_f.should ==({:name => ['williamson', 'charles']})
+      Parent.person_g.should ==({:name => ['williamson', 'charles']})
     end
   end
 end
@@ -92,31 +92,31 @@ describe "hash usage" do
 
   describe "by default" do
     it "is set to not 'inherit' by default" do
-      @props[:eyes][:inherit].must_equal false
+      @props[:eyes][:inherit].should == false
     end
 
     it "descendents (including instances) do not inherit" do
-      Parent.new.eyes.must_equal({})
-      Child.eyes.must_equal({})
-      Child.new.eyes.must_equal({})
-      GrandChild.eyes.must_equal({})
-      GrandChild.new.eyes.must_equal({})
+      Parent.new.eyes.should ==({})
+      Child.eyes.should ==({})
+      Child.new.eyes.should ==({})
+      GrandChild.eyes.should ==({})
+      GrandChild.new.eyes.should ==({})
     end
 
     it "'Parent' has 'default' value" do
-      Parent.eyes.must_equal({:color => "red"})
+      Parent.eyes.should ==({:color => "red"})
     end
 
     it "has type ':Hash'" do
-      @props[:eyes][:type].must_equal :Hash
+      @props[:eyes][:type].should == :Hash
     end
 
     it "has blank value of empty hash" do
-      @props[:eyes][:blank].call({}).must_equal true
+      @props[:eyes][:blank].call({}).should == true
     end
 
     it "has new value of empty hash" do
-      @props[:eyes][:new].call.must_equal({})
+      @props[:eyes][:new].call.should ==({})
     end
 
     it "nonblank values never inherit" do

data/spec/preset_classes/strings.rb

@@ -27,46 +27,46 @@ describe "string - base" do
 
       props = Parent.singleton_class.properties
 
-      props[:color_a][:type].must_equal :String
-      props[:color_b][:type].must_equal :String
-      props[:color_c][:type].must_equal :Object
-      Parent.color_a.must_equal "white"
-      Parent.color_b.must_equal ''
-      Parent.color_c.must_equal nil
+      props[:color_a][:type].should == :String
+      props[:color_b][:type].should == :String
+      props[:color_c][:type].should == :Object
+      Parent.color_a.should == "white"
+      Parent.color_b.should == ''
+      Parent.color_c.should == nil
 
       Parent.color_b = "white"
       Parent.color_c = "white"
-      props[:color_c][:type].must_equal :String
-      Parent.color_b.must_equal "white"
-      Parent.color_c.must_equal "white"
+      props[:color_c][:type].should == :String
+      Parent.color_b.should == "white"
+      Parent.color_c.should == "white"
 
       Parent.cascade [:color_d, "white"], :color_e
       Parent.cascade [:color_f, "white"]
       Parent.cascade :color_g  
-      props[:color_d][:type].must_equal :String
-      props[:color_e][:type].must_equal :Object
-      props[:color_f][:type].must_equal :String
-      props[:color_g][:type].must_equal :Object
-      Parent.color_d.must_equal "white"
-      Parent.color_e.must_equal nil
-      Parent.color_f.must_equal "white"
-      Parent.color_g.must_equal nil
+      props[:color_d][:type].should == :String
+      props[:color_e][:type].should == :Object
+      props[:color_f][:type].should == :String
+      props[:color_g][:type].should == :Object
+      Parent.color_d.should == "white"
+      Parent.color_e.should == nil
+      Parent.color_f.should == "white"
+      Parent.color_g.should == nil
 
       Parent.color_e = Parent.color_g = "white"
-      props[:color_e][:type].must_equal :String
-      props[:color_g][:type].must_equal :String
-      Parent.color_e.must_equal "white"
-      Parent.color_g.must_equal "white"
+      props[:color_e][:type].should == :String
+      props[:color_g][:type].should == :String
+      Parent.color_e.should == "white"
+      Parent.color_g.should == "white"
     end
 
     it "is all the same" do
-      Parent.color_a.must_equal "white"
-      Parent.color_b.must_equal "white"
-      Parent.color_c.must_equal "white"
-      Parent.color_d.must_equal "white"
-      Parent.color_e.must_equal "white"
-      Parent.color_f.must_equal "white"
-      Parent.color_g.must_equal "white"
+      Parent.color_a.should == "white"
+      Parent.color_b.should == "white"
+      Parent.color_c.should == "white"
+      Parent.color_d.should == "white"
+      Parent.color_e.should == "white"
+      Parent.color_f.should == "white"
+      Parent.color_g.should == "white"
     end
   end
 end
@@ -90,19 +90,19 @@ describe "string" do
 
   describe "by default" do
     it "has type :String" do
-      @props[:color][:type].must_equal :String
+      @props[:color][:type].should == :String
     end
 
     it "inherits by default" do
-      @props[:color][:inherit].must_equal true
+      @props[:color][:inherit].should == true
     end
 
     it "has blank value of empty string" do
-      @props[:color][:blank].call('').must_equal true
+      @props[:color][:blank].call('').should == true
     end
 
     it "has new value of empty string" do
-      @props[:color][:new].call.must_equal ''
+      @props[:color][:new].call.should == ''
     end
   end
 
@@ -142,29 +142,29 @@ describe "string" do
     end
 
     it "has blank value of nil and new value of empty string" do
-      @props[:city][:blank].call('').must_equal false
-      @props[:city][:blank].call(nil).must_equal true
+      @props[:city][:blank].call('').should == false
+      @props[:city][:blank].call(nil).should == true
 
       new_val = @props[:city][:new].call
 
-      Parent.city.must_equal "new york"
-      Parent.city_is_blank?.must_equal false
-      Child.city.must_equal new_val
-      Child.city_is_blank?.must_equal false
-      GrandChild.city.must_equal new_val
-      GrandChild.city_is_blank?.must_equal false
+      Parent.city.should == "new york"
+      Parent.city_is_blank?.should == false
+      Child.city.should == new_val
+      Child.city_is_blank?.should == false
+      GrandChild.city.should == new_val
+      GrandChild.city_is_blank?.should == false
 
       GrandChild.city = nil
-      GrandChild.city_is_blank?.must_equal true
-      GrandChild.city.must_equal Child.city
+      GrandChild.city_is_blank?.should == true
+      GrandChild.city.should == Child.city
       
       Child.city = nil
-      Child.city_is_blank?.must_equal true
-      Child.city.must_equal Parent.city
+      Child.city_is_blank?.should == true
+      Child.city.should == Parent.city
       
       Parent.city = nil
-      Parent.city.must_equal nil
-      Parent.city_is_blank?.must_equal true
+      Parent.city.should == nil
+      Parent.city_is_blank?.should == true
     end
   end
 
@@ -176,15 +176,15 @@ describe "string" do
     end
 
     it "has blank value of nil and new value of nil" do
-      @props[:state][:blank].call('').must_equal false
-      @props[:state][:blank].call(nil).must_equal true
-      @props[:state][:new].call.must_equal nil
+      @props[:state][:blank].call('').should == false
+      @props[:state][:blank].call(nil).should == true
+      @props[:state][:new].call.should == nil
 
-      Child.state_is_blank?.must_equal true
-      GrandChild.state_is_blank?.must_equal true
+      Child.state_is_blank?.should == true
+      GrandChild.state_is_blank?.should == true
 
-      Child.state(false).must_equal nil
-      GrandChild.state(false).must_equal nil
+      Child.state(false).should == nil
+      GrandChild.state(false).should == nil
     end
   end
 end

data/spec/preset_classes/undefined.rb

@@ -34,22 +34,22 @@ describe "null syntax" do
     it "has ':Object' type" do
       [:string, :int, :float, :sym, :bool, :hash, :array, :set].each do |type|
         name = "future_#{type}".to_sym
-        @props[name][:type].must_equal :Object
+        @props[name][:type].should == :Object
       end
     end
 
     it "is nil for parent class" do
       [:string, :int, :float, :sym, :bool, :hash, :array, :set].each do |type|
         name = "future_#{type}".to_sym
-        Parent.send(name).must_equal nil
+        Parent.send(name).should == nil
       end
     end
 
     it "is nil for subclasses" do
       [:string, :int, :float, :sym, :bool, :hash, :array, :set].each do |type|
         name = "future_#{type}".to_sym
-        Child.send(name).must_equal nil
-        GrandChild.send(name).must_equal nil
+        Child.send(name).should == nil
+        GrandChild.send(name).should == nil
       end
     end
   end

data/spec/usage/block_spec.rb

@@ -21,17 +21,17 @@ describe "options" do
 
     it "has a global default" do
       CC.block_inst_exec = true
-      CC.block_inst_exec?.must_equal true
+      CC.block_inst_exec?.should == true
 
       CC.block_inst_exec = false
-      CC.block_inst_exec?.must_equal false
+      CC.block_inst_exec?.should == false
     end
     
     it "defaults to global setting" do
       props = A.cascade do
         color
       end
-      props[:color][:block_inst_exec].must_equal(CC.block_inst_exec?)
+      props[:color][:block_inst_exec].should ==(CC.block_inst_exec?)
     end
 
     it "can be set in the 'cascade' block, overruling the global default" do
@@ -39,7 +39,7 @@ describe "options" do
       props = A.cascade do
         color :block_inst_exec => false
       end
-      props[:color][:block_inst_exec].must_equal false
+      props[:color][:block_inst_exec].should == false
     end
 
     it "can be set in 'opts' hash of property method, overruling others" do
@@ -52,8 +52,8 @@ describe "options" do
       who_is_self_1 = A.color(:inherit, 0){|me, parents| self}
       who_is_self_2 = A.color(:inherit, 0, {:block_inst_exec => true}){|me, parents| self}
       
-      who_is_self_1.must_equal who_am_i
-      who_is_self_2.must_equal A
+      who_is_self_1.should == who_am_i
+      who_is_self_2.should == A
     end
   end
 end