setsumei 0.0.1

data/spec/setsumei/build_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+module Setsumei
+  describe Build do
+    describe ".a(klass,from: hash_data)" do
+      let(:klass) { mock "class" }
+      let(:hash_data) { Hash.new }
+
+      let(:defined_attributes) { { an_attribute: attribute } }
+      let(:attribute) { mock "attribute" }
+      let(:object) { mock "object" }
+
+      before do
+        klass.stub(:defined_attributes).and_return(defined_attributes)
+        klass.stub(:new).and_return(object)
+        attribute.stub(:set_value_on)
+      end
+
+      subject { Build.a klass, from: hash_data }
+
+      it "should instantiate klass" do
+        klass.should_receive(:new).and_return(object)
+        subject
+      end
+      it "should set value on object using attribute" do
+        attribute.should_receive(:set_value_on).with(object, from_value_in: hash_data )
+        subject
+      end
+      it { should == object }
+    end
+
+    describe ".a(klass,from: hash_data) error conditions" do
+      context "klass doesn't have defined attributes" do
+        let(:klass) { mock "class" }
+        specify { expect { Build.a klass, from: {} }.to raise_error ArgumentError }
+      end
+
+      context "hash data isnt provided" do
+        let(:klass) { mock "class", defined_attributes: {} }
+        specify { expect { Build.a klass }.to raise_error ArgumentError }
+      end
+    end
+  end
+end

data/spec/setsumei/describable/boolean_attribute_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+module Setsumei
+  module Describable
+    describe BooleanAttribute do
+      its(:name) { should == nil }
+
+      describe ".named(name)" do
+        let(:name) { :my_boolean_field }
+
+        subject { BooleanAttribute.named(name) }
+
+        it { should be_a BooleanAttribute }
+        its(:name) { should == name }
+      end
+
+      describe "#value_for(pre_type_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 }
+        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 }
+        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
+      end
+    end
+  end
+end

data/spec/setsumei/describable/collection_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+
+module Setsumei
+  module Describable
+    describe Collection do
+      describe "initialization" do
+        its(:klass) { should be_nil }
+        its(:options) { should be_nil }
+      end
+
+      describe ".of(klass,options)" do
+        let(:klass) { mock "klass" }
+        let(:options) { mock "options" }
+
+        subject { Collection.of klass, options }
+
+        it { should be_a Collection }
+        its(:klass) { should == klass }
+        its(:options) { should == options }
+      end
+
+      describe "#set_value_on(object, from_value_in: hash)" do
+        let(:object) { mock "object" }
+        let(:hash) { Hash.new }
+        let(:hash_keys) { mock "hash_keys" }
+        let(:key) { "aHashKey" }
+
+        let(:klass) { mock "a klass" }
+        let(:options) { Hash.new }
+        let(:collection) { Collection.of klass, options }
+
+        before do
+          hash.stub(:keys).and_return(hash_keys)
+          Build::Key.stub(:for).and_return(key)
+          hash[key] = []
+          Build.stub(:a)
+        end
+
+        subject { collection.set_value_on object, from_value_in: hash }
+
+        it "should detect they key it should use to retreive the values from the hash" do
+          hash.should_receive(:keys).and_return(hash_keys)
+          Build::Key.should_receive(:for).with( klass, given: hash_keys).and_return(key)
+          subject
+        end
+
+        context "single value" do
+          let(:single_value) { mock "single_value" }
+          let(:single_instance) { mock "single_instance" }
+
+          before do
+            hash[key] = single_value
+            Build.stub(:a).and_return single_instance
+            object.stub(:<<)
+          end
+
+          it "should build a single instance of klass" do
+            Build.should_receive(:a).with(klass, from: single_value).and_return(single_instance)
+            subject
+          end
+          it "should append this to the object" do
+            object.should_receive(:<<).with(single_instance)
+            subject
+          end
+        end
+        context "multiple values" do
+          let(:a_value) { mock "a_value" }
+          let(:another_value) { mock "another_value" }
+          let(:more_values) { mock "more_values" }
+
+          let(:first_instance) { mock "first_instance" }
+          let(:second_instance) { mock "second_instance" }
+          let(:final_instance) { mock "final_instance" }
+
+          before do
+            hash[key] = [a_value,another_value,more_values]
+            Build.stub(:a).and_return( first_instance, second_instance, final_instance )
+            object.stub(:<<)
+          end
+
+          it "should build multiple instances of klass" do
+            Build.should_receive(:a).with(klass, from: a_value)#and_return(first_instance)
+            Build.should_receive(:a).with(klass, from: another_value)#and_return(second_instance)
+            Build.should_receive(:a).with(klass, from: more_values)#and_return(final_instance)
+            subject
+          end
+          it "should append all of these to the object" do
+            object.should_receive(:<<).with(first_instance)
+            object.should_receive(:<<).with(second_instance)
+            object.should_receive(:<<).with(final_instance)
+            subject
+          end
+        end
+
+        context "options for collection specifiy within" do
+          before do
+            options[:within] = "SpecialKeyLocation"
+          end
+
+          it "should detect they key it should use to retreive the values from the hash" do
+            Build::Key.should_receive(:for).with( "SpecialKeyLocation", given: hash_keys).and_return(key)
+            subject
+          end
+        end
+      end
+    end
+  end
+end

data/spec/setsumei/describable/float_attribute_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+module Setsumei
+  module Describable
+    describe FloatAttribute do
+      its(:name) { should == nil }
+
+      describe ".named(name)" do
+        let(:name) { :my_float_field }
+
+        subject { FloatAttribute.named(name) }
+
+        it { should be_a FloatAttribute }
+        its(:name) { should == name }
+      end
+
+      describe "#value_for(pre_type_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 }
+        end
+        context "where the value isn't a float" do
+          specify { float_attribute.value_for("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
+      end
+    end
+  end
+end

data/spec/setsumei/describable/int_attribute_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+module Setsumei
+  module Describable
+    describe IntAttribute do
+      its(:name) { should == nil }
+
+      describe ".named(name)" do
+        let(:name) { :my_int_field }
+
+        subject { IntAttribute.named(name) }
+
+        it { should be_a IntAttribute }
+        its(:name) { should == name }
+      end
+
+      describe "#value_for(pre_type_cast_value)" do
+        let(:int_attribute) { IntAttribute.new }
+
+        subject { int_attribute.value_for pre_type_cast_value }
+
+        context "where the value is a int" do
+          specify { int_attribute.value_for(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 }
+        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
+      end
+    end
+  end
+end

data/spec/setsumei/describable/object_attribute_spec.rb

@@ -0,0 +1,105 @@
+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 }
+        let(:my_klass) { Class.new }
+
+        subject { ObjectAttribute.named name, as_a: 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
+      end
+
+      describe "#value_for(pre_type_cast_value)" do
+        let(:klass) { mock "klass" }
+        let(:pre_type_cast_value) { { hash: "with_values" } }
+        let(:object_attribute) { ObjectAttribute.named :name, as_a: klass }
+
+        subject { object_attribute.value_for pre_type_cast_value }
+
+        it "should use the Builder to produce a object with klass" do
+          Build.should_receive(:a).with(klass, from: pre_type_cast_value)
+          subject
+        end
+
+        context "there is no data for this object" do
+          context "empty hash" do
+            let(:pre_type_cast_value) { {} }
+            it { should be_nil }
+          end
+          context "nil" do
+            let(:pre_type_cast_value) { nil }
+            it { should be_nil }
+          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
+
+        context "where type is ObjectAttribute" do
+          let(:type) { ObjectAttribute }
+          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_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
+      end
+    end
+  end
+end