karta 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 231b33f0743a4ef1e663dd75c255b172f99d30f1
+  data.tar.gz: 081df11b8bd73cc4ca3c9ba8b52ed98e91b79221
+SHA512:
+  metadata.gz: 7dbf32d707430e58f73cdd13fc91420ed11902bd866c361e50713c73a90b883145bd7451738bd57050df219a4c80b96fb08b696145c1b0c0bb6d16a0499b2b44
+  data.tar.gz: d694e2de81f5088196ae1b9a56859e36f001c43f77679a6fda2df234010f9658cee79329ec92ecbea20bf84fcc914849362c46f1dacb193090702fb11bbe0c64

data/.gitignore

@@ -0,0 +1,16 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+/ideas/
+.byebug_history

data/.reek

@@ -0,0 +1,3 @@
+exclude_paths:
+  - ideas
+  - spec

data/.rspec

@@ -0,0 +1,2 @@
+--format Fuubar
+--color

data/.rubocop.yml

@@ -0,0 +1,3 @@
+AllCops:
+  Exclude:
+    - 'ideas/**/*'

data/.ruby-gemset

@@ -0,0 +1 @@
+karta

data/.ruby-version

@@ -0,0 +1 @@
+2.3.1

data/.yardopts

@@ -0,0 +1,3 @@
+lib/**/*.rb
+-
+LICENSE

data/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in karta.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2016 Samuel Nilsson
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,106 @@
+# Karta
+
+Karta is a very light-weight Ruby library that makes it easy to create mapper objects in a Ruby application. The mapper object makes it easy to map or transform one object into an other. The main use case is to transform data objects from an domain to another domain, e.g. map a `Twitter::User` to `User`. Instead of having to, for example, define a method `#from_twitter_user` on the `User` class which sets all attributes correctly a mapper object is created which defines all mappings.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'karta'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install karta
+
+## Usage
+
+### Setting up a mapper
+The main functionality of Karta is used by letting a class inherit from `Karta::Mapper`. By doing so the class gets a `#map` method which will run all methods starting with `map_` with the two objects as arguments.
+
+##### Example
+```ruby
+class MyTwitterMapper < Karta::Mapper
+  def map_email(twitter_user, user)
+    user.email = twitter_user.twitter_email
+  end
+
+  def map_username(twitter_user, user)
+    user.username = twitter_user.twitter_handle.gsub('@', '')
+  end
+end
+
+# Mapping from one instance to another, overriding
+# values if already set
+twitter_user = ...
+user = ...
+mapped_user = MyTwitterMapper.new.map(from: twitter_user, to: user)
+
+# Mapping from an instance to a class, will return
+# a new instance of the class
+twitter_user = ...
+user = MyTwitterMapper.new.map(from: twitter_user, to: User)
+
+# Using class method (which instantiates before running map on the instance)
+twitter_user = ...
+user = MyTwitterMapper.map(from: twitter_user, to: User)
+```
+
+### Using the mapper registry
+To simplify cases when an application has several mappers it is possible to register mappers and then only use `Karta.map` to map between two objects.
+
+##### Example
+
+```ruby
+class MyMapper < Karta::Mapper
+  # map methods...
+end
+
+Karta.register_mapper MyMapper, from_klass: Twitter::User, to_klass: User
+
+# There is an option to not have to specify from and to class
+# when registering the mapper. This relies on reflection and
+# requires the mapper to have a class name on the correct format
+# (`[from class]To[to class]Mapper`) for example `FooToBarMapper`.
+class FooToBarMapper < Karta::Mapper
+  # map methods
+end
+
+# Register mapper with from_klass = Foo and to_klass = Bar
+Karta.register_mapper FooToBarMapper
+
+# Using Karta.map to map between two objects
+twitter_user = ...
+user = Karta.map(from: twitter_user, to: User)
+
+foo = ...
+bar = Karta.map(from: foo, to Bar)
+```
+
+### One to one mappings
+Sometimes you have fields that could be mapped directly without performing any transformations instead of having to define mapping methods for each you can use `one_to_one_mapping :attr`.
+
+##### Example
+
+```ruby
+class FooToBarMapper < Karta::Mapper
+  one_to_one_mapping :email
+end
+
+foo = ...
+bar = FooToBarMapper.map(from: foo, to Bar)
+puts foo.email == bar.email # => true
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/samuel02/karta/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+# frozen_string_literal: true
+require 'bundler/gem_tasks'

data/karta.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+# frozen_string_literal: true
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'karta/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'karta'
+  spec.version       = Karta::VERSION
+  spec.authors       = ['Samuel Nilsson']
+  spec.email         = ['mail@samuelnilsson.me']
+  spec.summary       = 'A simple Ruby gem for creating mappers which map one '\
+                       'object to another.'
+  spec.homepage      = ''
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.7'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.5'
+  spec.add_development_dependency 'byebug', '~> 9.0'
+  spec.add_development_dependency 'rubocop', '~> 0.46.0'
+  spec.add_development_dependency 'simplecov', '~> 0.12.0'
+  spec.add_development_dependency 'fuubar', '~> 2.2'
+end

data/lib/karta.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+require 'karta/version'
+require 'karta/mapper_registry'
+require 'karta/error'
+require 'karta/mapper'
+
+# The module that contains everything relating to Karta
+#
+# @author Samuel Nilsson <mail@samuelnilsson.me>
+module Karta
+  # Holds the global registry of mappers
+  #
+  # @return [MapperRegistry] the mapper registry
+  def self.mapper_registry
+    @mapper_registry ||= MapperRegistry.new
+  end
+
+  # Register a new mapper to the registry
+  #
+  # @param mapper [Karta::Mapper] the mapper to be registered
+  # @param from_klass [Class] the class the mapper is supposed to map from
+  # @param to_klass [Class] the class the mapper is supposed to map to
+  #
+  # @return [MapperRegistry]
+  def self.register_mapper(mapper, from_klass: nil, to_klass: nil)
+    mapper_registry.register(mapper: mapper,
+                             from_klass: from_klass,
+                             to_klass: to_klass)
+  end
+
+  # Map an object to another using a registered mapper. Returns a new instance
+  # of the mapped object.
+  #
+  # @param from [Object] the object to map from
+  # @param to [Object, Class] the object or class to map to
+  #
+  # @raise [ArgumentError] if trying to map from a class rather than an instance
+  #
+  # @return [Object] a new instance of the same type as `to`
+  def self.map(from:, to:)
+    to, to_klass, from, from_klass = *_handle_map_args(from, to)
+
+    mapper_registry.find(from_klass: from_klass, to_klass: to_klass)
+                   .map(from: from, to: to)
+  end
+
+  # Map an object to another using a registered mapper. Performs the mapping
+  # "in place" and thus modifies the 'to' object and overrides attributes.
+  #
+  # @param from [Object] the object to map from
+  # @param to [Object, Class] the object or class to map to
+  #
+  # @raise [ArgumentError] if trying to map from a class rather than an instance
+  #
+  # @return [Object] returns modified version of 'to'
+  def self.map!(from:, to:)
+    to, to_klass, from, from_klass = *_handle_map_args(from, to)
+
+    mapper_registry.find(from_klass: from_klass, to_klass: to_klass)
+                   .map!(from: from, to: to)
+  end
+
+  # @api private
+  def self._handle_map_args(from, to)
+    raise ArgumentError, 'cannot map from a class' if from.is_a?(Class)
+    to_klass = to.is_a?(Class) ? to : to.class
+    [to, to_klass, from, from.class]
+  end
+end

data/lib/karta/error.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+module Karta
+  # Basic class for exceptions in Karta
+  class Error < StandardError; end
+
+  # Exception for case when a mapper cannot be found
+  class MapperNotFoundError < Error
+    def initialize(from, to)
+      super("no mapper found (#{from} → #{to})")
+    end
+  end
+
+  # Exception for case when a mapper has an invalid name
+  class InvalidNameError < Error
+    def initialize
+      super('mapper name must be on format [Foo]To[Bar]Mapper')
+    end
+  end
+end

data/lib/karta/mapper.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+module Karta
+  # Contains the basic functionality for a mapper object,
+  # the class is meant to be inherited by a mapper class
+  # in order to get the `#map method as well as being able
+  # to specify one-to-one mappings
+  class Mapper
+    # Maps an object to another using all mapping methods defined on the mapper.
+    # Mapping methods are defined as "one-to-one mappings" by using
+    # `.one_to_one_mapping`or by defining methods with names starting with
+    # 'map_'. The mapping methods are supposed to take the object which it is
+    # mapping from as well as the object which it should map into.
+    #
+    # @param from [Object] the object to map from
+    # @param to [Object, Class] the object or class to map to
+    #
+    # @return [Object] a new instance of the same type as `to`
+    def map(from:, to:)
+      to_klass = to.is_a?(Class) ? to : to.class
+      _map(from, to_klass.new)
+    end
+
+    # Maps an object to another using all mapping methods defined on the mapper.
+    # see #map
+    #
+    # @param from [Object] the object to map from
+    # @param to [Object, Class] the object or class to map to
+    #
+    # @return [Object] a new instance of the same type as `to`
+    def map!(from:, to:)
+      to = to.new if to.is_a?(Class)
+      _map(from, to)
+    end
+
+    # Find all mapping methods defined on the mapper.
+    #
+    # @return [Array<Symbol>] names of all methods beginning with `map_`
+    def self.mapping_methods
+      public_instance_methods(true).grep(/^map_/)
+    end
+
+    # Defines a one-to-one mapping on the mapper as a method.
+    #
+    # A one-to-one-mapping is a mapping where the attribute names are equal
+    # and no transformation is supposed to take place. E.g. `foo.id = bar.id`.
+    def self.one_to_one_mapping(attr)
+      define_method("map_#{attr}") do |from, to|
+        to.send("#{attr}=", from.send(attr))
+      end
+    end
+
+    # Instantiates a mapper and runs the `#map` method
+    #
+    # @param from [Object] the object to map from
+    # @param to [Object, Class] the object or class to map to
+    #
+    # @return [Object] a new instance of the same type as `to`
+    def self.map(from:, to:)
+      new.map(from: from, to: to)
+    end
+
+    # Instantiates a mapper and runs the `#map!` method
+    #
+    # @param from [Object] the object to map from
+    # @param to [Object, Class] the object or class to map to
+    #
+    # @return [Object] a new instance of the same type as `to`
+    def self.map!(from:, to:)
+      new.map!(from: from, to: to)
+    end
+
+    private
+
+    def _map(from, to)
+      self.class.mapping_methods.each { |meth| send(meth, from, to) }
+      to
+    end
+  end
+end

data/lib/karta/mapper_registry.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+module Karta
+  # Simple collection class for mappers
+  class MapperRegistry
+    attr_reader :mappers
+
+    def initialize
+      @mappers = []
+    end
+
+    # Register a mapper to the registry.
+    #
+    # If no from_klass or to_klass are specified it will try to parse this
+    # from the class name of the mapper. This assumes that the class name
+    # of the mapper is on the form `[from class]To[to class]Mapper`, e.g.
+    # `FooToBarMapper`. For obvious reasons this makes it hard to handle
+    # cases where one of the classes is namespaced, e.g. `Baz::Bar`. For
+    # those cases the `from_klass` and `to_klass` must be specified.
+    #
+    # @param mapper [Karta::Mapper] the mapper to register
+    # @param from_klass [Class] the class the mapper is supposed to map from
+    # @param to_klass [Class] the class the mapper is supposed to map to
+    #
+    # @raise [InvalidNameError] if no `from_klass` or `to_klass` is specified
+    #   and the class name of the mapper does not follow the correct format.
+    #
+    # @return [MapperRegistry] the mapper registry after the mapper has been
+    #   added
+    def register(mapper:, from_klass: nil, to_klass: nil)
+      unless from_klass && to_klass
+        from_klass, to_klass = *klasses_from_class_name(mapper.to_s)
+      end
+
+      mappers.push(mapper: mapper,
+                   from_klass: from_klass,
+                   to_klass: to_klass)
+
+      self
+    end
+
+    # Find a mapper in the registry
+    #
+    # @param from_klass [Class] the class the mapper is supposed to map from
+    # @param to_klass [Class] the class the mapper is supposed to map to
+    #
+    # @raise [MapperNotFoundError] if no applicable mapper is found
+    #
+    # @return [Karta::Mapper] the found mapper
+    def find(from_klass:, to_klass:)
+      mappers.find(lambda do
+        raise MapperNotFoundError.new(from_klass, to_klass)
+      end) do |mapper|
+        mapper[:from_klass] == from_klass && mapper[:to_klass] == to_klass
+      end.fetch(:mapper)
+    end
+
+    private
+
+    def klasses_from_class_name(klass_name)
+      raise InvalidNameError unless klass_name =~ /.*To.*Mapper/
+
+      klass_name.gsub('Mapper', '')
+                .split('To')
+                .map(&Kernel.method(:const_get))
+    end
+  end
+end

data/lib/karta/version.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+module Karta
+  VERSION = '1.0.1'
+end

data/spec/acceptance/map_instance_to_class_spec.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+describe 'mapping from one instance to a class' do
+  before do
+    define_klass 'Foo', attrs: [:id, :foo_name]
+    define_klass 'Bar', attrs: [:id, :name]
+
+    define_klass 'FooToBarMapper', base: Karta::Mapper do
+      one_to_one_mapping :id
+
+      def map_name(foo, bar)
+        bar.name = foo.foo_name
+      end
+    end
+  end
+
+  let(:foo) { Foo.new(id: 1, foo_name: 'Foo') }
+
+  describe 'using a mapper object' do
+    subject { FooToBarMapper.map(from: foo, to: Bar) }
+
+    it 'creates a new instance and maps all fields defined in the mapper' do
+      expect(subject.class).to eq Bar
+      expect(subject.id).to    eq foo.id
+      expect(subject.name).to  eq foo.foo_name
+    end
+  end
+
+  describe 'using the mapper registry' do
+    before do
+      Karta.register_mapper FooToBarMapper
+    end
+
+    subject { Karta.map(from: foo, to: Bar) }
+
+    it 'creates a new instance and maps all fields defined in the mapper' do
+      expect(subject.class).to eq Bar
+      expect(subject.id).to    eq foo.id
+      expect(subject.name).to  eq foo.foo_name
+    end
+  end
+end

data/spec/acceptance/map_instance_to_instance_spec.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+describe 'mapping from one instance to another' do
+  before do
+    define_klass 'Foo', attrs: [:id, :foo_name]
+    define_klass 'Bar', attrs: [:id, :name]
+
+    define_klass 'FooToBarMapper', base: Karta::Mapper do
+      one_to_one_mapping :id
+
+      def map_name(foo, bar)
+        bar.name = foo.foo_name
+      end
+    end
+  end
+
+  let(:foo) { Foo.new(id: 1, foo_name: 'Foo') }
+  let(:bar) { Bar.new(id: 2, name: '') }
+
+  describe 'using a mapper object' do
+    subject { FooToBarMapper.map!(from: foo, to: bar) }
+
+    it 'maps all fields defined in the mapper' do
+      expect(subject.class).to eq Bar
+      expect(subject.id).to    eq foo.id
+      expect(subject.name).to  eq foo.foo_name
+      expect(bar.id).to        eq 1
+      expect(bar.name).to      eq 'Foo'
+    end
+  end
+
+  describe 'using the mapper registry' do
+    before do
+      Karta.register_mapper FooToBarMapper
+    end
+
+    subject { Karta.map!(from: foo, to: bar) }
+
+    it 'maps all fields defined in the mapper' do
+      expect(subject.class).to eq Bar
+      expect(subject.id).to    eq foo.id
+      expect(subject.name).to  eq foo.foo_name
+    end
+  end
+end

data/spec/karta/mapper_registry_spec.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+describe Karta::MapperRegistry do
+  describe '#register' do
+    subject(:mapper_registry) { Karta::MapperRegistry.new }
+
+    context 'when from_klass or to_klass are not specified' do
+      context 'when the class name of the mapper follows the correct format' do
+        before do
+          define_klass 'Foo'
+          define_klass 'Bar'
+          define_klass 'FooToBarMapper', base: Karta::Mapper
+        end
+
+        it 'parses the class names from the mapper name and adds the mapper' do
+          mapper_registry.register(mapper: FooToBarMapper)
+
+          expect(mapper_registry.mappers.count).to eq 1
+
+          mapper = mapper_registry.mappers.first
+
+          expect(mapper[:mapper]).to     eq FooToBarMapper
+          expect(mapper[:from_klass]).to eq Foo
+          expect(mapper[:to_klass]).to   eq Bar
+        end
+      end
+
+      context 'when the class name of the mapper contains a namespaced class' do
+        before do
+          define_klass 'Baz'
+          define_klass 'Baz::Foo'
+          define_klass 'Bar'
+          define_klass 'Baz::FooToBarMapper', base: Karta::Mapper
+        end
+
+        it 'parses the class names from the mapper name and adds the mapper' do
+          mapper_registry.register(mapper: Baz::FooToBarMapper)
+
+          expect(mapper_registry.mappers.count).to eq 1
+
+          mapper = mapper_registry.mappers.first
+
+          expect(mapper[:mapper]).to     eq Baz::FooToBarMapper
+          expect(mapper[:from_klass]).to eq Baz::Foo
+          expect(mapper[:to_klass]).to   eq Bar
+        end
+      end
+
+      context "when the class name of the mapper isn't on the correct format" do
+        before do
+          define_klass 'CustomMapper', base: Karta::Mapper
+        end
+
+        it 'raises an error' do
+          expect do
+            mapper_registry.register(mapper: CustomMapper)
+          end.to raise_error Karta::InvalidNameError,
+                             'mapper name must be on format [Foo]To[Bar]Mapper'
+        end
+      end
+    end
+
+    context 'when from_klass and to_klass are specified' do
+      before do
+        define_klass 'Foo'
+        define_klass 'Bar'
+        define_klass 'CustomMapper', base: Karta::Mapper
+      end
+
+      it 'adds the mapper to the registry' do
+        mapper_registry.register mapper: CustomMapper,
+                                 from_klass: Foo,
+                                 to_klass: Bar
+
+        expect(mapper_registry.mappers.count).to eq 1
+
+        mapper = mapper_registry.mappers.first
+
+        expect(mapper[:mapper]).to     eq CustomMapper
+        expect(mapper[:from_klass]).to eq Foo
+        expect(mapper[:to_klass]).to   eq Bar
+      end
+    end
+  end
+
+  describe '#find' do
+    subject(:mapper_registry) { Karta::MapperRegistry.new }
+
+    context 'when an appropriate mapper exists' do
+      before do
+        define_klass 'Foo'
+        define_klass 'Bar'
+        define_klass 'FooToBarMapper', base: Karta::Mapper
+
+        allow(mapper_registry).to\
+          receive(:mappers).and_return([{
+                                         mapper: FooToBarMapper,
+                                         from_klass: Foo,
+                                         to_klass: Bar
+                                       }])
+      end
+
+      it 'returns the mapper from the registry' do
+        expect(
+          mapper_registry.find(from_klass: Foo, to_klass: Bar)
+        ).to eq FooToBarMapper
+      end
+    end
+
+    context 'when no appropriate mapper can be found' do
+      it 'raises an error with a good error message' do
+        expect do
+          mapper_registry.find(from_klass: Integer, to_klass: Array)
+        end.to raise_error Karta::MapperNotFoundError,
+                           'no mapper found (Integer → Array)'
+      end
+    end
+  end
+end

data/spec/karta/mapper_spec.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+describe Karta::Mapper do
+  describe '#map' do
+    before do
+      define_klass 'Foo'
+      define_klass 'Bar'
+    end
+
+    let!(:mapper) do
+      define_klass('MyMapper', base: Karta::Mapper).new
+    end
+
+    before do
+      allow(MyMapper).to receive(:mapping_methods).and_return([:method])
+    end
+
+    context 'when to is an instance' do
+      let(:from) { Foo.new }
+      let(:to)   { Bar.new }
+
+      it 'calls all mapping methods with from and to \
+          and returns new instance' do
+        expect(mapper).to receive(:send).with(:method, from, Bar)
+        mapper.map(from: from, to: to)
+      end
+    end
+
+    context 'when to is a class' do
+      let(:from) { Foo.new }
+      let(:to)   { Bar }
+
+      it 'calls all mapping methods with from and a to instance' do
+        expect(mapper).to receive(:send).with(:method, from, to)
+
+        mapper.map(from: from, to: to)
+      end
+    end
+  end
+
+  describe '#map!' do
+    before do
+      define_klass 'Foo'
+      define_klass 'Bar'
+    end
+
+    let!(:mapper) do
+      define_klass('MyMapper', base: Karta::Mapper).new
+    end
+
+    before do
+      allow(MyMapper).to receive(:mapping_methods).and_return([:method])
+    end
+
+    context 'when to is an instance' do
+      let(:from) { Foo.new }
+      let(:to)   { Bar.new }
+
+      it 'calls all mapping methods with from and to \
+          and modifies to in place' do
+        expect(mapper).to receive(:send).with(:method, from, to)
+        mapper.map!(from: from, to: to)
+      end
+    end
+
+    context 'when to is a class' do
+      let(:from) { Foo.new }
+      let(:to)   { Bar }
+
+      it 'calls all mapping methods with from and a to instance' do
+        expect(mapper).to receive(:send).with(:method, from, to)
+
+        mapper.map!(from: from, to: to)
+      end
+    end
+  end
+
+  describe '#mapping_methods' do
+    let(:mapper_klass) do
+      define_klass 'MyMapper', base: Karta::Mapper do
+        def map_foo; end
+
+        def bar; end
+
+        private
+
+        def map_baz; end
+      end
+    end
+
+    it 'finds all instance methods that starts with map_' do
+      expect(mapper_klass.mapping_methods).to     include :map_foo
+      expect(mapper_klass.mapping_methods).to_not include :bar
+    end
+
+    it 'skips private methods' do
+      expect(mapper_klass.private_method_defined?(:map_baz)).to \
+        be true
+      expect(mapper_klass.mapping_methods).to_not \
+        include :map_baz
+    end
+  end
+
+  describe '.one_to_one_mapping' do
+    let(:mapper) do
+      define_klass 'Foo', base: Karta::Mapper do
+        one_to_one_mapping :foo
+      end.new
+    end
+
+    it 'defines a mapping method on the instance' do
+      expect(mapper).to respond_to :map_foo
+    end
+  end
+
+  describe '.map' do
+    let(:mapper) { double('mapper') }
+    let(:from)   { double('from') }
+    let(:to)     { double('to') }
+
+    let(:mapper_klass) { define_klass 'Mapper', base: Karta::Mapper }
+
+    it 'instantiates self and runs the map method on the instance' do
+      expect(mapper_klass).to receive(:new).and_return(mapper)
+      expect(mapper).to       receive(:map).with(from: from, to: to)
+
+      mapper_klass.map(from: from, to: to)
+    end
+  end
+end

data/spec/karta_spec.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+describe Karta do
+  describe '.mapper_registry' do
+    context 'when a mapper registry has already been initialized' do
+      let(:mapper_registry) { double('mapper_registry') }
+
+      it 'returns the mapper registry' do
+        Karta.instance_variable_set('@mapper_registry', mapper_registry)
+        expect(Karta.mapper_registry).to eq mapper_registry
+      end
+    end
+
+    context 'when no mapper registry has been initialized' do
+      it 'initializes the mapper registry to an empty array' do
+        expect(Karta.instance_variable_get('@mapper_registry')).to be_nil
+
+        Karta.mapper_registry
+
+        expect(Karta.instance_variable_get('@mapper_registry')).to \
+          be_a Karta::MapperRegistry
+      end
+    end
+  end
+
+  describe '.register_mapper' do
+    let(:mapper_registry) { double('mapper_registry') }
+    let(:mapper)          { double('mapper') }
+    let(:from_klass)      { double('from_klass') }
+    let(:to_klass)        { double('to_klass') }
+
+    before do
+      expect(Karta).to receive(:mapper_registry).and_return(mapper_registry)
+    end
+
+    it 'registers a mapper' do
+      expect(mapper_registry).to receive(:register)\
+        .with(mapper: mapper, from_klass: from_klass, to_klass: to_klass)
+
+      Karta.register_mapper(mapper, from_klass: from_klass, to_klass: to_klass)
+    end
+  end
+
+  describe '.map' do
+    context 'when trying to map from a class' do
+      let(:foo) { double('foo') }
+
+      before do
+        define_klass 'Bar'
+      end
+
+      it 'raises an ArgumentError' do
+        expect do
+          Karta.map(from: Bar, to: foo)
+        end.to raise_error(ArgumentError, 'cannot map from a class')
+      end
+    end
+
+    context 'when mapping to a class' do
+      let(:mapper)          { double('mapper') }
+      let(:mapper_registry) { double('mapper_registry') }
+      let(:bar)             { double('bar') }
+
+      before do
+        define_klass 'Foo'
+        allow(Karta).to receive(:mapper_registry).and_return(mapper_registry)
+      end
+
+      it 'finds a a mapper and maps' do
+        expect(mapper_registry).to receive(:find).and_return(mapper)
+        expect(mapper).to receive(:map).with(from: bar, to: Foo)
+
+        Karta.map(from: bar, to: Foo)
+      end
+    end
+
+    context 'when mapping to an instance' do
+      let(:mapper)          { double('mapper') }
+      let(:mapper_registry) { double('mapper_registry') }
+      let(:bar)             { double('bar') }
+      let(:foo)             { double('foo') }
+
+      before do
+        allow(Karta).to receive(:mapper_registry).and_return(mapper_registry)
+      end
+
+      it 'performs the mapping and returns a new instance' do
+        expect(mapper_registry).to receive(:find).and_return(mapper)
+        expect(mapper).to receive(:map).with(from: bar, to: foo)
+          .and_return(double('new-foo'))
+
+        result = Karta.map(from: bar, to: foo)
+
+        expect(result).to_not eq foo
+      end
+    end
+  end
+
+  describe '.map!' do
+    context 'when trying to map from a class' do
+      let(:foo) { double('foo') }
+
+      before do
+        define_klass 'Bar'
+      end
+
+      it 'raises an ArgumentError' do
+        expect do
+          Karta.map!(from: Bar, to: foo)
+        end.to raise_error(ArgumentError, 'cannot map from a class')
+      end
+    end
+
+    context 'when mapping to a class' do
+      let(:mapper)          { double('mapper') }
+      let(:mapper_registry) { double('mapper_registry') }
+      let(:bar)             { double('bar') }
+
+      before do
+        define_klass 'Foo'
+        allow(Karta).to receive(:mapper_registry).and_return(mapper_registry)
+      end
+
+      it 'finds a a mapper and maps' do
+        expect(mapper_registry).to receive(:find).and_return(mapper)
+        expect(mapper).to receive(:map!).with(from: bar, to: Foo)
+
+        Karta.map!(from: bar, to: Foo)
+      end
+    end
+
+    context 'when mapping to an instance' do
+      let(:mapper)          { double('mapper') }
+      let(:mapper_registry) { double('mapper_registry') }
+      let(:bar)             { double('bar') }
+      let(:foo)             { double('foo') }
+
+      before do
+        allow(Karta).to receive(:mapper_registry).and_return(mapper_registry)
+      end
+
+      it 'performs the mapping and returns the instance' do
+        expect(mapper_registry).to receive(:find).and_return(mapper)
+        expect(mapper).to receive(:map!).with(from: bar, to: foo)
+          .and_return(foo)
+
+        result = Karta.map!(from: bar, to: foo)
+
+        expect(result).to eq foo
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
+$LOAD_PATH << File.join(File.dirname(__FILE__))
+
+require 'simplecov'
+SimpleCov.start
+
+require 'rubygems'
+require 'rspec'
+require 'byebug'
+
+require 'karta'
+
+Dir['spec/support/**/*.rb'].each { |f| require File.expand_path(f) }
+
+RSpec.configure do |config|
+  config.after do
+    Karta.instance_variables.each do |ivar|
+      Karta.instance_variable_set(ivar, nil)
+    end
+  end
+end

data/spec/support/macros/define_constant.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+module DefineConstantMacros
+  # Simple class used for making flexible objects
+  # in tests
+  class FlexibleObject
+    def initialize(data = {})
+      data.each { |attr, val| instance_variable_set("@#{attr}", val) }
+    end
+  end
+
+  def define_klass(path, attrs: [], base: FlexibleObject, &block)
+    namespace, class_name = *constant_path(path)
+    klass = Class.new(base)
+    namespace.const_set(class_name, klass)
+
+    klass.class_eval do
+      attrs.each { |attr| attr_accessor attr }
+    end
+
+    klass.class_eval(&block) if block_given?
+
+    @defined_constants << path
+    klass
+  end
+
+  def constant_path(constant_name)
+    names = constant_name.split('::')
+    class_name = names.pop
+    namespace = names.inject(Object) { |acc, elem| acc.const_get(elem) }
+    [namespace, class_name]
+  end
+
+  def default_constants
+    @defined_constants ||= []
+  end
+
+  def clear_generated_constants
+    @defined_constants.reverse.each do |path|
+      namespace, class_name = *constant_path(path)
+      namespace.send(:remove_const, class_name)
+    end
+
+    @defined_constants.clear
+  end
+
+  RSpec.configure do |config|
+    config.include DefineConstantMacros
+
+    config.before do
+      default_constants
+    end
+
+    config.after do
+      clear_generated_constants
+    end
+  end
+end

metadata

@@ -0,0 +1,173 @@
+--- !ruby/object:Gem::Specification
+name: karta
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- Samuel Nilsson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-12-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '9.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '9.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.46.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.46.0
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.12.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.12.0
+- !ruby/object:Gem::Dependency
+  name: fuubar
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+description: 
+email:
+- mail@samuelnilsson.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".reek"
+- ".rspec"
+- ".rubocop.yml"
+- ".ruby-gemset"
+- ".ruby-version"
+- ".yardopts"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- karta.gemspec
+- lib/karta.rb
+- lib/karta/error.rb
+- lib/karta/mapper.rb
+- lib/karta/mapper_registry.rb
+- lib/karta/version.rb
+- spec/acceptance/map_instance_to_class_spec.rb
+- spec/acceptance/map_instance_to_instance_spec.rb
+- spec/karta/mapper_registry_spec.rb
+- spec/karta/mapper_spec.rb
+- spec/karta_spec.rb
+- spec/spec_helper.rb
+- spec/support/macros/define_constant.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: A simple Ruby gem for creating mappers which map one object to another.
+test_files:
+- spec/acceptance/map_instance_to_class_spec.rb
+- spec/acceptance/map_instance_to_instance_spec.rb
+- spec/karta/mapper_registry_spec.rb
+- spec/karta/mapper_spec.rb
+- spec/karta_spec.rb
+- spec/spec_helper.rb
+- spec/support/macros/define_constant.rb