cascading_classes 0.6.1 → 0.6.2

data/spec/basics/proc_spec.rb

@@ -36,58 +36,58 @@ describe "proc properties" do
   end
 
   it "inherits by default" do
-    @props[:weather][:inherit].must_equal true    # sanity
-    @props[:mood][:inherit].must_equal true
-    @props[:color][:inherit].must_equal true
+    @props[:weather][:inherit].should == true    # sanity
+    @props[:mood][:inherit].should == true
+    @props[:color][:inherit].should == true
   end
 
   describe "a property of type :Proc" do
     it "evaluates the proc on each invocation of the property" do
-      A.weather.must_equal :sunny
-      A.mood.must_equal "content"
-      A.color.must_equal "rosy"
+      A.weather.should == :sunny
+      A.mood.should == "content"
+      A.color.should == "rosy"
 
       A.weather = :rainy
-      A.mood.must_equal "depressed"
-      A.color.must_equal "blue"
+      A.mood.should == "depressed"
+      A.color.should == "blue"
     end
 
     it "has second parameter that is a list of parents" do
       A.mood = Proc.new{|me, parents| parents}
 
-      A.mood.must_equal []
-      B.mood.must_equal [A]
-      C.mood.must_equal [B, A]
+      A.mood.should == []
+      B.mood.should == [A]
+      C.mood.should == [B, A]
 
-      A.new.mood.must_equal [A]
-      B.new.mood.must_equal [B, A]
-      C.new.mood.must_equal [C, B, A]
+      A.new.mood.should == [A]
+      B.new.mood.should == [B, A]
+      C.new.mood.should == [C, B, A]
     end
 
     describe "blank descendents" do
       it "inherits from its nearest non-blank ancestor" do
-        B.mood_is_blank?.must_equal true
-        C.mood_is_blank?.must_equal true
+        B.mood_is_blank?.should == true
+        C.mood_is_blank?.should == true
 
         A.weather = :sunny
-        B.mood.must_equal "content"
-        C.mood.must_equal "content"
-        B.color.must_equal "rosy"
-        C.color.must_equal "rosy"
+        B.mood.should == "content"
+        C.mood.should == "content"
+        B.color.should == "rosy"
+        C.color.should == "rosy"
 
         A.weather = :rainy
 
-        B.mood.must_equal "depressed"
-        C.mood.must_equal "depressed"
-        B.color.must_equal "blue"
-        C.color.must_equal "blue"
+        B.mood.should == "depressed"
+        C.mood.should == "depressed"
+        B.color.should == "blue"
+        C.color.should == "blue"
       end
 
       it "uses its own proc if not blank" do
         B.mood = Proc.new{ "angry" }
 
-        B.mood.must_equal "angry"
-        B.color.must_equal "blue"
+        B.mood.should == "angry"
+        B.color.should == "blue"
       end
 
       describe "the parent redefines the proc property" do
@@ -99,9 +99,9 @@ describe "proc properties" do
           A.weather = :sunny
           B.weather = :rainy
           
-          A.color.must_equal "A: rosy"
-          B.color.must_equal "B: blue"
-          C.color.must_equal "C: blue"
+          A.color.should == "A: rosy"
+          B.color.should == "B: blue"
+          C.color.should == "C: blue"
         end
       end
 
@@ -115,46 +115,46 @@ describe "proc properties" do
           it "inherits the new proc by default" do
             A.weather = :sunny
 
-            A.mood.must_equal "content"
-            B.mood.must_equal "angry"
-            C.mood.must_equal "angry"
+            A.mood.should == "content"
+            B.mood.should == "angry"
+            C.mood.should == "angry"
 
-            A.color.must_equal "rosy"
-            B.color.must_equal "B: blue"
-            C.color.must_equal "C: blue"
+            A.color.should == "rosy"
+            B.color.should == "B: blue"
+            C.color.should == "C: blue"
           end
 
           describe "descendents can any inheritance, using the default instead" do
             it "accepts ':default' syntax" do
               A.weather = :sunny
 
-              A.mood.must_equal "content"
-              B.mood.must_equal "angry"
-              C.mood(:default).must_equal "content"
+              A.mood.should == "content"
+              B.mood.should == "angry"
+              C.mood(:default).should == "content"
             end
 
             it "accepts ':inherit => false' syntax" do
               A.weather = :sunny
 
-              A.mood.must_equal "content"
-              B.mood.must_equal "angry"
-              C.mood(:inherit => false).must_equal "content"
+              A.mood.should == "content"
+              B.mood.should == "angry"
+              C.mood(:inherit => false).should == "content"
 
-              A.color.must_equal "rosy"
-              B.color.must_equal "B: blue"
-              C.color(:inherit => false).must_equal "blue"  # ***** take note: C.mood = "depressed" *****
+              A.color.should == "rosy"
+              B.color.should == "B: blue"
+              C.color(:inherit => false).should == "blue"  # ***** take note: C.mood = "depressed" *****
             end
 
             it "accepts ':inherit, false' syntax" do
               A.weather = :sunny
 
-              A.mood.must_equal "content"
-              B.mood.must_equal "angry"
-              C.mood(:inherit, false).must_equal "content"
+              A.mood.should == "content"
+              B.mood.should == "angry"
+              C.mood(:inherit, false).should == "content"
 
-              A.color.must_equal "rosy"
-              B.color.must_equal "B: blue"
-              C.color(:inherit, false).must_equal "blue"
+              A.color.should == "rosy"
+              B.color.should == "B: blue"
+              C.color(:inherit, false).should == "blue"
             end
           end
         end
@@ -174,27 +174,27 @@ describe "proc properties" do
     end
 
     it "does not inherit" do
-      @props[:weather][:inherit].must_equal true  # sanity
-      @props[:mood][:inherit].must_equal false
-      @props[:color][:inherit].must_equal false
+      @props[:weather][:inherit].should == true  # sanity
+      @props[:mood][:inherit].should == false
+      @props[:color][:inherit].should == false
     end
 
     describe "descendents" do
       it "propogates the initial proc value, but not any descendents' proc" do
-        B.color_is_blank?.must_equal true
-        C.mood_is_blank?.must_equal true
+        B.color_is_blank?.should == true
+        C.mood_is_blank?.should == true
 
-        A.weather.must_equal :sunny    # sanity
-        B.weather.must_equal :sunny    # sanity
-        C.weather.must_equal :sunny
+        A.weather.should == :sunny    # sanity
+        B.weather.should == :sunny    # sanity
+        C.weather.should == :sunny
 
-        A.mood.must_equal "content"    # sanity
-        B.mood.must_equal "angry"      # sanity
-        C.mood.must_equal "content"
+        A.mood.should == "content"    # sanity
+        B.mood.should == "angry"      # sanity
+        C.mood.should == "content"
 
-        A.color.must_equal "A: rosy"    # sanity
-        B.color.must_equal "B: blue"    # sanity
-        C.color.must_equal "C: rosy"
+        A.color.should == "A: rosy"    # sanity
+        B.color.should == "B: blue"    # sanity
+        C.color.should == "C: rosy"
       end
     end
   end
@@ -208,16 +208,16 @@ describe "proc properties" do
     end
 
     it "inherits the property" do
-      @props[:ingredients][:inherit].must_equal true
-      @props[:sweet_tooth][:inherit].must_equal true
+      @props[:ingredients][:inherit].should == true
+      @props[:sweet_tooth][:inherit].should == true
 
-      A.ingredients.must_equal Set.new([:sugar, :butter, :flour, :eggs])
-      B.ingredients.must_equal Set.new([:sugar, :butter, :flour, :eggs])
-      C.ingredients.must_equal Set.new([:sugar, :butter, :flour, :eggs])
+      A.ingredients.should == Set.new([:sugar, :butter, :flour, :eggs])
+      B.ingredients.should == Set.new([:sugar, :butter, :flour, :eggs])
+      C.ingredients.should == Set.new([:sugar, :butter, :flour, :eggs])
 
-      A.sweet_tooth.must_equal false
-      B.sweet_tooth.must_equal false
-      C.sweet_tooth.must_equal false
+      A.sweet_tooth.should == false
+      B.sweet_tooth.should == false
+      C.sweet_tooth.should == false
     end
 
     describe "a descendent redefines the property with a proc" do
@@ -244,18 +244,18 @@ describe "proc properties" do
         C.diabetic = true
         D.diabetic = false
 
-        B.diabetic.must_equal false
-        C.diabetic.must_equal true
-        D.diabetic.must_equal false
+        B.diabetic.should == false
+        C.diabetic.should == true
+        D.diabetic.should == false
 
-        B.ingredients.must_equal Set.new([:sugar, :butter, :flour, :eggs])
-        C.ingredients.must_equal Set.new([:splenda, :butter, :flour, :eggs])
-        D.ingredients.must_equal Set.new([:sugar, :butter, :flour, :eggs])
+        B.ingredients.should == Set.new([:sugar, :butter, :flour, :eggs])
+        C.ingredients.should == Set.new([:splenda, :butter, :flour, :eggs])
+        D.ingredients.should == Set.new([:sugar, :butter, :flour, :eggs])
 
-        A.sweet_tooth.must_equal false
-        B.sweet_tooth.must_equal true
-        C.sweet_tooth.must_equal false
-        D.sweet_tooth.must_equal true
+        A.sweet_tooth.should == false
+        B.sweet_tooth.should == true
+        C.sweet_tooth.should == false
+        D.sweet_tooth.should == true
       end
 
       describe "descendents redefine the property, but not to a proc" do
@@ -265,11 +265,11 @@ describe "proc properties" do
         end
 
         it "descendents reflect the new 'static' settings" do
-          C.ingredients.must_equal Set.new([:equal, :butter, :flour, :eggs])
-          D.ingredients.must_equal Set.new([:equal, :butter, :flour, :eggs])
+          C.ingredients.should == Set.new([:equal, :butter, :flour, :eggs])
+          D.ingredients.should == Set.new([:equal, :butter, :flour, :eggs])
 
-          C.sweet_tooth.must_equal false
-          D.sweet_tooth.must_equal false
+          C.sweet_tooth.should == false
+          D.sweet_tooth.should == false
         end
       end
     end
@@ -285,19 +285,19 @@ describe "proc properties" do
         "green"
       }
 
-      B.color.must_equal("green")
-      who_am_i.must_equal(B)
-      which_parents.must_equal([A])
+      B.color.should ==("green")
+      who_am_i.should ==(B)
+      which_parents.should ==([A])
     end
 
     it "evaluates to the property value" do
       B.color = Proc.new{ "green" }
-      B.color.must_equal "green"
+      B.color.should == "green"
 
       C.color = Proc.new{|me, parents|
         "#{me} #{parents.first.color.capitalize}"
       }
-      C.color.must_equal "C Green"
+      C.color.should == "C Green"
     end
   end
 end
@@ -333,9 +333,9 @@ describe "examples" do
     end
 
     it "works" do
-      A.merged_opts.must_equal({:color => "black", :music => ["Rolling Stones"]})
-      B.merged_opts.must_equal({:color => "black", :music => ["Arcade Fire"]})
-      C.merged_opts.must_equal({:color => "blond", :music => ["Arcade Fire"]})
+      A.merged_opts.should ==({:color => "black", :music => ["Rolling Stones"]})
+      B.merged_opts.should ==({:color => "black", :music => ["Arcade Fire"]})
+      C.merged_opts.should ==({:color => "blond", :music => ["Arcade Fire"]})
     end
   end
 end

data/spec/class_helper_methods/parents_for_spec.rb

@@ -26,11 +26,11 @@ describe "parents_for()" do
   end
 
   it "lists ancestors for given property" do
-    A.parents_for(:color).must_equal []
-    B.parents_for(:color).must_equal [A]
-    C.parents_for(:color).must_equal [B, A]
+    A.parents_for(:color).should == []
+    B.parents_for(:color).should == [A]
+    C.parents_for(:color).should == [B, A]
 
-    B.parents_for(:score).must_equal []
-    C.parents_for(:score).must_equal [B]
+    B.parents_for(:score).should == []
+    C.parents_for(:score).should == [B]
   end
 end

data/spec/custom_classes/hash_like_spec.rb

@@ -33,34 +33,34 @@ describe "custom hash-like class" do
 
   describe "by default" do
     it "is set to not inherit by default" do
-      @props[:beta][:inherit].must_equal false
+      @props[:beta][:inherit].should == false
     end
 
     it "descendents (including instances) do not inherit" do
-      Parent.new.beta.must_equal MyCustom.new
-      Child.beta.must_equal MyCustom.new
-      Child.new.beta.must_equal MyCustom.new
-      GrandChild.beta.must_equal MyCustom.new
-      GrandChild.new.beta.must_equal MyCustom.new
+      Parent.new.beta.should == MyCustom.new
+      Child.beta.should == MyCustom.new
+      Child.new.beta.should == MyCustom.new
+      GrandChild.beta.should == MyCustom.new
+      GrandChild.new.beta.should == MyCustom.new
     end
 
     it "'Parent' has 'default' value" do
-      Parent.beta.must_equal MyCustom.new(:rank, 4, :color, "red")
+      Parent.beta.should == MyCustom.new(:rank, 4, :color, "red")
     end
 
     it "has type ':MyCustom'" do
-      @props[:beta][:type].must_equal :MyCustom
+      @props[:beta][:type].should == :MyCustom
     end
 
     it "has blank value of empty 'MyCustom' object" do
       mc = MyCustom.new
-      mc.empty?.must_equal true
+      mc.empty?.should == true
 
-      @props[:beta][:blank].call(mc).must_equal true
+      @props[:beta][:blank].call(mc).should == true
     end
 
     it "has new value of empty 'MyCustom' object" do
-      @props[:beta][:new].call.must_equal MyCustom.new
+      @props[:beta][:new].call.should == MyCustom.new
     end
 
     it "nonblank values never inherit" do

data/spec/helper_spec.rb

@@ -7,33 +7,33 @@ require 'minitest/autorun'
 ## end
 
 def blank_inherit_helper(obj, property, expected_depth, expected_val, empty)
-  obj.send("#{property}_is_blank?").must_equal true
+  obj.send("#{property}_is_blank?").should be_true
 
   dont_inherit = (expected_depth < 0) ? [0] : (0...expected_depth).to_a
   dont_inherit << false << nil
   dont_inherit.each do |i|
-    obj.send(property, i).must_equal empty
-    obj.send(property, :inherit => i).must_equal empty
-    obj.send(property, :inherit, i).must_equal empty
+    obj.send(property, i).should == empty
+    obj.send(property, :inherit => i).should == empty
+    obj.send(property, :inherit, i).should == empty
   end
   
   do_inherit = (expected_depth < 0) ? [] : (expected_depth..(expected_depth+1)).to_a
   do_inherit << true << -1
   do_inherit.each do |i|
-    obj.send(property, i).must_equal(expected_val)
-    obj.send(property, :inherit => i).must_equal(expected_val)
-    obj.send(property, :inherit, i).must_equal(expected_val)
+    obj.send(property, i).should eq(expected_val)
+    obj.send(property, :inherit => i).should eq(expected_val)
+    obj.send(property, :inherit, i).should eq(expected_val)
   end
 end
 
 def nonblank_helper(obj, property, expected)
-  obj.send("#{property}_is_blank?").must_equal false
+  obj.send("#{property}_is_blank?").should be_false
 
   vals = [0, 1, 2, 3, -1, false, true, nil]
   vals.each do |i|
-    obj.send(property, i).must_equal expected
-    obj.send(property, :inherit => i).must_equal expected
-    obj.send(property, :inherit, i).must_equal expected
+    obj.send(property, i).should == expected
+    obj.send(property, :inherit => i).should == expected
+    obj.send(property, :inherit, i).should == expected
   end
 end
 

data/spec/instances/basics.rb

@@ -9,71 +9,71 @@ end
 # defaults: hash of defaults
 def getters(obj, defaults)
   defaults.each do |key, val|
-    obj.send(key).must_equal val
+    obj.send(key).should == val
   end
 end
 
 def container_getters(obj, depth)
-  obj.urls(false).must_equal Array.new
-  obj.urls(nil).must_equal Array.new
+  obj.urls(false).should == Array.new
+  obj.urls(nil).should == Array.new
   0.upto(depth-1).each do |i|
-    obj.urls(i).must_equal Array.new
+    obj.urls(i).should == Array.new
   end
   depth.upto(depth+1).each do |i|
-    obj.urls(i).must_equal ["www.google.com"]
+    obj.urls(i).should == ["www.google.com"]
   end
-  obj.urls(-1).must_equal ["www.google.com"]
-  obj.urls(true).must_equal ["www.google.com"]
+  obj.urls(-1).should == ["www.google.com"]
+  obj.urls(true).should == ["www.google.com"]
 
-  obj.name(false).must_equal Hash.new
-  obj.name(nil).must_equal Hash.new
+  obj.name(false).should == Hash.new
+  obj.name(nil).should == Hash.new
   0.upto(depth-1).each do |i|
-    obj.name(i).must_equal Hash.new
+    obj.name(i).should == Hash.new
   end
   depth.upto(depth+1).each do |i|
-    obj.name(i).must_equal({:first => 'jon', :last => 'smith'})
+    obj.name(i).should ==({:first => 'jon', :last => 'smith'})
   end
-  obj.name(true).must_equal({:first => 'jon', :last => 'smith'})
-  obj.name(-1).must_equal({:first => 'jon', :last => 'smith'})
+  obj.name(true).should ==({:first => 'jon', :last => 'smith'})
+  obj.name(-1).should ==({:first => 'jon', :last => 'smith'})
 end
 
 def setters(obj)
   obj.color = "blue"
-  obj.color.must_equal "blue"
+  obj.color.should == "blue"
 
   obj.setting = :rural
-  obj.setting.must_equal :rural
+  obj.setting.should == :rural
 
   obj.score = 28.1
-  obj.score.must_equal 28.1
+  obj.score.should == 28.1
 
   obj.num = 15
-  obj.num.must_equal 15
+  obj.num.should == 15
 
   obj.available = false
-  obj.available.must_equal false
+  obj.available.should == false
 
   obj.urls << "www.yahoo.com" << "www.bing.com"
-  obj.urls.must_equal ["www.yahoo.com", "www.bing.com"]
+  obj.urls.should == ["www.yahoo.com", "www.bing.com"]
 
   obj.urls = ["www.nytimes.com"]
-  obj.urls.must_equal ["www.nytimes.com"]
+  obj.urls.should == ["www.nytimes.com"]
 
-  obj.verify.must_equal false   # doesn't inherit name
-  obj.verify2.must_equal true   # inherits name
+  obj.verify.should == false   # doesn't inherit name
+  obj.verify2.should == true   # inherits name
 
   obj.name[:first] = 'thomas'
   obj.name[:last] = 'smith'
-  obj.name.must_equal({:first => 'thomas', :last => 'smith'})
+  obj.name.should ==({:first => 'thomas', :last => 'smith'})
 
-  obj.verify.must_equal true
-  obj.verify2.must_equal true
+  obj.verify.should == true
+  obj.verify2.should == true
 
   obj.verify = Proc.new{|me| me.name[:first] !~ /mas/}
   obj.verify2 = Proc.new{|me| me.name(true)[:first] !~ /mas/}
 
-  obj.verify.must_equal false
-  obj.verify2.must_equal false
+  obj.verify.should == false
+  obj.verify2.should == false
 end
 
 describe "instances: via 'extend'" do
@@ -107,8 +107,8 @@ describe "instances: via 'extend'" do
       a = A.new
       [:color, :setting, :score, :num, :available,
        :urls, :name, :verify].each do |t|
-        @props[t][:instances_too].must_equal false
-        a.respond_to?(:t).must_equal false
+        @props[t][:instances_too].should == false
+        a.respond_to?(:t).should == false
       end
     end
   end
@@ -132,17 +132,17 @@ describe "instances: via 'extend'" do
       a = A.new
       [:color, :setting, :score, :num, :available,
        :urls, :name, :verify, :verify2].each do |t|
-        @props[t][:instances_too].must_equal true
-        a.respond_to?(t).must_equal true
+        @props[t][:instances_too].should == true
+        a.respond_to?(t).should == true
       end
     end
 
     it "inherits all non-container properties" do
       [:color, :setting, :score, :num, :available, :verify, :verify2].each do |t|
-        @props[t][:inherit].must_equal true
+        @props[t][:inherit].should == true
       end
-      @props[:urls][:inherit].must_equal false
-      @props[:name][:inherit].must_equal false
+      @props[:urls][:inherit].should == false
+      @props[:name][:inherit].should == false
 
       defaults = A.to_hash  # assumes 'to_hash' works; ie: likely testing it too
       [:urls, :name, :verify, :verify2].each{|j| defaults.delete j}
@@ -201,17 +201,17 @@ describe "instances: via 'include'" do
       a = A.new
       [:color, :setting, :score, :num, :available,
        :urls, :name, :verify, :verify2].each do |t|
-        @props[t][:instances_too].must_equal true
-        a.respond_to?(t).must_equal true
+        @props[t][:instances_too].should == true
+        a.respond_to?(t).should == true
       end
     end
 
     it "inherits all non-container properties" do
       [:color, :setting, :score, :num, :available, :verify, :verify2].each do |t|
-        @props[t][:inherit].must_equal true
+        @props[t][:inherit].should == true
       end
-      @props[:urls][:inherit].must_equal false
-      @props[:name][:inherit].must_equal false
+      @props[:urls][:inherit].should == false
+      @props[:name][:inherit].should == false
 
       defaults = A.to_hash  # assumes 'to_hash' works; ie: likely testing it too
       [:urls, :name, :verify, :verify2].each{|j| defaults.delete j}