setsumei 0.0.10 → 0.0.12

data/spec/setsumei/describable/boolean_attribute_spec.rb

@@ -3,89 +3,31 @@ require 'spec_helper'
 module Setsumei
   module Describable
     describe BooleanAttribute do
-      its(:name) { should == nil }
 
-      describe ".named(name)" do
-        let(:name) { :my_boolean_field }
+      describe "#== other" do
+        subject { BooleanAttribute.new }
 
-        subject { BooleanAttribute.named(name) }
-
-        it { should be_a BooleanAttribute }
-        its(:name) { should == name }
-
-        it_should_behave_like "it handles options properly"
+        it { should == :boolean }
+        it { should == BooleanAttribute }
+        it { should_not eq double }
       end
 
-      describe "#value_for(pre_type_cast_value)" do
+      describe "#cast value" do
         let(:boolean_attribute) { BooleanAttribute.new }
 
         context "where the value is a boolean" do
-          specify { boolean_attribute.value_for(true).should === true }
-          specify { boolean_attribute.value_for(false).should === false }
+          specify { boolean_attribute.cast(true).should === true }
+          specify { boolean_attribute.cast(false).should === false }
         end
         context "where the value isn't a boolean" do
-          specify { boolean_attribute.value_for("false").should === false }
-          specify { boolean_attribute.value_for("true").should === true }
-          specify { boolean_attribute.value_for("True").should === true }
-          specify { boolean_attribute.value_for("1").should === true }
-        end
-      end
-
-      describe "#is_an_attribute_of_type?" do
-        let(:boolean_attribute) { BooleanAttribute.new }
-
-        subject { boolean_attribute.is_an_attribute_of_type? type }
-
-        context "where type is :boolean" do
-          let(:type) { :boolean }
-          it { should be_true }
-        end
-
-        context "where type is BooleanAttribute" do
-          let(:type) { BooleanAttribute }
-          it { should be_true }
-        end
-
-        context "where type is unknown" do
-          let(:type) { mock "an unknown type" }
-          it { should be_false }
+          specify { boolean_attribute.cast("false").should === false }
+          specify { boolean_attribute.cast("true").should === true }
+          specify { boolean_attribute.cast("True").should === true }
+          specify { boolean_attribute.cast("1").should === true }
         end
       end
 
-      describe "set_value_on object, from_value_in: hash" do
-        let(:hash) { Hash.new }
-        let(:key) { "key" }
-        let(:hash_keys) { mock "hash_keys" }
-        let(:value_in_hash) { mock "value_in_hash" }
-
-        let(:object) { mock "object", :my_boolean_attribute= => nil }
-
-        let(:boolean_attribute) { BooleanAttribute.named :my_boolean_attribute }
-        let(:converted_value) { mock "converted_value" }
-
-        before do
-          Build::Key.stub(:for).and_return(key)
-          hash[key] = value_in_hash
-          boolean_attribute.stub(:value_for).and_return(converted_value)
-        end
-
-        subject { boolean_attribute.set_value_on object, from_value_in: hash }
-
-        it "should detect the key it should use to retrieve the value from the hash" do
-          hash.should_receive(:keys).and_return(hash_keys)
-          Build::Key.should_receive(:for).with(:my_boolean_attribute, given: hash_keys ).and_return(key)
-          subject
-        end
-        it "should convert the value" do
-          boolean_attribute.should_receive(:value_for).with(value_in_hash).and_return(converted_value)
-          subject
-        end
-        it "should pass object a value to the attribute described by this class" do
-          object.should_receive(:my_boolean_attribute=).with(converted_value)
-          subject
-        end
-        it_should_behave_like "it handles lookup keys properly"
-      end
     end
   end
 end
+

data/spec/setsumei/describable/date_attribute_spec.rb

@@ -2,100 +2,39 @@ require 'spec_helper'
 
 module Setsumei
   module Describable
-    describe DateAttribute do
-      its(:name) { should == nil }
+    describe DateTimeAttribute do
 
-      describe ".named(name)" do
-        let(:name) { :my_date_field }
-
-        subject { DateAttribute.named(name) }
-
-        it { should be_a DateAttribute }
-        its(:name) { should == name }
-        its(:format) { should == '%Y-%m-%d' }
-
-        context 'format specified' do
-          let(:format) { mock "format" }
-
-          subject { DateAttribute.named name, format: format }
-
-          its(:format) { should == format }
+      describe "#initialize(format)" do
+        it 'is configurable' do
+          format = double
+          DateTimeAttribute.new(:date, format, Date).format.should == format
         end
+      end
+
+      describe "#== other" do
+        subject { DateTimeAttribute.new :date, '%Y-%m-%d', Date }
 
-        it_should_behave_like "it handles options properly"
+        it { should == :date }
+        it { should == DateTimeAttribute }
+        it { should_not eq double }
       end
 
-      describe "#value_for(pre_type_cast_value)" do
-        let(:attribute) { DateAttribute.new }
 
-        subject { attribute.value_for pre_type_cast_value }
+      describe "#cast value" do
+        let(:attribute) { DateTimeAttribute.new :date, '%Y-%m-%d', Date }
+
+        subject { attribute.cast value }
 
         context "where pre_type_cast_value is a string" do
-          let(:pre_type_cast_value) { "time" }
+          let(:value) { "time" }
           let(:formatted_value) { mock "formatted_value" }
 
           it "should parse it into a time with format" do
-            Date.should_receive(:strptime).with(pre_type_cast_value.to_s,attribute.format).and_return(formatted_value)
+            Date.should_receive(:strptime).with(value,'%Y-%m-%d').and_return(formatted_value)
             subject.should == formatted_value
           end
         end
       end
-
-      describe "#is_an_attribute_of_type?" do
-        let(:attribute) { DateAttribute.new }
-
-        subject { attribute.is_an_attribute_of_type? type }
-
-        context "where type is :date" do
-          let(:type) { :date }
-          it { should be_true }
-        end
-
-        context "where type is DateAttribute" do
-          let(:type) { DateAttribute }
-          it { should be_true }
-        end
-
-        context "where type is unknown" do
-          let(:type) { mock "an unknown type" }
-          it { should be_false }
-        end
-      end
-
-      describe "set_value_on object, from_value_in: hash" do
-        let(:hash) { Hash.new }
-        let(:key) { "key" }
-        let(:hash_keys) { mock "hash_keys" }
-        let(:value_in_hash) { mock "value_in_hash" }
-        let(:converted_value) { mock "converted_value" }
-
-        let(:object) { mock "object", :my_date_attribute= => nil }
-
-        let(:date_attribute) { DateAttribute.named :my_date_attribute }
-
-        before do
-          Build::Key.stub(:for).and_return(key)
-          hash[key] = value_in_hash
-          date_attribute.stub(:value_for).and_return(converted_value)
-        end
-
-        subject { date_attribute.set_value_on object, from_value_in: hash }
-
-        it "should detect the key it should use to retrieve the value from the hash" do
-          hash.should_receive(:keys).and_return(hash_keys)
-          Build::Key.should_receive(:for).with(:my_date_attribute, given: hash_keys ).and_return(key)
-          subject
-        end
-        it "should convert the value" do
-          date_attribute.should_receive(:value_for).with(value_in_hash).and_return(converted_value)
-          subject
-        end
-        it "should pass object a value to the attribute described by this class" do
-          object.should_receive(:my_date_attribute=).with(converted_value)
-          subject
-        end
-        it_should_behave_like "it handles lookup keys properly"
-      end
     end
   end
 end

data/spec/setsumei/describable/float_attribute_spec.rb

@@ -3,87 +3,26 @@ require 'spec_helper'
 module Setsumei
   module Describable
     describe FloatAttribute do
-      its(:name) { should == nil }
 
-      describe ".named(name)" do
-        let(:name) { :my_float_field }
+      describe "#== other" do
+        subject { FloatAttribute.new }
 
-        subject { FloatAttribute.named(name) }
-
-        it { should be_a FloatAttribute }
-        its(:name) { should == name }
-
-        it_should_behave_like "it handles options properly"
+        it { should == :float }
+        it { should == FloatAttribute }
+        it { should_not eq double }
       end
 
-      describe "#value_for(pre_type_cast_value)" do
+      describe "#cast value" do
         let(:float_attribute) { FloatAttribute.new }
 
-        subject { float_attribute.value_for pre_type_cast_value }
-
         context "where the value is a float" do
-          specify { float_attribute.value_for(10.2).should == 10.2 }
+          specify { float_attribute.cast(10.2).should == 10.2 }
         end
         context "where the value isn't a float" do
-          specify { float_attribute.value_for("10.2").should == 10.2 }
+          specify { float_attribute.cast("10.2").should == 10.2 }
         end
       end
 
-      describe "#is_an_attribute_of_type?" do
-        let(:float_attribute) { FloatAttribute.new }
-
-        subject { float_attribute.is_an_attribute_of_type? type }
-
-        context "where type is :float" do
-          let(:type) { :float }
-          it { should be_true }
-        end
-
-        context "where type is FloatAttribute" do
-          let(:type) { FloatAttribute }
-          it { should be_true }
-        end
-
-        context "where type is unknown" do
-          let(:type) { mock "an unknown type" }
-          it { should be_false }
-        end
-      end
-
-      describe "set_value_on object, from_value_in: hash" do
-        let(:hash) { Hash.new }
-        let(:key) { "key" }
-        let(:hash_keys) { mock "hash_keys" }
-        let(:value_in_hash) { mock "value_in_hash" }
-
-        let(:object) { mock "object", :my_float_attribute= => nil }
-
-        let(:float_attribute) { FloatAttribute.named :my_float_attribute }
-        let(:converted_value) { mock "converted_value" }
-
-        before do
-          Build::Key.stub(:for).and_return(key)
-          hash[key] = value_in_hash
-          float_attribute.stub(:value_for).and_return(converted_value)
-        end
-
-        subject { float_attribute.set_value_on object, from_value_in: hash }
-
-        it "should detect the key it should use to retrieve the value from the hash" do
-          hash.should_receive(:keys).and_return(hash_keys)
-          Build::Key.should_receive(:for).with(:my_float_attribute, given: hash_keys ).and_return(key)
-          subject
-        end
-        it "should convert the value" do
-          float_attribute.should_receive(:value_for).with(value_in_hash).and_return(converted_value)
-          subject
-        end
-        it "should pass object a value to the attribute described by this class" do
-          object.should_receive(:my_float_attribute=).with(converted_value)
-          subject
-        end
-        it_should_behave_like "it handles lookup keys properly"
-      end
     end
   end
 end

data/spec/setsumei/describable/int_attribute_spec.rb

@@ -3,88 +3,29 @@ require 'spec_helper'
 module Setsumei
   module Describable
     describe IntAttribute do
-      its(:name) { should == nil }
 
-      describe ".named(name)" do
-        let(:name) { :my_int_field }
+      describe "#== other" do
+        subject { IntAttribute.new }
 
-        subject { IntAttribute.named(name) }
-
-        it { should be_a IntAttribute }
-        its(:name) { should == name }
-
-        it_should_behave_like "it handles options properly"
+        it { should == :int }
+        it { should == IntAttribute }
+        it { should_not eq double }
       end
 
-      describe "#value_for(pre_type_cast_value)" do
+      describe "#cast value" do
         let(:int_attribute) { IntAttribute.new }
 
-        subject { int_attribute.value_for pre_type_cast_value }
+        subject { int_attribute.cast pre_type_cast_value }
 
         context "where the value is a int" do
-          specify { int_attribute.value_for(42).should == 42 }
+          specify { int_attribute.cast(42).should == 42 }
         end
         context "where the value isn't a int" do
-          specify { int_attribute.value_for("10.6").should == 11 }
-          specify { int_attribute.value_for("10.4").should == 10 }
-        end
-      end
-
-      describe "#is_an_attribute_of_type?" do
-        let(:int_attribute) { IntAttribute.new }
-
-        subject { int_attribute.is_an_attribute_of_type? type }
-
-        context "where type is :int" do
-          let(:type) { :int }
-          it { should be_true }
-        end
-
-        context "where type is IntAttribute" do
-          let(:type) { IntAttribute }
-          it { should be_true }
-        end
-
-        context "where type is unknown" do
-          let(:type) { mock "an unknown type" }
-          it { should be_false }
+          specify { int_attribute.cast("10.6").should == 11 }
+          specify { int_attribute.cast("10.4").should == 10 }
         end
       end
 
-      describe "set_value_on object, from_value_in: hash" do
-        let(:hash) { Hash.new }
-        let(:key) { "key" }
-        let(:hash_keys) { mock "hash_keys" }
-        let(:value_in_hash) { mock "value_in_hash" }
-
-        let(:object) { mock "object", :my_int_attribute= => nil }
-
-        let(:int_attribute) { IntAttribute.named :my_int_attribute }
-        let(:converted_value) { mock "converted_value" }
-
-        before do
-          Build::Key.stub(:for).and_return(key)
-          hash[key] = value_in_hash
-          int_attribute.stub(:value_for).and_return(converted_value)
-        end
-
-        subject { int_attribute.set_value_on object, from_value_in: hash }
-
-        it "should detect the key it should use to retrieve the value from the hash" do
-          hash.should_receive(:keys).and_return(hash_keys)
-          Build::Key.should_receive(:for).with(:my_int_attribute, given: hash_keys ).and_return(key)
-          subject
-        end
-        it "should convert the value" do
-          int_attribute.should_receive(:value_for).with(value_in_hash).and_return(converted_value)
-          subject
-        end
-        it "should pass object a value to the attribute described by this class" do
-          object.should_receive(:my_int_attribute=).with(converted_value)
-          subject
-        end
-        it_should_behave_like "it handles lookup keys properly"
-      end
     end
   end
 end

data/spec/setsumei/describable/object_attribute_spec.rb

@@ -3,122 +3,67 @@ require 'spec_helper'
 module Setsumei
   module Describable
     describe ObjectAttribute do
-      its(:name) { should == nil }
-      its(:klass) { should == Object }
 
-      describe ".named(name)" do
-        let(:name) { :my_object_field }
+      describe "#initialize(klass)" do
         let(:my_klass) { Class.new }
 
-        subject { ObjectAttribute.named name, as_a: my_klass }
+        subject { ObjectAttribute.new my_klass }
 
-        it { should be_a ObjectAttribute }
-        its(:name) { should == name }
-        its(:klass) { should == my_klass }
-
-        context "klass is left off" do
-          subject { ObjectAttribute.named name }
-          specify { expect { subject }.to raise_error ArgumentError }
-        end
-
-        it_should_behave_like "it handles options properly"
+        specify { subject.klass.should == my_klass }
       end
 
-      describe "#value_for(pre_type_cast_value)" do
+      describe "#cast data" do
         let(:klass) { mock "klass" }
-        let(:pre_type_cast_value) { { hash: "with_values" } }
-        let(:object_attribute) { ObjectAttribute.named :name, as_a: klass }
+        let(:data)  { { hash: "with_values" } }
+        let(:object_attribute) { ObjectAttribute.new(klass) }
 
         before do
           klass.stub(:create_from).and_raise(NoMethodError)
         end
 
-        subject { object_attribute.value_for pre_type_cast_value }
+        subject { object_attribute.cast data }
 
         it "should use the Builder to produce a object with klass" do
-          Build.should_receive(:a).with(klass, from: pre_type_cast_value)
+          Build.should_receive(:a).with(klass, from: data)
           subject
         end
 
         context "there is no data for this object" do
           context "empty hash" do
-            let(:pre_type_cast_value) { {} }
+            let(:data) { {} }
             it { should be_nil }
           end
           context "nil" do
-            let(:pre_type_cast_value) { nil }
+            let(:data) { nil }
             it { should be_nil }
           end
         end
+
         context "klass responds to create_from" do
-          let(:pre_fab_object) { mock "pre_fab_object" }
+          let(:pre_fab_object) { double "pre_fab_object" }
 
           before do
             klass.unstub(:create_from)
           end
 
           it "should build the klass itself" do
-            klass.should_receive(:create_from).with(pre_type_cast_value).and_return(pre_fab_object)
+            klass.should_receive(:create_from).with(data).and_return(pre_fab_object)
             subject.should == pre_fab_object
           end
         end
       end
 
-      describe "#is_an_attribute_of_type?" do
-        let(:object_attribute) { ObjectAttribute.new }
-
-        subject { object_attribute.is_an_attribute_of_type? type }
-
-        context "where type is :object" do
-          let(:type) { :object }
-          it { should be_true }
-        end
+      describe "#== other" do
+        let(:klass) { double }
 
-        context "where type is ObjectAttribute" do
-          let(:type) { ObjectAttribute }
-          it { should be_true }
-        end
+        subject { ObjectAttribute.new klass }
 
-        context "where type is unknown" do
-          let(:type) { mock "an unknown type" }
-          it { should be_false }
-        end
+        it { should eq :object }
+        it { should eq klass }
+        it { should eq ObjectAttribute }
+        it { should_not eq double("an unknown type") }
       end
 
-      describe "set_value_on object, from_value_in: hash" do
-        let(:hash) { Hash.new }
-        let(:key) { "key" }
-        let(:hash_keys) { mock "hash_keys" }
-        let(:value_in_hash) { mock "value_in_hash" }
-
-        let(:object) { mock "object", :my_object_attribute= => nil }
-
-        let(:object_attribute) { ObjectAttribute.named :my_object_attribute, as_a: mock("object_klass") }
-        let(:converted_value) { mock "converted_value" }
-
-        before do
-          Build::Key.stub(:for).and_return(key)
-          hash[key] = value_in_hash
-          object_attribute.stub(:value_for).and_return(converted_value)
-        end
-
-        subject { object_attribute.set_value_on object, from_value_in: hash }
-
-        it "should detect the key it should use to retrieve the value from the hash" do
-          hash.should_receive(:keys).and_return(hash_keys)
-          Build::Key.should_receive(:for).with(:my_object_attribute, given: hash_keys ).and_return(key)
-          subject
-        end
-        it "should convert the value" do
-          object_attribute.should_receive(:value_for).with(value_in_hash).and_return(converted_value)
-          subject
-        end
-        it "should pass object a value to the attribute described by this class" do
-          object.should_receive(:my_object_attribute=).with(converted_value)
-          subject
-        end
-        it_should_behave_like "it handles lookup keys properly"
-      end
     end
   end
 end