yaoc 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 409ba0cb455bbdea76b8dd9f32bd81c5d7d8a6bf
-  data.tar.gz: 37de097336722ccd09c26c44f943a6161355ae9f
+  metadata.gz: 1a3e08de6de1dd93ced77b872cc67f802987d027
+  data.tar.gz: 01fa46d585b98a34f3c13fb118d259b6006a8d58
 SHA512:
-  metadata.gz: 1258d989f4d14f28c806c45daac46516d0277e471906583ad999d68a662b09deb792118fc9675a06b9df50c12ecfa558a1631d5c2226d26009d10c16d485c389
-  data.tar.gz: b3969999352325fe98045f0b2e5d3edd153f1b12915822a93a1b44f776893a2963cf943fed7103462c882b6a845df1c64f1e79404fabbee408dfc85e7956615a
+  metadata.gz: 045204c3589d7c9c683ba014503db36c6dab8165a34abd50a1e7157f1b28445136a7923a62d2b6b2506bdd6276fc2989fc0cfcdb7e6b725c45cafc4e9edcb05d
+  data.tar.gz: 31cd8c25c0f8a7d6dc1ecd960777fd34e1b9d2f3b9cb3b1663673724ae59d6aa4e446efe9730cf625c23e66e9b4af573d71db25cf3c78412efce0aac67577fb8

data/Guardfile

@@ -6,6 +6,8 @@ guard :rspec, all_after_pass: true ,
   
   watch(%r{^spec/.+_spec\.rb$})
 
+  watch('lib/yaoc.rb')  { "spec" }
+
   watch(%r{^lib/(.+)\.rb$})     { |m| "spec/unit/lib/#{m[1]}_spec.rb" }
   watch(%r{^lib/(.+)\.rb$})     { |m| "spec/integration/lib/#{m[1]}_spec.rb" }
 

data/README.md

@@ -53,21 +53,15 @@ mapper = Yaoc::ObjectMapper.new(User, OldUser).tap do |mapper|
 
     rule to: :firstname,
          from: :fullname,
-         converter: ->(source, result){ result.merge({firstname:
-                                                      source.fullname.split().first }) },
-         reverse_converter: ->(source, result){ result.merge({fullname:
-                                                              "#{source.firstname} #{source.lastname}" }) }
+         converter: ->(source, result){ fill_result_with_value(result, :firstname, source.fullname.split().first) },
+         reverse_converter: ->(source, result){ fill_result_with_value(result, :fullname,  "#{source.firstname} #{source.lastname}") }
 
     rule to: :lastname,
          from: :fullname,
-         converter: ->(source, result){ result.merge({lastname:  source.fullname.split().last }) },
+         converter: ->(source, result){ fill_result_with_value(result, :lastname, source.fullname.split().last ) },
          reverse_converter: ->(source, result){ result }
 
     rule to: :id
-
-    # or
-    # rule to: [:id, :foo, :bar, ...], from: [:rid, :rfoo], converter: [->(){}]
-
   end
 end
 
@@ -120,12 +114,12 @@ mapper = Yaoc::ObjectMapper.new(source, reverse_source).tap do |mapper|
 
     rule to: :firstname,
          from: :fullname,
-         converter: ->(source, result){ result.merge({firstname:  source.fullname.split().first }) },
-         reverse_converter: ->(source, result){ result.merge({fullname:  "#{source.firstname} #{source.lastname}" }) }
+         converter: ->(source, result){ fill_result_with_value(result, :firstname,  source.fullname.split().first ) },
+         reverse_converter: ->(source, result){ fill_result_with_value(result, :fullname, "#{source.firstname} #{source.lastname}") }
 
     rule to: :lastname,
          from: :fullname,
-         converter: ->(source, result){ result.merge({lastname:  source.fullname.split().last }) },
+         converter: ->(source, result){ fill_result_with_value(result, :lastname,  source.fullname.split().last) },
          reverse_converter: ->(source, result){ result }
 
     rule to: :id
@@ -169,8 +163,8 @@ mapper = Yaoc::ObjectMapper.new(User3, OldUser3).tap do |mapper|
     rule to: 1,
          from: :fullname,
 
-         converter: ->(source, result){ result[1] = source.fullname.split().first  },
-         reverse_converter: ->(source, result){ result[1] =  "#{source.firstname} #{source.lastname}" }
+         converter: ->(source, result){ fill_result_with_value(result, 1, source.fullname.split().first)  },
+         reverse_converter: ->(source, result){ fill_result_with_value(result, 1,  "#{source.firstname} #{source.lastname}") }
 
     rule to: 2,
          from: :fullname,
@@ -180,6 +174,7 @@ mapper = Yaoc::ObjectMapper.new(User3, OldUser3).tap do |mapper|
 
     rule to: 3, from: :r_role,
          reverse_to: 2, reverse_from: :role
+
   end
 end
 
@@ -200,6 +195,98 @@ puts mapper.dump(new_user3)
 
 ```
 
+### And how to use it with compositions?
+
+```ruby
+
+User4 = Struct.new(:id, :firstname, :lastname, :roles) do
+  def initialize(params={})
+    super()
+
+    params.each do |attr, value|
+      self.public_send("#{attr}=", value)
+    end if params
+  end
+end
+
+OldUser4 = Struct.new(:o_id, :o_firstname, :o_lastname, :o_roles) do
+  def initialize(params={})
+    super()
+
+    params.each do |attr, value|
+      self.public_send("#{attr}=", value)
+    end if params
+  end
+end
+
+
+Role = Struct.new(:id, :name) do
+  def initialize(params={})
+    super()
+
+    params.each do |attr, value|
+      self.public_send("#{attr}=", value)
+    end if params
+  end
+end
+
+OldRole = Struct.new(:o_id, :o_name) do
+  def initialize(params={})
+    super()
+
+    params.each do |attr, value|
+      self.public_send("#{attr}=", value)
+    end if params
+  end
+end
+
+
+role_mapper = Yaoc::ObjectMapper.new(Role, OldRole).tap do |mapper|
+  mapper.add_mapping do
+    fetcher :public_send
+
+    rule to: :id, from: :o_id
+    rule to: :name, from: :o_name
+
+  end
+end
+
+user_mapper = Yaoc::ObjectMapper.new(User4, OldUser4).tap do |mapper|
+  mapper.add_mapping do
+    fetcher :public_send
+
+    rule to: [:id, :firstname, :lastname],
+         from: [:o_id, :o_firstname, :o_lastname]
+
+    rule to: :roles,
+         from: :o_roles,
+         object_converter: role_mapper,
+         is_collection: true
+
+  end
+end
+
+
+old_user4 = OldUser4.new(o_id: 1,
+                         o_firstname: "firstname",
+                         o_lastname:"lastname",
+                         o_roles: [OldRole.new(o_id: 1, o_name: "admin"), OldRole.new(o_id: 2, o_name: "guest")] )
+new_user4 = user_mapper.load(old_user4)
+
+puts old_user4
+puts new_user4
+
+puts user_mapper.dump(new_user4)
+
+#<struct OldUser4 o_id=1, o_firstname="firstname", o_lastname="lastname",
+# o_roles=[#<struct OldRole o_id=1, o_name="admin">, #<struct OldRole o_id=2, o_name="guest">]>
+#<struct User4 id=1, firstname="firstname", lastname="lastname",
+# roles=[#<struct Role id=1, name="admin">, #<struct Role id=2, name="guest">]>
+#<struct OldUser4 o_id=1, o_firstname="firstname", o_lastname="lastname",
+# o_roles=[#<struct OldRole o_id=1, o_name="admin">, #<struct OldRole o_id=2, o_name="guest">]>
+
+```
+
 ## Contributing
 
 1. Fork it ( http://github.com/slowjack2k/yaoc/fork )

data/lib/yaoc/converter_builder.rb

@@ -1,7 +1,56 @@
 module Yaoc
 
+  class NormalizedParameters
+    attr_accessor :to_s, :from_s, :converter_s
+
+    def initialize(to, from, converter, object_converter, is_collection)
+      self.to_s = Array(to)
+      self.from_s = Array(from)
+      self.converter_s = Array(converter)
+
+      object_converter_s = Array(object_converter)
+      is_collection_s = Array(is_collection)
+
+      self.to_s.each_with_index do |to, index|
+        from_s[index] ||= to
+      end
+
+      object_converter_s.each_with_index do |object_converter, index|
+        converter_s[index] = converter_to_proc(to_s[index], from_s[index], object_converter, !!is_collection_s[index])
+      end
+
+    end
+
+    def each
+      return to_enum(__callee__) unless block_given?
+
+      self.to_s.each_with_index do |to, index|
+        yield to, from_s[index] , converter_s[index]
+      end
+    end
+
+    def converter_to_proc(to, from, converter, is_collection)
+      ->(source, result){
+        object_to_convert = source.public_send(fetcher, from)
+        converted_object = nil
+
+        if is_collection
+          converted_object = object_to_convert.map(&converter)
+        else
+          converter_as_proc = converter.to_proc
+          converted_object = converter_as_proc.call(object_to_convert)
+        end
+
+        fill_result_with_value(result, to, converted_object)
+      }
+    end
+
+  end
+
+
   class ConverterBuilder
-    attr_accessor  :build_commands, :command_order, :strategy, :all_commands_applied
+    attr_accessor  :build_commands, :command_order,
+                   :strategy, :all_commands_applied
 
     def initialize(command_order=:recorded_order, fetcher=:fetch)
       self.build_commands = []
@@ -16,15 +65,11 @@ module Yaoc
       apply_commands!
     end
 
-    def rule(to: nil, from: to, converter: nil)
+    def rule(to: nil, from: to, converter: nil, object_converter: nil, is_collection: nil)
       self.all_commands_applied = false
 
-      to_s = Array(to)
-      from_s = Array(from)
-      converter_s = Array(converter)
-
-      to_s.each_with_index do |to, index|
-        build_commands.push  ->{ converter_class.map(to, from_s[index] || to, converter_s[index]) }
+      NormalizedParameters.new(to, from, converter, object_converter, is_collection).each do |to, from, converter|
+        build_commands.push  ->{ converter_class.map(to, from , converter) }
       end
     end
 
@@ -35,9 +80,9 @@ module Yaoc
       build_commands_ordered.each &:call
     end
 
-    def converter(fetch_able)
+    def converter(fetch_able, target_source=nil)
       raise "BuildCommandsNotExecuted" unless self.all_commands_applied?
-      converter_class.new(fetch_able, fetcher)
+      converter_class.new(fetch_able, fetcher, target_source || ->(attrs){ attrs})
     end
 
     def fetcher=(new_fetcher)
@@ -47,10 +92,11 @@ module Yaoc
     protected
 
     def converter_class
-      @converter_class ||= Struct.new(:to_convert, :fetcher) do
-        include MappingBase
+      @converter_class ||= Struct.new(:to_convert, :fetcher, :target_source) do
+        include MappingToClass
+
       end.tap do |new_class|
-        new_class.send(:include, strategy_module)
+        new_class.mapping_strategy = strategy_module
       end
     end
 

data/lib/yaoc/mapping_base.rb

@@ -2,12 +2,30 @@ module Yaoc
   module MappingBase
     include AbstractType
 
-
     def self.included(other)
       other.extend(ClassMethods)
     end
 
-    abstract_method :call
+    def to_proc
+      ->(to_convert){
+        old_to_convert = self.to_convert
+        begin
+          self.to_convert = to_convert
+          call
+        ensure
+          self.to_convert = old_to_convert
+        end
+      }
+    end
+
+    def call
+      self.class.mapping_strategy.call(self)
+    end
+
+    def fill_result_with_value(result, key, value)
+      result.tap{|taped_result| taped_result[key] = value}
+    end
+
 
     def converter_methods
       self.class.converter_methods
@@ -20,7 +38,19 @@ module Yaoc
     module ClassMethods
       include AbstractType
 
-      abstract_method :converter_proc
+      def converter_proc(to, from)
+        -> (to_convert, result){
+          fill_result_with_value(result, to, to_convert.public_send(fetcher, from))
+        }
+      end
+
+      def mapping_strategy=(new_strat)
+        @mapping_strategy = new_strat
+      end
+
+      def mapping_strategy
+        @mapping_strategy
+      end
 
       def map(to, from, block=nil)
         class_private_module(:Mapping).tap do |mod|

data/lib/yaoc/mapping_to_class.rb

@@ -0,0 +1,32 @@
+module Yaoc
+  module MappingToClass
+
+    def self.included(other)
+      other.send(:include, MappingBase)
+      other.send(:include, InstanceMethods)
+    end
+
+    module InstanceMethods
+      def call(*args)
+        create_target(super)
+      end
+
+      def source_method
+        self.target_source.respond_to?(:call) ? :call : :new
+      end
+
+      def create_target(args)
+        if args.is_a? Array
+          self.target_source.send(source_method, *args)
+        else
+          self.target_source.send(source_method, args)
+        end
+      end
+
+      def to_a # wenn included into struct's Array(...) call's to_a
+        [self]
+      end
+    end
+
+  end
+end

data/lib/yaoc/object_mapper.rb

@@ -3,19 +3,17 @@ module Yaoc
   class ObjectMapper
     attr_accessor :load_result_source, :dump_result_source
 
-    def initialize(load_result_source, dump_result_source=->(attrs){ attrs})
-      self.load_result_source = load_result_source.respond_to?(:call) ? load_result_source : ->(*attrs){load_result_source.new(*attrs)}
-      self.dump_result_source = dump_result_source.respond_to?(:call) ? dump_result_source : ->(*attrs){dump_result_source.new(*attrs)}
+    def initialize(load_result_source, dump_result_source=nil)
+      self.load_result_source = load_result_source
+      self.dump_result_source = dump_result_source
     end
 
     def load(fetch_able)
-      converter_result = converter(fetch_able).call()
-      call_constructor(load_result_source, converter_result)
+      converter(fetch_able).call()
     end
 
     def dump(object)
-      converter_result = reverse_converter(object).call()
-      call_constructor(dump_result_source, converter_result)
+      reverse_converter(object).call()
     end
 
     def add_mapping(&block)
@@ -23,34 +21,44 @@ module Yaoc
       apply_commands
     end
 
-    protected
+    def converter(fetch_able=nil)
+      converter_builder.converter(fetch_able, load_result_source)
+    end
 
-    def call_constructor(call_able, args)
-      if args.is_a? Array
-        call_able.call(*args)
-      else
-        call_able.call(args)
-      end
+    def reverse_converter(fetch_able=nil)
+      reverse_converter_builder.converter(fetch_able, dump_result_source)
     end
 
+    protected
+
     def apply_commands
       converter_builder.apply_commands!
       reverse_converter_builder.apply_commands!
     end
 
     def rule(to: nil, from: to, converter: nil,
-             reverse_to: from, reverse_from: to, reverse_converter: nil)
+             reverse_to: from,
+             reverse_from: to,
+             reverse_converter: nil,
+             object_converter: nil,
+             is_collection: nil)
+
+      object_converter = Array(object_converter)
 
       converter_builder.rule(
           to: to,
           from: from,
           converter: converter,
+          object_converter: object_converter.map(&:converter),
+          is_collection: is_collection,
       )
 
       reverse_converter_builder.rule(
           to: reverse_to,
           from: reverse_from,
           converter: reverse_converter,
+          object_converter: object_converter.map(&:reverse_converter),
+          is_collection: is_collection,
       )
     end
 
@@ -70,14 +78,6 @@ module Yaoc
       reverse_converter_builder.strategy = new_strategy
     end
 
-    def converter(fetch_able)
-      converter_builder.converter(fetch_able)
-    end
-
-    def reverse_converter(fetch_able)
-      reverse_converter_builder.converter(fetch_able)
-    end
-
     def converter_builder
       @converter_builder ||= Yaoc::ConverterBuilder.new()
     end

data/lib/yaoc/strategies/to_array_mapping.rb

@@ -1,25 +1,15 @@
 module Yaoc
   module Strategies
     module ToArrayMapping
-      def self.included(other)
-        other.extend(ClassMethods)
-      end
 
-      def call
+      def self.call(conv_object)
         [].tap do |result|
-          converter_methods.each do |method_name|
-            self.public_send(method_name, to_convert, result)
+          conv_object.converter_methods.each do |method_name|
+            conv_object.public_send(method_name, conv_object.to_convert, result)
           end
         end
       end
 
-      module ClassMethods
-        def converter_proc(to, from)
-          -> (to_convert, result){
-            result[to] = to_convert.public_send(fetcher, from)
-          }
-        end
-      end
     end
   end
 end

data/lib/yaoc/strategies/to_hash_mapping.rb

@@ -1,23 +1,13 @@
 module Yaoc
   module Strategies
     module ToHashMapping
-      def self.included(other)
-        other.extend(ClassMethods)
-      end
 
-      def call
-        converter_methods.reduce({}) do |result, method_name|
-          self.public_send(method_name, to_convert, result)
+      def self.call(conv_object)
+        conv_object.converter_methods.reduce({}) do |result, method_name|
+          conv_object.public_send(method_name, conv_object.to_convert, result)
         end
       end
 
-      module ClassMethods
-        def converter_proc(to, from)
-          -> (to_convert, result){
-            result.merge({to => to_convert.public_send(fetcher, from)})
-          }
-        end
-      end
     end
   end
 end

data/lib/yaoc/version.rb

@@ -1,3 +1,3 @@
 module Yaoc
-  VERSION = "0.0.4"
+  VERSION = "0.0.5"
 end

data/lib/yaoc.rb

@@ -1,6 +1,7 @@
 require "yaoc/version"
 require 'abstract_type'
 require 'yaoc/mapping_base'
+require 'yaoc/mapping_to_class'
 
 Dir[File.join(File.expand_path(__dir__ ), "yaoc/strategies/*.rb")].each { |f| require f }
 
@@ -8,5 +9,5 @@ require 'yaoc/converter_builder'
 require 'yaoc/object_mapper'
 
 module Yaoc
-  # Your code goes here...
+
 end

data/spec/acceptance/map_objects_spec.rb

@@ -12,8 +12,8 @@ feature "Map objects", %q{
         fetcher :public_send
         reverse_fetcher :public_send
         rule to: :name,
-             converter: ->(source, result){ result.merge({name:  "#{source[:name]} Hello World"}) },
-             reverse_converter: ->(source, result){ result.merge({name: source.name}) }
+             converter: ->(source, result){ fill_result_with_value(result, :name, "#{source[:name]} Hello World") },
+             reverse_converter: ->(source, result){ fill_result_with_value(result, :name, source.name) }
         rule to: :role, from: :fullrolename
         rule to: :id
         rule to: [:foo, :bar]

data/spec/acceptance/map_to_objects_using_other_converters_spec.rb

@@ -0,0 +1,173 @@
+require "spec_helper"
+
+feature "Map objects reusing other existing converters", %q{
+   In order to map objects with other converters
+   as a lib user
+   I want to map object from an input object to an output object and reverse with a given converter
+} do
+
+
+  given(:new_role_class){
+    Struct.new(:id, :name) do
+      include Equalizer.new(:id, :name)
+
+      def initialize(params={})
+        super()
+
+        params.each do |attr, value|
+          self.public_send("#{attr}=", value)
+        end if params
+      end
+    end
+  }
+
+  given(:old_role_class){
+    Struct.new(:o_id, :o_name) do
+      include Equalizer.new(:o_id, :o_name)
+
+      def initialize(params={})
+        super()
+
+        params.each do |attr, value|
+          self.public_send("#{attr}=", value)
+        end if params
+      end
+    end
+  }
+
+  given(:role_converter){
+    Yaoc::ObjectMapper.new(new_role_class, old_role_class).tap do |mapper|
+      mapper.add_mapping do
+        fetcher :public_send
+
+        rule to:   [:id, :name],
+             from: [:o_id, :o_name]
+
+      end
+    end
+  }
+
+  given(:new_user_class){
+    Struct.new(:id, :firstname, :lastname, :roles) do
+      include Equalizer.new(:id, :firstname, :lastname, :roles)
+
+      def initialize(params={})
+        super()
+
+        params.each do |attr, value|
+          self.public_send("#{attr}=", value)
+        end if params
+      end
+    end
+  }
+
+  given(:old_user_class){
+    Struct.new(:o_id, :o_firstname, :o_lastname, :o_roles) do
+      include Equalizer.new(:o_id, :o_firstname, :o_lastname, :o_roles)
+
+      def initialize(params={})
+        super()
+
+        params.each do |attr, value|
+          self.public_send("#{attr}=", value)
+        end if params
+      end
+    end
+  }
+
+  given(:user_converter){
+    other_converter = role_converter
+    is_col = is_collection
+
+    Yaoc::ObjectMapper.new(new_user_class, old_user_class).tap do |mapper|
+      mapper.add_mapping do
+        fetcher :public_send
+
+        rule to:   [:id, :firstname, :lastname],
+             from: [:o_id, :o_firstname, :o_lastname]
+
+        rule to: :roles,
+             from: :o_roles,
+             object_converter: other_converter,
+             is_collection: is_col
+      end
+    end
+  }
+
+
+  context "composition is a collection" do
+    given(:is_collection){
+      true
+    }
+
+    given(:old_user) {
+      old_user_class.new(
+          o_id: "user_1",
+          o_firstname: "o firstname",
+          o_lastname: "o lastname",
+          o_roles: [
+              old_role_class.new(o_id: "role_1", o_name: "admin"),
+              old_role_class.new(o_id: "role_2", o_name: "ruth"),
+              old_role_class.new(o_id: "role_3", o_name: "guest"),
+          ]
+      )
+    }
+
+    given(:expected_new_user) {
+      new_user_class.new(
+          id: "user_1",
+          firstname: "o firstname",
+          lastname: "o lastname",
+          roles: [
+              new_role_class.new(id: "role_1", name: "admin"),
+              new_role_class.new(id: "role_2", name: "ruth"),
+              new_role_class.new(id: "role_3", name: "guest"),
+          ]
+      )
+    }
+
+    scenario "creates a new user from the old one" do
+      expect(user_converter.load(old_user)).to eq expected_new_user
+    end
+
+    scenario "dumps an result object as result object" do
+      expect(user_converter.dump(expected_new_user)).to eq old_user
+    end
+
+  end
+
+  context "composition is a single value" do
+    given(:is_collection){
+      false
+    }
+
+    given(:old_user) {
+      old_user_class.new(
+          o_id: "user_1",
+          o_firstname: "o firstname",
+          o_lastname: "o lastname",
+          o_roles: old_role_class.new(o_id: "role_1", o_name: "admin, ruth, guest")
+
+      )
+    }
+
+    given(:expected_new_user) {
+      new_user_class.new(
+          id: "user_1",
+          firstname: "o firstname",
+          lastname: "o lastname",
+          roles: new_role_class.new(id: "role_1", name: "admin, ruth, guest")
+      )
+    }
+
+    scenario "creates a new user from the old one" do
+      expect(user_converter.load(old_user)).to eq expected_new_user
+    end
+
+    scenario "dumps an result object as result object" do
+      expect(user_converter.dump(expected_new_user)).to eq old_user
+    end
+
+  end
+
+end

data/spec/acceptance/map_to_objects_with_positional_constructors_spec.rb

@@ -1,6 +1,6 @@
 require "spec_helper"
 
-feature "Map objects", %q{
+feature "Map objects to classes with positional constructors", %q{
    In order to map objects with positional constructors
    as a lib user
    I want to map object from an input object to an output object and reverse with a given mapping strategy

data/spec/integration/lib/yaoc/converter_builder_spec.rb

@@ -0,0 +1,58 @@
+require "spec_helper"
+
+describe Yaoc::ConverterBuilder do
+  subject{
+    ot = other_converter
+    is_col = is_collection
+
+    Yaoc::ConverterBuilder.new().tap{|converter|
+      converter.add_mapping do
+        fetch_with :[]
+        rule to: :id,
+             from: :name,
+             is_collection: is_col,
+             object_converter: ot
+      end
+    }
+
+  }
+
+  let(:other_converter){
+    Class.new() do
+      def to_proc
+        @proc ||= ->(index, *args){
+          [nil, nil, :my_result_1, nil,  :my_result_2][index]
+        }
+      end
+
+      def to_a
+        [self]
+      end
+
+    end.new
+  }
+
+  let(:is_collection){
+    false
+  }
+
+  describe "#converter_to_proc" do
+
+    it "creates a converter proc" do
+      expect(other_converter.to_proc).to receive(:call).with(2).and_return(:my_result)
+      expect(subject.converter(nil, nil).map_0000_name_to_id({:name => 2},{})).to eq(id: :my_result)
+    end
+
+    context "value to convert is a collection" do
+      let(:is_collection){
+        true
+      }
+
+      it "creates a converter proc for collections" do
+        expect(subject.converter(nil, nil).map_0000_name_to_id({:name => [2, 4]},{})).to eq(id: [:my_result_1, :my_result_2])
+      end
+
+    end
+  end
+
+end

data/spec/unit/lib/yaoc/converter_builder_spec.rb

@@ -16,8 +16,10 @@ describe Yaoc::ConverterBuilder do
     double("converter", call: nil)
   }
 
-  describe ".new" do
+  describe "#command_order" do
+
     it "applies command in recorded order as default" do
+      subject.command_order = :recorded_order
 
       expect(converter_class).to receive(:map).ordered.with(:id, :id, nil)
       expect(converter_class).to receive(:map).ordered.with(:name, :name, nil)
@@ -30,10 +32,7 @@ describe Yaoc::ConverterBuilder do
     end
 
     it "applies command in reverse recorded order when wanted" do
-      subject = Yaoc::ConverterBuilder.new(:reverse_order).tap{|converter|
-        converter.stub(:converter_class).and_return(converter_class)
-      }
-
+      subject.command_order = :reverse_order
 
       expect(converter_class).to receive(:map).ordered.with(:name, :name, nil)
       expect(converter_class).to receive(:map).ordered.with(:id, :id, nil)
@@ -103,6 +102,29 @@ describe Yaoc::ConverterBuilder do
              from: [:r_id]
       end
     end
+
+    it "supports the use of a object converter" do
+      expect(converter_class).to receive(:map).ordered.with(:id, :id, kind_of(Proc))
+      other_converter = :some_converter
+
+      subject.add_mapping do
+        rule to: :id,
+             object_converter: other_converter
+      end
+
+    end
+
+    it "supports the collection flag for object converters" do
+      expect(converter_class).to receive(:map).ordered.with(:id, :id, kind_of(Proc))
+      other_converter = :some_converter
+
+      subject.add_mapping do
+        rule to: :id,
+             is_collection: true,
+             object_converter: other_converter
+      end
+
+    end
   end
 
   describe "#converter" do
@@ -112,7 +134,7 @@ describe Yaoc::ConverterBuilder do
         with_strategy :to_array_mapping
       end
 
-      expect(subject.converter({})).to be_kind_of Yaoc::Strategies::ToArrayMapping
+      expect(subject.send(:converter_class).mapping_strategy).to eq(Yaoc::Strategies::ToArrayMapping)
     end
 
     it "raises an exception when not all commands are applied" do
@@ -122,4 +144,5 @@ describe Yaoc::ConverterBuilder do
       expect{subject.converter({})}.to raise_exception
     end
   end
+
 end

data/spec/unit/lib/yaoc/mapping_base_spec.rb

@@ -5,18 +5,12 @@ describe Yaoc::MappingBase do
     Struct.new(:to_convert) do
       include Yaoc::MappingBase
 
-      def self.converter_proc(to, from)
-        -> (to_convert, result){
-          [to, from, to_convert, result]
-        }
-      end
-
-      def call
-        result = :my_result
-        converter_methods.map do |method_name|
-          self.public_send(method_name, to_convert, result)
+      self.mapping_strategy = ->(obj){
+        result = {}
+        obj.converter_methods.map do |method_name|
+          obj.public_send(method_name, obj.to_convert, result)
         end
-      end
+      }
 
     end
   }
@@ -34,8 +28,8 @@ describe Yaoc::MappingBase do
       subject.map(:foo, :bar)
       subject.map(:bar, :foo)
 
-      expect(subject.new(:my_to_convert).call()).to eq [[:foo, :bar, :my_to_convert, :my_result],
-                                                        [:bar, :foo, :my_to_convert, :my_result]]
+      expect(subject.new({bar: :my_to_convert, foo: :my_result}).call()).to eq [{:foo=>:my_to_convert, :bar=>:my_result},
+                                                                                {:foo=>:my_to_convert, :bar=>:my_result}]
     end
 
     it "uses my converter when provided" do
@@ -59,20 +53,6 @@ describe Yaoc::MappingBase do
       Struct.new(:to_convert) do
         include Yaoc::MappingBase
 
-        def self.create_block(to, from)
-          -> (to_convert, result){
-            [to, from, to_convert, result]
-          }
-        end
-
-        def call
-          result = nil
-
-          converter_methods.map do |method_name|
-            self.public_send(method_name, to_convert, result)
-          end
-        end
-
         def fetcher
           "my_fetcher"
         end
@@ -90,4 +70,48 @@ describe Yaoc::MappingBase do
 
   end
 
+  describe "#call" do
+    it "delegates execution to strategy" do
+      mapper = subject.new()
+
+      expect(subject.mapping_strategy).to receive(:call).with mapper
+
+      mapper.call
+    end
+  end
+
+  describe "#to_proc" do
+    it "creates a wrapper around call" do
+      mapper = subject.new()
+      mapper_as_proc = mapper.to_proc
+      expect(mapper).to receive :call
+
+      mapper_as_proc.call(:some_thing)
+    end
+
+    it "changes 'to_convert' temporary" do
+      mapper = subject.new(:old_some_thing)
+      mapper_as_proc = mapper.to_proc
+
+      expect(mapper).to receive(:to_convert=).ordered.with(:some_thing)
+      expect(mapper).to receive(:to_convert=).ordered.with(:old_some_thing)
+
+      mapper_as_proc.call(:some_thing)
+    end
+
+    it "changes 'to_convert' even when a exception occurs" do
+      mapper = subject.new(:old_some_thing)
+      mapper_as_proc = mapper.to_proc
+
+      mapper.stub(:call) do
+        raise "MyException"
+      end
+
+      expect(mapper).to receive(:to_convert=).ordered.with(:some_thing)
+      expect(mapper).to receive(:to_convert=).ordered.with(:old_some_thing)
+
+      expect{mapper_as_proc.call(:some_thing)}.to raise_error "MyException"
+    end
+  end
+
 end

data/spec/unit/lib/yaoc/mapping_to_class_spec.rb

@@ -0,0 +1,53 @@
+require "spec_helper"
+
+describe Yaoc::MappingToClass do
+  subject{
+    Struct.new(:target_source) do
+      include Yaoc::MappingToClass
+
+      self.mapping_strategy = ->(obj){
+        [1]
+      }
+
+    end.new(expected_class)
+  }
+
+  let(:expected_class){
+    Struct.new(:id)
+  }
+
+  describe "#call" do
+    it "creates on object of the wanted kind" do
+      expect(subject.call).to be_kind_of expected_class
+    end
+
+    it "can use a lambda for creation" do
+      creator = ->(*args){}
+      expect(creator).to receive :call
+      subject.target_source = creator
+      subject.call
+    end
+
+
+    it "splashes args when conversion result is an array" do
+      creator = ->(*args){}
+      subject.class.mapping_strategy = ->(obj){
+        [1, 2]
+      }
+
+      expect(creator).to receive(:call).with(1,2)
+
+      subject.target_source = creator
+
+      subject.call
+    end
+  end
+
+  describe "#to_a" do
+    it "satisfies Array(*) when included into structs" do
+      expect(subject.to_a).to eq ([subject])
+    end
+  end
+
+
+end

data/spec/unit/lib/yaoc/object_mapper_spec.rb

@@ -24,11 +24,26 @@ describe Yaoc::ObjectMapper do
     double("reverse_converter", call: nil)
   }
 
+  let(:expected_default_params){
+    {
+        to: :id,
+        from: :id,
+        converter: nil,
+        object_converter: [],
+        is_collection: nil
+    }
+  }
+
   describe "#add_mapping" do
 
     it "creates a converter" do
+      expected_params = expected_default_params.merge(
+          to: :id,
+          from: :id2,
+          converter: :some_proc
+      )
 
-      expect(converter_builder).to receive(:rule).with(to: :id, from: :id2, converter: :some_proc)
+      expect(converter_builder).to receive(:rule).with(expected_params)
 
       subject.add_mapping do
         rule to: :id,
@@ -40,8 +55,13 @@ describe Yaoc::ObjectMapper do
     end
 
     it "creates a revers converter" do
+      expected_params = expected_default_params.merge(
+          to: :id2,
+          from: :id,
+          converter: :some_reverse_proc
+      )
 
-      expect(reverse_converter_builder).to receive(:rule).with(to: :id2, from: :id, converter: :some_reverse_proc)
+      expect(reverse_converter_builder).to receive(:rule).with(expected_params)
 
       subject.add_mapping do
         rule to: :id,
@@ -52,9 +72,42 @@ describe Yaoc::ObjectMapper do
 
     end
 
+    it "allows to use another converter as converter" do
+      converter_double = double("converter")
+
+      expected_params = expected_default_params.merge(
+          from: :id2,
+          object_converter: [converter_double],
+          is_collection: false
+      )
+
+      expected_params_reverse = expected_default_params.merge(
+          to: :id2,
+          from: :id,
+          object_converter: [converter_double],
+          is_collection: false
+      )
+
+
+      expect(converter_builder).to receive(:rule).with(expected_params)
+      expect(reverse_converter_builder).to receive(:rule).with(expected_params_reverse)
+
+      expect(converter_double).to receive(:converter).and_return(converter_double)
+      expect(converter_double).to receive(:reverse_converter).and_return(converter_double)
+
+
+      subject.add_mapping do
+        rule to: :id,
+             from: :id2,
+             is_collection: false,
+             object_converter: converter_double
+      end
+    end
+
     it "uses defaults" do
-      expect(converter_builder).to receive(:rule).with(to: :id, from: :id, converter: nil)
-      expect(reverse_converter_builder).to receive(:rule).with(to: :id, from: :id, converter: nil)
+      expect(converter_builder).to receive(:rule).with(expected_default_params)
+
+      expect(reverse_converter_builder).to receive(:rule).with(expected_default_params)
 
       subject.add_mapping do
         rule to: :id
@@ -63,7 +116,12 @@ describe Yaoc::ObjectMapper do
     end
 
     it "accepts a reverse mapping for from and to" do
-      expect(reverse_converter_builder).to receive(:rule).with(to: :id_r, from: :id_r, converter: nil)
+      expected_params = expected_default_params.merge(
+          to: :id_r,
+          from: :id_r,
+      )
+
+      expect(reverse_converter_builder).to receive(:rule).with(expected_params)
 
       subject.add_mapping do
         rule to: :id, reverse_to: :id_r, reverse_from: :id_r
@@ -78,7 +136,6 @@ describe Yaoc::ObjectMapper do
         rule to: :id
       end
 
-
     end
 
     it "allows to set a reverse_fetcher" do
@@ -107,30 +164,23 @@ describe Yaoc::ObjectMapper do
         rule to: :id, from: 0
       end
     end
+
   end
 
   describe "#load" do
-    it "creates an object of result_class kind" do
-      data = {id: 1}
-
-      converter.stub(call: data)
+    it "creates an object of result class kind" do
+      expect(converter).to receive(:call)
 
-      expect(subject.load_result_source).to receive(:call).with(data)
-
-      subject.load(data)
+      subject.load({})
     end
   end
 
   describe "#dump" do
 
     it "dump the object as an wanted object" do
-      data = {id: 1}
-
-      reverse_converter.stub(call: data)
-
-      expect(subject.dump_result_source).to receive(:call).with(data)
+      expect(reverse_converter).to receive(:call)
 
-      subject.dump(data)
+      subject.dump({})
     end
 
   end

data/spec/unit/lib/yaoc/strategies/to_array_mapping_spec.rb

@@ -4,7 +4,7 @@ describe Yaoc::Strategies::ToArrayMapping do
   subject{
     Struct.new(:to_convert) do
       include Yaoc::MappingBase
-      include Yaoc::Strategies::ToArrayMapping
+      self.mapping_strategy = Yaoc::Strategies::ToArrayMapping
     end
   }
 
@@ -32,7 +32,7 @@ describe Yaoc::Strategies::ToArrayMapping do
 
     it "uses my converter proc" do
       subject.map(0, :id)
-      subject.map(3, :fullname, ->(source, result){ result[3] = "#{source.fetch(:name)} Hello World" })
+      subject.map(3, :fullname, ->(source, result){ fill_result_with_value(result, 3, "#{source.fetch(:name)} Hello World") })
 
       ext_expectation = expected_array.clone
       ext_expectation[3] = "#{ext_expectation[1]} Hello World"

data/spec/unit/lib/yaoc/strategies/to_hash_mapping_spec.rb

@@ -4,7 +4,7 @@ describe Yaoc::Strategies::ToHashMapping do
   subject{
     Struct.new(:to_convert) do
       include Yaoc::MappingBase
-      include Yaoc::Strategies::ToHashMapping
+      self.mapping_strategy = Yaoc::Strategies::ToHashMapping
     end
   }
 
@@ -20,7 +20,7 @@ describe Yaoc::Strategies::ToHashMapping do
     {id: 1, name: "paul"}
   }
 
-  describe ".call" do
+  describe "#call" do
 
     it "creates a hash from a object" do
       subject.map(:id, :id)
@@ -41,7 +41,7 @@ describe Yaoc::Strategies::ToHashMapping do
 
     it "uses my converter proc" do
       subject.map(:id, :id)
-      subject.map(:name, :fullname, ->(source, result){ result.merge({name: source.fetch(:name) + " Hello World"}) })
+      subject.map(:name, :fullname, ->(source, result){ fill_result_with_value(result, :name, source.fetch(:name) + " Hello World") })
 
       ext_expectation = expected_hash.clone
       ext_expectation[:name] += " Hello World"

data/yaoc.gemspec

@@ -7,7 +7,7 @@ Gem::Specification.new do |spec|
   spec.name          = "yaoc"
   spec.version       = Yaoc::VERSION
   spec.authors       = ["Dieter Späth"]
-  spec.email         = ["dieter.spaeth@gmx.de"]
+  spec.email         = ["shad0wrunner@gmx.de"]
   spec.summary       = %q{Yet another object converter}
   spec.description   = %q{Yet another object converter}
   spec.homepage      = "https://github.com/slowjack2k/yaoc"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: yaoc
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Dieter Späth
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-23 00:00:00.000000000 Z
+date: 2014-01-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: abstract_type
@@ -208,7 +208,7 @@ dependencies:
         version: '0'
 description: Yet another object converter
 email:
-- dieter.spaeth@gmx.de
+- shad0wrunner@gmx.de
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -222,16 +222,20 @@ files:
 - lib/yaoc.rb
 - lib/yaoc/converter_builder.rb
 - lib/yaoc/mapping_base.rb
+- lib/yaoc/mapping_to_class.rb
 - lib/yaoc/object_mapper.rb
 - lib/yaoc/strategies/to_array_mapping.rb
 - lib/yaoc/strategies/to_hash_mapping.rb
 - lib/yaoc/version.rb
 - spec/acceptance/map_objects_spec.rb
+- spec/acceptance/map_to_objects_using_other_converters_spec.rb
 - spec/acceptance/map_to_objects_with_positional_constructors_spec.rb
+- spec/integration/lib/yaoc/converter_builder_spec.rb
 - spec/spec_helper.rb
 - spec/support/feature.rb
 - spec/unit/lib/yaoc/converter_builder_spec.rb
 - spec/unit/lib/yaoc/mapping_base_spec.rb
+- spec/unit/lib/yaoc/mapping_to_class_spec.rb
 - spec/unit/lib/yaoc/object_mapper_spec.rb
 - spec/unit/lib/yaoc/strategies/to_array_mapping_spec.rb
 - spec/unit/lib/yaoc/strategies/to_hash_mapping_spec.rb
@@ -262,11 +266,14 @@ specification_version: 4
 summary: Yet another object converter
 test_files:
 - spec/acceptance/map_objects_spec.rb
+- spec/acceptance/map_to_objects_using_other_converters_spec.rb
 - spec/acceptance/map_to_objects_with_positional_constructors_spec.rb
+- spec/integration/lib/yaoc/converter_builder_spec.rb
 - spec/spec_helper.rb
 - spec/support/feature.rb
 - spec/unit/lib/yaoc/converter_builder_spec.rb
 - spec/unit/lib/yaoc/mapping_base_spec.rb
+- spec/unit/lib/yaoc/mapping_to_class_spec.rb
 - spec/unit/lib/yaoc/object_mapper_spec.rb
 - spec/unit/lib/yaoc/strategies/to_array_mapping_spec.rb
 - spec/unit/lib/yaoc/strategies/to_hash_mapping_spec.rb