simple_mapper 0.0.1

data/lib/simple_mapper/exceptions.rb

@@ -0,0 +1,10 @@
+module SimpleMapper
+  class Exception < ::Exception
+  end
+  class TypeConversionException < Exception
+  end
+  class InvalidTypeException < Exception
+  end
+  class InvalidPatternException < Exception
+  end
+end

data/test/integration/attribute_change_tracking_test.rb

@@ -0,0 +1,181 @@
+require 'test_helper'
+
+# Change tracking is done at the attribute object level
+# via SimpleMapper::Attribute methods +changed?+ and +changed!+,
+# but the basic attribute object depends on the +simple_mapper_changes+
+# hash attribute provided by SimpleMapper::Attributes to including classes.
+#
+# The unit tests mock out this interdependency, so we need this simple
+# integration test to verify the basics.
+class AttributeChangeTrackingTest < Test::Unit::TestCase
+  context 'Objects built using SimpleMapper::Attributes' do
+    setup do
+      @class = Class.new do
+        include SimpleMapper::Attributes
+        maps :a
+        maps :b
+      end
+      @values = {:a => 'A', :b => 'B'}
+      @instance = @class.new(@values.clone)
+    end
+
+    should 'indicate no change on attribute objects for not-newly-assigned attributes' do
+      assert_equal false, @class.simple_mapper.attributes[:a].changed?(@instance)
+      assert_equal false, @class.simple_mapper.attributes[:b].changed?(@instance)
+    end
+
+    should 'indicate no change on instance via :attribute_changed? for not-newly-assigned attributes' do
+      assert_equal false, @instance.attribute_changed?(:a)
+      assert_equal false, @instance.attribute_changed?(:b)
+    end
+
+    should 'indicate change on attribute objects for newly-assigned attributes' do
+      @instance.a = 'something else'
+      assert_equal true, @class.simple_mapper.attributes[:a].changed?(@instance)
+      assert_equal false, @class.simple_mapper.attributes[:b].changed?(@instance)
+    end
+
+    should 'indicate change on instance via :attribute_changed? for newly-assigned attributes' do
+      @instance.a = 'something else'
+      assert_equal true, @instance.attribute_changed?(:a)
+      assert_equal false, @instance.attribute_changed?(:b)
+    end
+
+    should 'indicate change on nested attribute if nested attribute has a newly-assigned member' do
+      @class.maps :nested do
+        maps :inner_a
+        maps :inner_b
+      end
+      assert_equal false, @instance.attribute_changed?(:nested)
+      @instance.nested.inner_a = 'foo'
+      assert_equal true, @instance.attribute_changed?(:nested)
+    end
+
+    context 'when converting :to_simple with :changed' do
+      should 'result in an empty hash if no attributes have been changed' do
+        assert_equal({}, @instance.to_simple(:changed => true))
+      end
+
+      should 'result in hash with one member if only one member was changed' do
+        @instance.a = new_a = 'new a'
+        assert_equal({:a => new_a}, @instance.to_simple(:changed => true))
+      end
+
+      should 'result in hash with multiple members if multiple members were changed' do
+        @instance.a = new_a = 'new_a'
+        @instance.b = new_b = 'new_b'
+        assert_equal({:a => new_a, :b => new_b}, @instance.to_simple(:changed => true))
+      end
+
+      should 'result in nested hash if the class has nested attributes' do
+        @class.maps :nested do
+          maps :inner_a
+          maps :inner_b
+        end
+        @instance.a = new_a = 'new_a'
+        @instance.nested.inner_a = new_inner_a = 'new_inner_a'
+        assert_equal({:a => new_a, :nested => {:inner_a => new_inner_a}}, @instance.to_simple(:changed => true))
+      end
+
+      context 'and a hash collection attribute' do
+        setup do
+          @collection_class = Class.new(SimpleMapper::Attribute) do
+            include SimpleMapper::Attribute::Collection
+
+            def prefix
+              '__'
+            end
+
+            def member_key?(key)
+              key.to_s[0..1] == prefix
+            end
+
+            def from_simple_key(key)
+              key.to_s.sub(prefix, '').to_sym
+            end
+
+            def to_simple_key(key)
+              (prefix + key.to_s).to_sym
+            end
+          end
+
+          @class.maps :collection, :attribute_class => @collection_class
+          @instance = @class.new(@values.clone)
+        end
+
+        should 'have no output for the collection if no members were changed' do
+          @instance.a = new_a = 'new_a'
+          assert_equal({:a => new_a}, @instance.to_simple(:changed => true))
+        end
+
+        should 'have output for items added to the collection' do
+          @instance.collection[:first] = 'first'
+          @instance.collection[:second] = 'second'
+          @instance.collection[:third] = 'third'
+          assert_equal(
+            {
+              :__first  => 'first',
+              :__second => 'second',
+              :__third  => 'third',
+            },
+            @instance.to_simple(:changed => true)
+          )
+        end
+
+        should 'have output for items altered in the collection' do
+          @instance = @class.new(:__first => 'first', :__second => 'second', :__third => 'third')
+          @instance.collection[:second] = 'new second'
+          @instance.collection.delete(:third)
+          @instance.collection[:fourth] = 'fourth'
+          assert_equal(
+            {:__second => 'new second',
+             :__third  => nil,
+             :__fourth => 'fourth'},
+            @instance.to_simple(:changed => true)
+          )
+        end
+
+        context 'with mapped members' do
+          setup do
+            @mapped_collection_class = Class.new(@collection_class) do
+              def prefix
+                '--'
+              end
+            end
+            @class.maps :mapped_collection, :attribute_class => @mapped_collection_class do
+              maps :name
+              maps :id, :type => :simple_uuid, :default => :from_type
+            end
+          end
+
+          should 'have output for items added to collection' do
+            @instance.mapped_collection[:me] = @instance.mapped_collection.build(:name => 'me')
+            @instance.mapped_collection[:you] = @instance.mapped_collection.build(:name => 'you')
+            expected = {
+              :'--me'  => {:name => 'me',  :id => @instance.mapped_collection[:me].id},
+              :'--you' => {:name => 'you', :id => @instance.mapped_collection[:you].id},
+            }
+            assert_equal expected, @instance.to_simple(:changed => true)
+          end
+
+          should 'have output for items removed from collection' do
+            @instance = @class.new(:'--me' => {:name => 'me'}, :'--you' => {:name => 'you'})
+            @instance.mapped_collection.delete(:you)
+            assert_equal({:'--you' => nil}, @instance.to_simple(:changed => true))
+          end
+
+          should 'have output for all attributes in replaced member' do
+            @instance = @class.new(:'--me' => {:name => 'me'})
+            @instance.mapped_collection[:me] = @instance.mapped_collection.build
+            assert_equal({:'--me' => {:name => nil, :id => @instance.mapped_collection[:me].id}}, @instance.to_simple(:changed => true))
+          end
+        end
+      end
+
+      context 'and an array collection attribute' do
+        setup do
+        end
+      end
+    end
+  end
+end

data/test/integration/attribute_meta_interaction_test.rb

@@ -0,0 +1,169 @@
+require 'test_helper'
+
+class AttributeMetaInteractionTest < Test::Unit::TestCase
+  context 'Object attribute / meta attribute method' do
+    setup do
+      @class = Class.new do
+        include SimpleMapper::Attributes
+        maps :foo
+      end
+    end
+
+    context 'read_source_attribute' do
+      setup do
+        @instance = @class.new(:foo => 'Foo!')
+      end
+
+      should 'return the attribute specified from the source hash' do
+        assert_equal 'Foo!', @instance.read_source_attribute(:foo)
+      end
+
+      should 'return the attribute from source even if updated locally' do
+        @instance.write_attribute(:foo, 'Blah!')
+        assert_equal 'Blah!', @instance.read_attribute(:foo)
+        assert_equal 'Foo!', @instance.read_source_attribute(:foo)
+      end
+
+      should 'return the source attribute via string key if symbol key does not exist' do
+        @class.maps :some_attr
+        @instance = @class.new('foo' => 'Foo!', :some_attr => 'Some Attr')
+        assert_equal 'Foo!', @instance.read_attribute(:foo)
+        assert_equal 'Some Attr', @instance.read_attribute(:some_attr)
+      end
+    end
+
+    context 'read_attribute' do
+      setup do
+        @instance = @class.new(:foo => 'Foo!', :some_attr => 'Some Attr')
+      end
+
+      should 'return the source attribute by default' do
+        assert_equal 'Foo!', @instance.read_attribute(:foo)
+      end
+
+      should 'return the updated attribute if one exists' do
+        @instance.write_attribute(:foo, 'Blah!')
+        assert_equal 'Blah!', @instance.read_attribute(:foo)
+      end
+
+      should 'return the attribute default if source attribute is nil' do
+        @instance = @class.new
+        @instance.attribute_object_for(:foo).expects(:default_value).with(@instance).returns('foo default')
+        result = @instance.read_attribute(:foo)
+        assert_equal 'foo default', result
+      end
+
+      context 'with a type converter' do
+        setup do
+          @expected_out = '_foo_'
+          @expected_in = 'Foo!'
+          @type_a = mock('type_a')
+          @type_a.expects(:decode).with(@expected_in).returns(@expected_out)
+          @class.simple_mapper.attributes[:foo].type = @type_a
+        end
+
+        should 'transform the source attribute' do
+          assert_equal @expected_out, @instance.read_attribute(:foo)
+        end
+
+        should 'transform the default value if no source value is defined' do
+          @instance = @class.new
+          @instance.attribute_object_for(:foo).default = :get_default
+          @instance.stubs(:get_default).returns(@expected_in)
+          assert_equal @expected_out, @instance.read_attribute(:foo)
+        end
+      end
+
+      context 'with a type name' do
+        setup do
+          foo_type = mock('foo_type')
+          foo_class = foo_type.class
+          @expected_in = 'Foo!'
+          @expected_out = 'Foo on Ewe!'
+          foo_type.expects(:decode).once.with(@expected_in).returns(@expected_out)
+          SimpleMapper::Attributes.stubs(:types).with.returns({:foo_type => {
+            :name          => :foo_type,
+            :expected_type => foo_class,
+            :converter     => foo_type,
+          }})
+          @class.simple_mapper.attributes[:foo].type = :foo_type
+        end
+
+        should 'transform the source attribute if a type name was specified' do
+          assert_equal @expected_out, @instance.read_attribute(:foo)
+        end
+
+        should 'transform the default value if the source is nil' do
+          @instance = @class.new
+          @instance.attribute_object_for(:foo).default = :get_default
+          @instance.stubs(:get_default).returns(@expected_in)
+          assert_equal @expected_out, @instance.read_attribute(:foo)
+        end
+      end
+
+      should 'not transform the source attr if it is already of the expected type' do
+        foo_type = mock('foo too type')
+        foo_type.expects(:decode).never
+        SimpleMapper::Attributes.expects(:type_for).with(:foo_type).returns({
+          :name          => :foo_type,
+          :expected_type => String,
+          :converter     => foo_type,
+        })
+        @class.simple_mapper.attributes[:foo].type = :foo_type
+        assert_equal 'Foo!', @instance.read_attribute(:foo)
+      end
+
+      should 'not transform a written attribute when type was specified' do
+        type_a = mock('type_a')
+        type_a.expects(:decode).never
+        @class.simple_mapper.attributes[:foo].type = type_a
+        @instance.write_attribute(:foo, 'blahblah')
+        assert_equal 'blahblah', @instance.read_attribute(:foo)
+      end
+    end
+
+    context 'get_attribute_default' do
+      setup do
+        @instance = @class.new(:foo => 'foo')
+      end
+
+      should 'return nil if the attribute has no default specified' do
+        @class.maps :without_default
+        assert_equal nil, @instance.get_attribute_default(:without_default)
+      end
+
+      should 'invoke specified default symbol on instance if attr has default specified' do
+        @class.maps :with_default, :default => :some_default
+        @instance.expects(:some_default).once.with.returns('the default value')
+        assert_equal 'the default value', @instance.get_attribute_default(:with_default)
+      end
+
+      context 'with :default of :from_type' do
+        setup do
+          @expected_val = 'some default value'
+          @name = :with_default
+          @type = stub('type', :name => :type_name, :decode => :foo, :encode => :foo2)
+          @type.expects(:default).once.with.returns(@expected_val)
+        end
+
+        should 'invoke :default on type converter if default is :from_type and :type is object' do
+          @class.maps :with_default, :type => @type, :default => :from_type
+          assert_equal @expected_val, @instance.get_attribute_default(:with_default)
+        end
+
+        should 'invoke :default on registered type if default is :from_type and :type is registered' do
+          begin
+            SimpleMapper::Attributes.stubs(:types).with.returns({@name => {
+              :name           => @name,
+              :expected_class => @type.class,
+              :converter      => @type}})
+            @class.maps :with_default, :type => @name, :default => :from_type
+            assert_equal @expected_val, @instance.get_attribute_default(:with_default)
+          ensure
+            SimpleMapper::Attributes.types.delete @type.name
+          end
+        end
+      end
+    end
+  end
+end

data/test/integration/attribute_pattern_test.rb

@@ -0,0 +1,77 @@
+require 'test_helper'
+
+# basic end-to-end tests for the SimpleMapper::Attribute::Pattern attribute class.
+class AttributePatternIntegrationTest < Test::Unit::TestCase
+  context 'A SimpleMapper::Attribute::Pattern attribute' do
+    setup do
+      @target_class = SimpleMapper::Attribute::Pattern
+      @class = Class.new do
+        include SimpleMapper::Attributes
+      end
+    end
+
+    context 'with simple values' do
+      setup do
+        @class.maps :simple, :attribute_class => @target_class, :pattern => /^simple_/
+        @class.maps :float,  :attribute_class => @target_class, :pattern => /^float_/, :type => :float
+        @simple = {:simple_a => 'a', :simple_b => 'b', :simple_c => 'c'}
+        @float  = {:float_a => 1.0, :float_b => 100.1, :float_c => 99.99999}
+        @object = @class.new( @simple.merge( @float.inject({}) {|h, kv| h[kv[0]] = kv[1].to_s; h} ) )      end
+
+      should 'map untyped pairs to the patterned collection attribute' do
+        assert_equal @simple, @object.simple
+      end
+
+      should 'map typed pairs to the patterned collection attribute' do
+        assert_equal @float, @object.float
+      end
+
+      should 'map untyped instance values back to simple structure using to_simple' do
+        result = @object.to_simple || {}
+        assert_equal @simple, result.reject {|k, v| ! /^simple_/.match(k.to_s)}
+      end
+
+      should 'map typed instance values back to simple structure using to_simple' do 
+        result = @object.to_simple || {}
+        assert_equal(@float.inject({}) {|h, pair| h[pair[0]] = pair[1].to_s; h},
+                     result.reject {|k, v| ! /^float_/.match(k.to_s)})
+      end
+    end
+
+    context 'with a nested mapper' do
+      setup do
+        @class.maps :not_nested
+        @class.maps :nested, :attribute_class => @target_class, :pattern => /^nested_/ do
+          maps :foo
+          maps :bar
+        end
+
+        @input = {:nested_a => {:foo => 'foo_a', :bar => 'bar_a'},
+                  :nested_b => {:foo => 'foo_b', :bar => 'bar_b'},
+                  :nested_c => {:foo => 'foo_c', :bar => 'bar_c'},
+                  :not_nested => 'blah'}
+        @object = @class.new(@input)
+      end
+
+      should 'convert nested source values to type defined by block per item in patterned collection attribute' do
+        result = @object.nested.inject({}) do |hash, keyval|
+          hash[keyval[0]] = {:foo => keyval[1].foo, :bar => keyval[1].bar}
+          hash
+        end
+        expected = @input.clone
+        expected.delete :not_nested
+        assert_equal expected, result
+      end
+
+      should 'still map simple attributes too' do
+        assert_equal @input[:not_nested], @object.not_nested.to_s
+      end
+
+      should 'map nested objects back to nested simple structures with to_simple' do
+        expected = @input.reject {|k, v| ! /^nested_/.match(k.to_s)}
+        result = @object.to_simple || {}
+        assert_equal(expected, result.reject {|k, v| ! /^nested/.match(k.to_s)})
+      end
+    end
+  end
+end

data/test/integration/to_simple_test.rb

@@ -0,0 +1,128 @@
+require 'test_helper'
+
+# The :to_simple method of the SimpleMapper::Attributes
+# module ultimately depends on the :to_simple
+# implementation of the attribute objects for a given
+# mapper class.
+#
+# Consequently, the integration test is necessary,
+# as other :to_simple tests at the unit level rely on
+# mocks for this interdependency.
+class ToSimpleTest < Test::Unit::TestCase
+  context "The mapper's :to_simple method" do
+    setup do
+      @class = Class.new do
+        include SimpleMapper::Attributes
+        maps :no_type
+      end
+    end
+
+    should 'return a hash with key/value per known attribute' do
+      @class.maps :other
+      @instance = @class.new( :no_type => 'no type', :other => 'Other!' )
+      assert_equal( {:no_type => 'no type', :other => 'Other!'}, @instance.to_simple )
+    end
+
+    should 'return hash whose key/value pairs follow attribute state' do
+      @class.maps :other
+      @instance = @class.new( :no_type => 'original', :other => 'original' )
+      @instance.other = 'updated'
+      assert_equal({:no_type => 'original', :other => 'updated'}, @instance.to_simple)
+    end
+
+    should 'map attributes to specified keys in returned hash' do
+      @class.maps :other, :key => :alt_key
+      @instance = @class.new
+      @instance.no_type = 'no type'
+      @instance.other = 'alt key'
+      assert_equal({:no_type => 'no type', :alt_key => 'alt key'}, @instance.to_simple)
+    end
+
+    should 'return a hash with strings for keys when :string_keys option is true' do
+      @class.maps :other, :key => :alt_key
+      @instance = @class.new
+      @instance.no_type = 'no type'
+      @instance.other = 'alt key'
+      assert_equal({'no_type' => 'no type', 'alt_key' => 'alt key'},
+                    @instance.to_simple(:string_keys => true))
+    end
+
+    should 'encode typed attribute values for converter types' do
+      @type = Object.new
+      @type.instance_eval do
+        def encode(value)
+          "encoded: #{value}"
+        end
+        def decode(value)
+          value
+        end
+      end
+      @class.maps :typed, :type => @type
+      @instance = @class.new( :typed => 'typed!' )
+      assert_equal 'encoded: typed!', @instance.to_simple[:typed]
+    end
+
+    should 'encode typed attribute values for registered types' do
+      @type = mock('type')
+      @type.expects(:encode).once.with('typed!').returns('encoded!')
+      @type.stubs(:decode).returns('typed!')
+      SimpleMapper::Attributes.expects(:type_for).with(:type).at_least_once.returns({
+        :name          => :type,
+        :expected_type => @type.class,
+        :converter     => @type,
+      })
+      @class.maps :typed, :type => :type
+      @instance = @class.new( :typed => 'typed!' )
+      assert_equal 'encoded!', @instance.to_simple[:typed]
+    end
+
+    context 'with :defined argument' do
+      should 'return a hash with key/value per defined attribute' do
+        @class.maps :undefined
+        assert_equal({:no_type => 'nt'}, @class.new({:no_type => 'nt'}).to_simple(:defined => true))
+      end
+
+      should 'return an empty hash if no attributes were set' do
+        assert_equal({}, @class.new.to_simple(:defined => true))
+      end
+    end
+
+    context 'with :changes argument' do
+      setup do
+        @class.maps :other
+        @instance = @class.new({:typed => 'typed', :other => 'other'})
+      end
+
+      should 'return an empty hash if no attributes were changed' do
+        assert_equal({}, @instance.to_simple(:changed => true))
+      end
+
+      should 'return a hash of only the key/value pairs that were changed' do
+        @instance.other = 'udder'
+        @instance.class.simple_mapper.attributes[:other].stubs(:changed?).with(@instance).returns(true)
+        assert_equal({:other => 'udder'}, @instance.to_simple(:changed => true))
+      end
+    end
+
+    context 'with an attribute value that uses a mapper' do
+      setup do
+        @class.maps :other do; end
+        @instance = @class.new({:no_type => 'no type',
+                                :other => {}})
+        @mock = @instance.other
+      end
+
+      should 'invoke to_simple on attribute value rather than encode' do
+        @mock.expects(:to_simple).returns('to simple')
+        assert_equal({:no_type => 'no type', :other => 'to simple'},
+                      @instance.to_simple)
+      end
+
+      should 'pass outer to_simple arguments along to inner to_simple' do
+        options = {:foo => 'floppy', :foot => 'fungi'}
+        @mock.expects(:to_simple).with(options).returns(nil)
+        @instance.to_simple(options)
+      end
+    end
+  end
+end