cascading_classes 0.3.0 → 0.6.0

data/spec/preset_classes/array_spec.rb

@@ -0,0 +1,214 @@
+begin
+  require_relative '../helper_spec'
+rescue NameError
+  require File.expand_path('../helper_spec', __FILE__)
+end
+
+describe "array syntax" do
+  before do
+    Parent = Class.new{extend CC}
+    Child = Class.new(Parent)
+    GrandChild = Class.new(Child)
+  end
+
+  after do
+    Object.send :remove_const, :Parent
+    Object.send :remove_const, :Child
+    Object.send :remove_const, :GrandChild
+  end
+
+  describe "equivalent syntax" do
+    before do
+      Parent.cascade do
+        colors_a :default => [:red, :blue, :yellow]
+        colors_b :array => true
+        colors_c
+      end
+
+      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
+
+      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]
+
+      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
+
+      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]
+    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]
+    end
+  end
+end
+
+describe "array syntax" do
+  before do
+    Parent = Class.new{include CC}
+    Child = Class.new(Parent)
+    GrandChild = Class.new(Child)
+
+    @props = Parent.cascade do
+      fruit :default => [:orange, :apple, :pear]
+    end
+  end
+
+  after do
+    Object.send :remove_const, :Parent
+    Object.send :remove_const, :Child
+    Object.send :remove_const, :GrandChild
+  end
+
+  describe "by default" do
+    it "is set to not 'inherit' by default" do
+      @props[:fruit][:inherit].must_equal(false)
+      Child.fruit.must_equal []
+    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 []
+    end
+
+    it "'Parent' has default value" do
+      Parent.fruit.must_equal [:orange, :apple, :pear]
+    end
+
+    it "has type ':Array'" do
+      @props[:fruit][:type].must_equal :Array
+    end
+
+    it "has blank value of empty array" do
+      @props[:fruit][:blank].call([]).must_equal true
+    end
+
+    it "has new value of empty array" do
+      @props[:fruit][:new].call.must_equal []
+    end
+
+    it "nonblank values never inherit" do
+      nonblank_helper(Parent, :fruit, [:orange, :apple, :pear])      
+
+      parent = Parent.new
+      parent.fruit = [:mango, :pineapple]
+      nonblank_helper(parent, :fruit, [:mango, :pineapple])
+
+      Child.fruit = ["summer", "rain"]
+      nonblank_helper(Child, :fruit, ["summer", "rain"])
+
+      child = Child.new
+      child.fruit = [:lemons, :limes]
+      nonblank_helper(child, :fruit, [:lemons, :limes])
+
+      GrandChild.fruit = [:watermelon, :orange]
+      nonblank_helper(GrandChild, :fruit, [:watermelon, :orange])
+
+      grandchild = GrandChild.new
+      grandchild.fruit = [{:time => false, :color => "blue"}]
+      nonblank_helper(grandchild, :fruit, [{:time => false, :color => "blue"}])
+    end
+  end
+
+  describe "property on instance of 'Parent' is blank" do
+    before do
+      @parent = Parent.new
+    end
+
+    it "can inherit one level up to 'Parent'" do
+      blank_inherit_helper(@parent, :fruit, 1, [:orange, :apple, :pear], [])
+    end
+  end
+
+  describe "'Child'" do
+    describe "property on 'Child' is blank" do
+      it "can inherit one level up to 'Parent'" do
+        blank_inherit_helper(Child, :fruit, 1, [:orange, :apple, :pear], [])
+      end
+
+      describe "property on instance of 'Child' is blank" do
+        before do
+          @child = Child.new
+        end
+
+        it "can inherit two levels up to 'Parent'" do
+          blank_inherit_helper(@child, :fruit, 2, [:orange, :apple, :pear], [])
+        end
+      end
+
+      describe "property on 'GrandChild' is blank" do
+        it "can inherit two levels up to 'Parent'" do
+          blank_inherit_helper(GrandChild, :fruit, 2, [:orange, :apple, :pear], [])
+        end
+      end
+    end
+
+    describe "property on 'Child' is nonblank" do
+      before do
+        Child.fruit = [:mango, :pineapple]
+      end
+
+      describe "property on instance of 'Child' is blank" do
+        before do
+          @child = Child.new
+        end
+
+        it "can inherit one level up to 'Child'" do
+          blank_inherit_helper(@child, :fruit, 1, [:mango, :pineapple], [])
+        end
+      end
+
+      describe "property on 'GrandChild' is blank" do
+        it "can inherit one level up to 'Child'" do
+          blank_inherit_helper(GrandChild, :fruit, 1, [:mango, :pineapple], [])
+        end
+
+        describe "property on instance of 'GrandChild' is blank" do
+          before do
+            @grandchild = GrandChild.new
+          end
+
+          it "can inherit two levels up to 'Child'" do
+            blank_inherit_helper(@grandchild, :fruit, 2, [:mango, :pineapple], [])
+          end
+        end
+      end
+    end
+  end
+end
+

data/spec/preset_classes/hash_spec.rb

@@ -0,0 +1,210 @@
+begin
+  require_relative '../helper_spec'
+rescue NameError
+  require File.expand_path('../helper_spec', __FILE__)
+end
+
+# todo: subclasses that inherit :Object (undefined types)
+
+describe "hash syntax" do
+  before do
+    Parent = Class.new{extend CC}
+    Child = Class.new(Parent)
+    GrandChild = Class.new(Child)
+  end
+
+  after do
+    Object.send :remove_const, :Parent
+    Object.send :remove_const, :Child
+    Object.send :remove_const, :GrandChild
+  end
+
+  describe "equivalent syntax" do
+    before do
+      Parent.cascade do
+        person_a :default => {:name => ['williamson', 'charles']}
+        person_b :hash => true
+        person_c
+      end
+
+      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
+
+      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']})
+
+      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
+
+      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']})
+    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']})
+    end
+  end
+end
+
+describe "hash usage" do
+  before do
+    Parent = Class.new{include CC}
+    Child = Class.new(Parent)
+    GrandChild = Class.new(Child)
+
+    @props = Parent.cascade do
+      eyes :default => {:color => "red"}
+    end
+  end
+
+  after do
+    Object.send :remove_const, :Parent
+    Object.send :remove_const, :Child
+    Object.send :remove_const, :GrandChild
+  end
+
+  describe "by default" do
+    it "is set to not 'inherit' by default" do
+      @props[:eyes][:inherit].must_equal 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({})
+    end
+
+    it "'Parent' has 'default' value" do
+      Parent.eyes.must_equal({:color => "red"})
+    end
+
+    it "has type ':Hash'" do
+      @props[:eyes][:type].must_equal :Hash
+    end
+
+    it "has blank value of empty hash" do
+      @props[:eyes][:blank].call({}).must_equal true
+    end
+
+    it "has new value of empty hash" do
+      @props[:eyes][:new].call.must_equal({})
+    end
+
+    it "nonblank values never inherit" do
+      nonblank_helper(Parent, :eyes, {:color => "red"})
+
+      parent = Parent.new
+      parent.eyes[:style] = "western"
+      nonblank_helper(parent, :eyes, {:style => "western"})
+
+      Child.eyes[:orig] = true
+      nonblank_helper(Child, :eyes, {:orig => true})
+
+      child = Child.new
+      child.eyes[:temp] = 95
+      nonblank_helper(child, :eyes, {:temp => 95})
+
+      GrandChild.eyes[:layout] = :normal
+      nonblank_helper(GrandChild, :eyes, {:layout => :normal})
+
+      grandchild = GrandChild.new
+      grandchild.eyes[:locale] = "en"
+      nonblank_helper(grandchild, :eyes, {:locale => "en"})
+    end
+  end
+
+  describe "property on instance of 'Parent' is blank" do
+    before do
+      @parent = Parent.new
+    end
+
+    it "can inherit one level up to 'Parent'" do
+      blank_inherit_helper(@parent, :eyes, 1, {:color => "red"}, {})
+    end
+  end
+
+  describe "'Child'" do
+    describe "property on 'Child' is blank" do
+      it "can inherit one level up to 'Parent'" do
+        blank_inherit_helper(Child, :eyes, 1, {:color => "red"}, {})
+      end
+
+      describe "property on instance of 'Child' is blank" do
+        before do
+          @child = Child.new
+        end
+
+        it "can inherit two levels up to 'Parent'" do
+          blank_inherit_helper(@child, :eyes, 2, {:color => "red"}, {})
+        end
+      end
+
+      describe "property on 'GrandChild' is blank" do
+        it "can inherit two levels up to 'Parent'" do
+          blank_inherit_helper(GrandChild, :eyes, 2, {:color => "red"}, {})
+        end
+      end
+    end
+
+    describe "property on 'Child' is nonblank" do
+      before do
+        Child.eyes[:degrees] = [:bachelors]
+      end
+
+      describe "property on instance of 'Child' is blank" do
+        before do
+          @child = Child.new
+        end
+
+        it "can inherit one level up to 'Child'" do
+          blank_inherit_helper(@child, :eyes, 1, {:degrees => [:bachelors]}, {})
+        end
+      end
+
+      describe "property on 'GrandChild' is blank" do
+        it "can inherit one level up to 'Child'" do
+          blank_inherit_helper(GrandChild, :eyes, 1, {:degrees => [:bachelors]}, {})
+        end
+
+        describe "property on instance of 'GrandChild' is blank" do
+          before do
+            @grandchild = GrandChild.new
+          end
+
+          it "can inherit two levels up to 'Child'" do
+            blank_inherit_helper(@grandchild, :eyes, 2, {:degrees => [:bachelors]}, {})
+          end
+        end
+      end
+    end
+  end
+end

data/spec/preset_classes/strings.rb

@@ -0,0 +1,190 @@
+begin
+  require_relative '../helper_spec'
+rescue NameError
+  require File.expand_path('../helper_spec', __FILE__)
+end
+
+describe "string - base" do
+  before do
+    Parent = Class.new{extend CC}
+    Child = Class.new(Parent)
+    GrandChild = Class.new(Child)
+  end
+
+  after do
+    Object.send :remove_const, :Parent
+    Object.send :remove_const, :Child
+    Object.send :remove_const, :GrandChild
+  end
+
+  describe "equivalent syntax" do
+    before do
+      Parent.cascade do
+        color_a :default => "white"
+        color_b :string => true
+        color_c
+      end
+
+      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
+
+      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"
+
+      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
+
+      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"
+    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"
+    end
+  end
+end
+
+describe "string" do
+  before do
+    Parent = Class.new{extend CC}
+    Child = Class.new(Parent)
+    GrandChild = Class.new(Child)
+
+    @props = Parent.cascade do
+      color :default => "red"
+    end
+  end
+
+  after do
+    Object.send :remove_const, :Parent
+    Object.send :remove_const, :Child
+    Object.send :remove_const, :GrandChild
+  end
+
+  describe "by default" do
+    it "has type :String" do
+      @props[:color][:type].must_equal :String
+    end
+
+    it "inherits by default" do
+      @props[:color][:inherit].must_equal true
+    end
+
+    it "has blank value of empty string" do
+      @props[:color][:blank].call('').must_equal true
+    end
+
+    it "has new value of empty string" do
+      @props[:color][:new].call.must_equal ''
+    end
+  end
+
+  describe "'Child' is blank" do
+    it "can inherit from 'Parent'" do
+      blank_inherit_helper(Child, :color, 1, "red", '')
+    end
+
+    describe "descendents of 'Child'" do
+      it "can inherit from 'Parent'" do
+        blank_inherit_helper(GrandChild, :color, 2, "red", '')
+      end
+    end
+  end
+
+  describe "'Child' is not blank" do
+    before do
+      Child.color = "blue"
+    end
+
+    it "does not inherit" do
+      nonblank_helper(Child, :color, "blue")
+    end
+
+    describe "descendents of 'Child'" do
+      it "inherits from 'Child'" do
+        blank_inherit_helper(GrandChild, :color, 1, "blue", '')
+      end
+    end
+  end
+
+  describe "change 'blank' proc, leave 'new' proc" do
+    before do
+      @props = Parent.cascade do
+        city :default => "new york", :blank => Proc.new{|v| v.nil?}
+      end
+    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
+
+      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
+
+      GrandChild.city = nil
+      GrandChild.city_is_blank?.must_equal true
+      GrandChild.city.must_equal Child.city
+      
+      Child.city = nil
+      Child.city_is_blank?.must_equal true
+      Child.city.must_equal Parent.city
+      
+      Parent.city = nil
+      Parent.city.must_equal nil
+      Parent.city_is_blank?.must_equal true
+    end
+  end
+
+  describe "change 'blank' proc and 'new' proc" do
+    before do
+      @props = Parent.cascade do
+        state :default => "NY", :blank => proc{|v| v.nil?}, :new => proc{ nil }
+      end
+    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
+
+      Child.state_is_blank?.must_equal true
+      GrandChild.state_is_blank?.must_equal true
+
+      Child.state(false).must_equal nil
+      GrandChild.state(false).must_equal nil
+    end
+  end
+end