simple_attribute_mapper 0.0.1 → 0.0.2

data/README.md

@@ -26,6 +26,7 @@ class Person
   atrribute :last_name, String
   attribute :email, String
   attribute :home_phone, String
+  attribute :mailing_address, String
 end
 
 class User < ActiveRecord::Base
@@ -33,6 +34,10 @@ class User < ActiveRecord::Base
   # last_name
   # user_name
   # phone_number
+  # street
+  # city
+  # state
+  # zip
 end
 ```
 
@@ -44,23 +49,43 @@ specify additional mappings, i.e. user_name -> email
 user = User.find(0000)
 user.user_name # => "test@example.com"
 mapper = SimpleAttributeMapper::Mapper.new({:user_name => :email})
-person = mapper.map(user, Person) # returns a new instance of Person 
+person = mapper.map(user, Person) # returns a new instance of Person
 person.email # => "test@example.com"
 ```
 
-## TODO
+Typically you won't create instances of SimpleAttributeMapper::Mapper in your code, instead you will configure all mappings and use `SimpleAttributeMapper.map`, see below
 
-* configure the mappings, i.e.
+### Configuration
 
 ```
-# configure once
-SimpleAttributeMapper.from(User).to(Person).with({:user_name => :email}).with({:phone_number => :home_phone})
-# use later
+# in rails: config/initializers/simple_attribute_mapper_config.rb
+SimpleAttributeMapper.configure do |config|
+  config << SimpleAttributeMapper.from(User).to(Person).with({:user_name => :email}).with({:phone_number => :home_phone})
+end
+
+# use later in application to map 
+user = User.find(0000)
 person = SimpleAttributeMapper.map(user, Person)
+
+```
+
+### Mapping options
+
 ```
+# default, maps all matching attributes
+SimpleAttributeMapper.from(User).to(Person)
+
+# map source to target
+SimpleAttributeMapper.from(User).to(Person).with({:user_name => :email})
 
-* nested attribute mappings
-* composite mappings through lambdas
+# map nested source to target
+# use array; i.e. User#mailing_address -> Address#country -> Country#name
+SimpleAttributeMapper.from(User).to(Person).with({[:mailing_address, :country, :name] => :country_name})
+
+# map composite source to target
+# use lambda
+SimpleAttributeMapper.from(User).to(Person).with({ lambda { |source| "#{source.street}\n#{source.city}, #{source.state}\n#{source.zip}" } => :mailing_address})
+```
 
 ## Contributing
 

data/lib/simple_attribute_mapper/configuration.rb

@@ -0,0 +1,34 @@
+module SimpleAttributeMapper
+  class Configuration
+    def initialize
+      @maps = []
+    end
+
+    attr_reader :maps
+
+    def add_mapping(map)
+      maps.each do |existing_map|
+        if existing_map.source_class == map.source_class && existing_map.target_class == map.target_class
+          raise DuplicateMappingError.new("Map is already configured for '#{map.source_class}' -> '#{map.target_class}'")
+        end
+      end
+
+      maps << map
+    end
+
+    def << map
+      add_mapping(map)
+    end
+
+    def find_mapping(source_class, target_class)
+      maps.select do |map|
+        map.source_class == source_class && map.target_class == target_class
+      end
+    end
+
+    # for testing only
+    def clear
+      @maps = []
+    end
+  end
+end

data/lib/simple_attribute_mapper/configuration_error.rb

@@ -0,0 +1,4 @@
+module SimpleAttributeMapper
+  class ConfigurationError < StandardError
+  end
+end

data/lib/simple_attribute_mapper/duplicate_mapping_error.rb

@@ -0,0 +1,4 @@
+module SimpleAttributeMapper
+  class DuplicateMappingError < StandardError
+  end
+end

data/lib/simple_attribute_mapper/mapper.rb

@@ -10,7 +10,13 @@ module SimpleAttributeMapper
       raise UnMappableError.new("source has no attributes") unless source.respond_to?(:attributes)
 
       target = target_class.new
+      map_matching_attributes(source, target)
+      map_specified_attributes(source, target)
 
+      target
+    end
+
+    def map_matching_attributes(source, target)
       source.attributes.each do |attribute|
         attribute_writer = "#{attribute[0]}=".to_sym
         attribute_value = attribute[1]
@@ -19,16 +25,41 @@ module SimpleAttributeMapper
           target.send(attribute_writer, attribute_value)
         end
       end
+    end
 
+    def map_specified_attributes(source, target)
       mappings.each do |source_attribute, target_attribute|
         attribute_writer = "#{target_attribute}=".to_sym
-        attribute_value = source.send(source_attribute)
-        # puts attribute_writer
-        # puts attribute_value
+        attribute_value = resolve_attribute_value(source_attribute, source)
+        # puts "#{attribute_writer} - #{attribute_value}"
         target.send(attribute_writer, attribute_value)
       end
+    end
 
-      target
+    def resolve_attribute_value(mapping_key, source)
+      if mapping_key.is_a?(Symbol)
+        source.send(mapping_key)
+      elsif mapping_key.is_a?(Array)
+        resolve_nested_value(mapping_key, source)
+      elsif mapping_key.is_a?(Proc)
+        mapping_key.call(source)
+      else
+        raise "Fatal, mapping for '#{mapping_key}' is unknown"
+      end
     end
+
+    def resolve_nested_value(mapping_key, source)
+      root_key = mapping_key.shift
+      current = source.send(root_key)
+
+      mapping_key.each do |nested|
+        value = current.send(nested)
+        if nested == mapping_key.last
+          return value
+        end
+        current = value
+      end
+    end
+
   end
 end

data/lib/simple_attribute_mapper/version.rb

@@ -1,3 +1,3 @@
 module SimpleAttributeMapper
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/simple_attribute_mapper.rb

@@ -1,14 +1,36 @@
 require "simple_attribute_mapper/version"
 require "simple_attribute_mapper/mapper"
+require "simple_attribute_mapper/configuration_error"
+require "simple_attribute_mapper/duplicate_mapping_error"
 require "simple_attribute_mapper/un_mappable_error"
 require "simple_attribute_mapper/map"
+require "simple_attribute_mapper/configuration"
 
 module SimpleAttributeMapper
+  class << self
+    attr_accessor :configuration
+  end
+
+  def self.configure
+    self.configuration ||= Configuration.new
+    yield(configuration)
+  end
+
   def self.from(source_class)
     Map.new(source_class)
   end
 
   def self.map(source_instance, target_class)
-    raise "TODO: implement"
+    if self.configuration.maps.length == 0
+      raise ConfigurationError.new("There are no mappings configured, check the documentation for configuration steps")
+    end
+
+    mappings = configuration.find_mapping(source_instance.class, target_class)
+    if mappings.length == 0
+      raise ConfigurationError.new("There are no mappings configured for '#{source_instance.class}' -> '#{target_class}'")
+    end
+
+    mapper = Mapper.new(mappings[0].mappings)
+    mapper.map(source_instance, target_class)
   end
 end

data/simple_attribute_mapper.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |gem|
   gem.version       = SimpleAttributeMapper::VERSION
   gem.authors       = ["Jesse House"]
   gem.email         = ["jesse.house@gmail.com"]
-  gem.description   = %q{Maps attribute values from one object to another}
+  gem.description   = %q{Maps attribute values from one object to another. See the README on github for more information}
   gem.summary       = %q{See the README for more information}
   gem.homepage      = "https://github.com/house9/simple_attribute_mapper"
 

data/spec/simple_attribute_mapper_spec.rb

@@ -1,6 +1,95 @@
 require 'spec_helper'
 
 describe SimpleAttributeMapper do
+  before(:each) { SimpleAttributeMapper.configure { |config| config.clear } }
+
+  describe "map" do
+    class Foo
+      include Virtus
+
+      attribute :foo, String
+      attribute :abc, String
+      attribute :source_baz, String
+    end
+
+    class Bar
+      include Virtus
+
+      attribute :bar, String
+      attribute :abc, String
+      attribute :target_baz, String
+    end
+
+    let(:source) { Foo }
+    let(:target) { Bar }
+
+    it "raises when no mappings" do
+      maps = []
+      SimpleAttributeMapper.configuration.stub(:maps).and_return(maps)
+      instance = source.new(foo: "FOO", abc: "ABC")
+      expect { SimpleAttributeMapper.map(instance, target) }.to raise_error(SimpleAttributeMapper::ConfigurationError)
+    end
+
+    it "raises when no mappings for specified mapping" do
+      maps = [ SimpleAttributeMapper.from(source).to(target).with({source_baz: :target_baz}) ]
+      SimpleAttributeMapper.configuration.stub(:maps).and_return(maps)
+      instance = source.new(foo: "FOO", abc: "ABC")
+      new_target = Struct.new(:abc)
+      expect { SimpleAttributeMapper.map(instance, new_target) }.to raise_error(SimpleAttributeMapper::ConfigurationError)
+    end
+
+    it "maps" do
+      maps = [ SimpleAttributeMapper.from(source).to(target).with({source_baz: :target_baz}) ]
+      SimpleAttributeMapper.configuration.stub(:maps).and_return(maps)
+      source_instance = source.new(foo: "FOO", abc: "ABC", source_baz: "BAZ")
+      target_instance = SimpleAttributeMapper.map(source_instance, target)
+      target_instance.bar.should be_nil
+      target_instance.abc.should == "ABC"
+      target_instance.target_baz.should == "BAZ"
+    end
+  end
+
+  describe "configure" do
+    describe "add_mapping" do
+      let(:source) { Struct.new(:foo, :xyz) }
+      let(:target) { Struct.new(:bar, :abc) }
+
+      it "adds to the configured maps" do
+        SimpleAttributeMapper.configure do |config|
+          config.add_mapping(SimpleAttributeMapper.from(source).to(target))
+        end
+
+        SimpleAttributeMapper.configuration.maps.length.should == 1
+      end
+
+      it "raises when adding duplicates" do
+        expect do
+          SimpleAttributeMapper.configure do |config|
+            config.add_mapping(SimpleAttributeMapper.from(source).to(target))
+            config.add_mapping(SimpleAttributeMapper.from(source).to(target))
+          end
+        end.to raise_error(SimpleAttributeMapper::DuplicateMappingError)
+      end
+    end
+
+    context "builds the mappings" do
+      let(:source)  { Struct.new(:foo, :xyz) }
+      let(:target1) { Struct.new(:bar, :abc) }
+      let(:target2) { Struct.new(:baz)       }
+      let(:target3) { Struct.new(:foo, :xyz) }
+
+      it "is built" do
+        SimpleAttributeMapper.configure do |config|
+          config << SimpleAttributeMapper.from(source).to(target1).with({foo: :bar}).with(xyz: :abc)
+          config << SimpleAttributeMapper.from(source).to(target2).with({foo: :baz})
+          config << SimpleAttributeMapper.from(source).to(target3)
+        end
+        SimpleAttributeMapper.configuration.maps.length.should == 3
+        SimpleAttributeMapper.configuration.maps[0].should be_an_instance_of(SimpleAttributeMapper::Map)
+      end
+    end
+  end
+
   describe "from" do
     it "returns map" do
       source = Struct.new(:foo)
@@ -46,12 +135,31 @@ describe SimpleAttributeMapper::Mapper do
   end
 
   describe "map" do
+    class Country
+      include Virtus
+
+      attribute :name, String
+    end
+
+    class Address
+      include Virtus
+
+      attribute :street, String
+      attribute :city, String
+      attribute :state, String
+      attribute :zip, String
+      attribute :country, Country
+    end
+
     class Foo
       include Virtus
 
       attribute :baz, String
       attribute :foo, String
       attribute :abc, String
+      attribute :address, Address
+      attribute :first_name, String
+      attribute :last_name, String
     end
 
     class Bar
@@ -59,6 +167,9 @@ describe SimpleAttributeMapper::Mapper do
 
       attribute :baz, String
       attribute :xyz, String
+      attribute :city, String
+      attribute :country_name, String
+      attribute :full_name, String
     end
 
     it "raises error when no source has no attributes" do
@@ -72,6 +183,31 @@ describe SimpleAttributeMapper::Mapper do
       bar.baz.should == "BAZ"
     end
 
+    context "mapping nested attributes" do
+      it "maps 1 level deep" do
+        mapper = SimpleAttributeMapper::Mapper.new({[:address, :city] => :city})
+        foo = Foo.new({baz: "BAZ", address: Address.new(city: "Foo City")})
+        bar = mapper.map(foo, Bar)
+        bar.city.should == "Foo City"
+      end
+
+      it "goes deeper" do
+        mapper = SimpleAttributeMapper::Mapper.new({[:address, :country, :name] => :country_name})
+        foo = Foo.new(baz: "BAZ", address: Address.new(country: Country.new(name: "Foo Country")))
+        bar = mapper.map(foo, Bar)
+        bar.country_name.should == "Foo Country"
+      end
+    end
+
+    context "composite mapping" do
+      it "maps first and last to full name" do
+        mapper = SimpleAttributeMapper::Mapper.new({ lambda { |source| "#{source.first_name} #{source.last_name}" } => :full_name})
+        foo = Foo.new(first_name: "Frank", last_name: "Risso")
+        bar = mapper.map(foo, Bar)
+        bar.full_name.should == "Frank Risso"
+      end
+    end
+
     it "does not map when no target attribute" do
       mapper = SimpleAttributeMapper::Mapper.new
       foo = Foo.new({baz: "BAZ", foo: "FOO"})
@@ -88,12 +224,4 @@ describe SimpleAttributeMapper::Mapper do
   end
 end
 
-describe "Building a mapping" do
-  let(:source) { Struct.new(:foo) }
-  let(:target) { Struct.new(:bar) }
 
-  it "is built" do
-    map = SimpleAttributeMapper.from(source).to(target).with({foo: :bar}).with(xyz: :abc)
-    map.should be_an_instance_of(SimpleAttributeMapper::Map)
-  end
-end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: simple_attribute_mapper
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-24 00:00:00.000000000 Z
+date: 2012-12-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -43,7 +43,8 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: Maps attribute values from one object to another
+description: Maps attribute values from one object to another. See the README on github
+  for more information
 email:
 - jesse.house@gmail.com
 executables: []
@@ -56,6 +57,9 @@ files:
 - README.md
 - Rakefile
 - lib/simple_attribute_mapper.rb
+- lib/simple_attribute_mapper/configuration.rb
+- lib/simple_attribute_mapper/configuration_error.rb
+- lib/simple_attribute_mapper/duplicate_mapping_error.rb
 - lib/simple_attribute_mapper/map.rb
 - lib/simple_attribute_mapper/mapper.rb
 - lib/simple_attribute_mapper/un_mappable_error.rb