yaoc 0.0.8 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 60a0299fcfe56955d503d23ff8d92b69d2f9aee4
-  data.tar.gz: 4946c343a774f4d278298671f781d61ad647fe02
+  metadata.gz: 2324f744d79c8b4447ce737b2eb4530c2ea22e49
+  data.tar.gz: 4f455b5e33867e51b06c248896f42eb24b5bac70
 SHA512:
-  metadata.gz: 27acb99f506e5220e00b16bfd691df573fd1ae1c860c9d0ec9e0a0b229c2a95500884b44e0561b0fcfc61dc2105c608459db1c1d1aafbb0b0bb43b0726e6f37f
-  data.tar.gz: 4bcd3ceecda4be8ce9b9c381991c1230249dd0d2c0d912ed91f86d6c356e90174a3e4bbe3294c7710d59a73cc8f0e15f8bf8f97f01eeaf96418ee2fbbc0e7c1f
+  metadata.gz: 8292da0e6c0ccfd4259c457c10da22351df4cc7b9081ada86cdf6ea3945ad0e69bccd7a26767243176193c9a0b7a0585be9f4c60c3886ff2e30005c8852b2cbc
+  data.tar.gz: 5744c15c87cdf05a21fef126b4747a94a23100d6dd82287cb6ac56058068a28750e45284537130b1aa146c35cdad293f6b0fb9658958c5485c1d09e24145ba8d

data/README.md

@@ -18,7 +18,7 @@ Or install it yourself as:
 
 ## Usage
 
-Uptodate doc's look into the specs.
+For uptodate doc's take a look into the specs.
 
 ### The resulting classes have hash enabled constructors?
 
@@ -39,12 +39,12 @@ mapper = Yaoc::ObjectMapper.new(User, OldUser).tap do |mapper|
 
     rule to: :firstname,
          from: :fullname,
-         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}") }
+         converter: ->(source, result){ Yaoc::TransformationCommand.fill_result_with_value(result, :firstname, source.fullname.split().first) },
+         reverse_converter: ->(source, result){ Yaoc::TransformationCommand.fill_result_with_value(result, :fullname,  "#{source.firstname} #{source.lastname}") }
 
     rule to: :lastname,
          from: :fullname,
-         converter: ->(source, result){ fill_result_with_value(result, :lastname, source.fullname.split().last ) },
+         converter: ->(source, result){ Yaoc::TransformationCommand.fill_result_with_value(result, :lastname, source.fullname.split().last ) },
          reverse_converter: ->(source, result){ result }
 
     rule to: :id
@@ -104,12 +104,12 @@ mapper = Yaoc::ObjectMapper.new(source, reverse_source).tap do |mapper|
 
     rule to: :firstname,
          from: :fullname,
-         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}") }
+         converter: ->(source, result){ Yaoc::TransformationCommand.fill_result_with_value(result, :firstname,  source.fullname.split().first ) },
+         reverse_converter: ->(source, result){ Yaoc::TransformationCommand.fill_result_with_value(result, :fullname, "#{source.firstname} #{source.lastname}") }
 
     rule to: :lastname,
          from: :fullname,
-         converter: ->(source, result){ fill_result_with_value(result, :lastname,  source.fullname.split().last) },
+         converter: ->(source, result){ Yaoc::TransformationCommand.fill_result_with_value(result, :lastname,  source.fullname.split().last) },
          reverse_converter: ->(source, result){ result }
 
     rule to: :id
@@ -147,6 +147,16 @@ puts "\n" * 5
 OldUser3 = Struct.new(:id, :fullname, :r_role)
 User3 = Struct.new(:id, :firstname, :lastname, :role)
 
+# alternative to proc for converter
+converter = Yaoc::TransformationCommand.create(to: 1,
+                                               from: :fullname,
+                                               deferred: false,
+                                               fetcher_proc: ->(source, fetcher, from){source.fullname.split().first} )
+
+reverse_converter = Yaoc::TransformationCommand.create(to: 1,
+                                                       from: :first_and_lastname,
+                                                       deferred: false,
+                                                       fetcher_proc: ->(source, fetcher, from){ "#{source.firstname} #{source.lastname}"} )
 
 mapper = Yaoc::ObjectMapper.new(User3, OldUser3).tap do |mapper|
   mapper.add_mapping do
@@ -161,8 +171,8 @@ mapper = Yaoc::ObjectMapper.new(User3, OldUser3).tap do |mapper|
     rule to: 1,
          from: :fullname,
 
-         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}") }
+         converter: converter,
+         reverse_converter: reverse_converter
 
     rule to: 2,
          from: :fullname,
@@ -187,6 +197,7 @@ new_user3.lastname = "name"
 
 puts mapper.dump(new_user3)
 
+
 #<struct OldUser3 id=1, fullname="myfirst mysecond", r_role="admin">
 #<struct User3 id=1, firstname="myfirst", lastname="mysecond", role="admin">
 #<struct OldUser3 id=1, fullname="no name", r_role="admin">

data/examples/01_hash_enabled_constructors.rb

@@ -16,12 +16,12 @@ mapper = Yaoc::ObjectMapper.new(User, OldUser).tap do |mapper|
 
     rule to: :firstname,
          from: :fullname,
-         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}") }
+         converter: ->(source, result){ Yaoc::TransformationCommand.fill_result_with_value(result, :firstname, source.fullname.split().first) },
+         reverse_converter: ->(source, result){ Yaoc::TransformationCommand.fill_result_with_value(result, :fullname,  "#{source.firstname} #{source.lastname}") }
 
     rule to: :lastname,
          from: :fullname,
-         converter: ->(source, result){ fill_result_with_value(result, :lastname, source.fullname.split().last ) },
+         converter: ->(source, result){ Yaoc::TransformationCommand.fill_result_with_value(result, :lastname, source.fullname.split().last ) },
          reverse_converter: ->(source, result){ result }
 
     rule to: :id

data/examples/02_procs_as_constructors.rb

@@ -34,12 +34,12 @@ mapper = Yaoc::ObjectMapper.new(source, reverse_source).tap do |mapper|
 
     rule to: :firstname,
          from: :fullname,
-         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}") }
+         converter: ->(source, result){ Yaoc::TransformationCommand.fill_result_with_value(result, :firstname,  source.fullname.split().first ) },
+         reverse_converter: ->(source, result){ Yaoc::TransformationCommand.fill_result_with_value(result, :fullname, "#{source.firstname} #{source.lastname}") }
 
     rule to: :lastname,
          from: :fullname,
-         converter: ->(source, result){ fill_result_with_value(result, :lastname,  source.fullname.split().last) },
+         converter: ->(source, result){ Yaoc::TransformationCommand.fill_result_with_value(result, :lastname,  source.fullname.split().last) },
          reverse_converter: ->(source, result){ result }
 
     rule to: :id

data/examples/03_positional_constructors.rb

@@ -11,6 +11,16 @@ OldUser3 = Struct.new(:id, :fullname, :r_role)
 User3 = Struct.new(:id, :firstname, :lastname, :role)
 
 
+converter = Yaoc::TransformationCommand.create(to: 1,
+                                               from: :fullname,
+                                               deferred: false,
+                                               fetcher_proc: ->(source, fetcher, from){source.fullname.split().first} )
+
+reverse_converter = Yaoc::TransformationCommand.create(to: 1,
+                                                       from: :first_and_lastname,
+                                                       deferred: false,
+                                                       fetcher_proc: ->(source, fetcher, from){ "#{source.firstname} #{source.lastname}"} )
+
 mapper = Yaoc::ObjectMapper.new(User3, OldUser3).tap do |mapper|
   mapper.add_mapping do
     fetcher :public_send
@@ -24,8 +34,8 @@ mapper = Yaoc::ObjectMapper.new(User3, OldUser3).tap do |mapper|
     rule to: 1,
          from: :fullname,
 
-         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}") }
+         converter: converter,
+         reverse_converter: reverse_converter
 
     rule to: 2,
          from: :fullname,

data/lib/yaoc.rb

@@ -1,5 +1,10 @@
 require "yaoc/version"
+
+Dir[File.join(File.expand_path(__dir__ ), "yaoc/helper/*.rb")].each { |f| require f }
+
 require 'yaoc/mapping_base'
+require 'yaoc/transformation_command'
+require 'yaoc/transformation_deferred_command'
 require 'yaoc/mapping_to_class'
 
 Dir[File.join(File.expand_path(__dir__ ), "yaoc/strategies/*.rb")].each { |f| require f }
@@ -7,8 +12,6 @@ Dir[File.join(File.expand_path(__dir__ ), "yaoc/strategies/*.rb")].each { |f| re
 require 'yaoc/converter_builder'
 require 'yaoc/object_mapper'
 
-Dir[File.join(File.expand_path(__dir__ ), "yaoc/helper/*.rb")].each { |f| require f }
-
 module Yaoc
 
 end

data/lib/yaoc/converter_builder.rb

@@ -36,20 +36,19 @@ module Yaoc
     end
 
     def converter_to_proc(to, from, converter, is_collection, deferred)
-      ->(source, result){
-        get_value_with = ->{
-          object_to_convert = source.public_send(fetcher, from)
-
-          if is_collection
-            object_to_convert.map(&converter)
-          else
-            converter_as_proc = converter.to_proc
-            converter_as_proc.call(object_to_convert)
-          end
-        }
-
-        fill_result_from_proc(result, to, get_value_with, deferred)
+
+      get_value_with = ->(source, fetcher, from){
+        object_to_convert = source.public_send(fetcher, from)
+
+        if is_collection
+          object_to_convert.map(&converter)
+        else
+          converter_as_proc = converter.to_proc
+          converter_as_proc.call(object_to_convert)
+        end
       }
+
+      TransformationCommand.create(to: to, from: from, deferred: deferred, fetcher_proc: get_value_with)
     end
 
   end
@@ -83,6 +82,10 @@ module Yaoc
         build_commands.reverse
       end
     end
+
+    def noop
+      ->(_, result){ result }
+    end
   end
 
 

data/lib/yaoc/helper/to_proc_delegator.rb

@@ -1,3 +1,5 @@
+require 'delegate'
+
 module Yaoc
   module Helper
     class ToProcDelegator < SimpleDelegator

data/lib/yaoc/mapping_base.rb

@@ -25,25 +25,6 @@ module Yaoc
       end
     end
 
-    def fill_result_with_value(result, key, value)
-      result.tap{|taped_result| taped_result[key] = value}
-    end
-
-    def fill_result_from_proc(result, key, proc, deferred=false)
-      value = if deferred
-                deferrer_strategy(proc)
-              else
-                proc.call
-              end
-
-      fill_result_with_value(result, key, value)
-    end
-
-    def deferrer_strategy(proc)
-      Yaoc::Helper::ToProcDelegator.new(proc)
-    end
-
-
     def converter_methods
       self.class.converter_methods
     end
@@ -54,16 +35,6 @@ module Yaoc
 
     module ClassMethods
 
-      def converter_proc(to, from, deferred=false)
-        -> (to_convert, result){
-          get_value_with = ->{
-            to_convert.public_send(fetcher, from)
-          }
-
-          fill_result_from_proc(result, to, get_value_with, deferred)
-        }
-      end
-
       def mapping_strategy=(new_strat)
         @mapping_strategy = new_strat
       end
@@ -74,7 +45,7 @@ module Yaoc
 
       def map(to: nil, from: to, converter: nil, lazy_loading: false)
         class_private_module(:Mapping).tap do |mod|
-          method_implementation = converter || converter_proc(to, from, lazy_loading)
+          method_implementation = TransformationCommand.create(to: to, from: from, deferred: lazy_loading, conversion_proc: converter)
 
           mod.send :define_method, "map_#{"%04d" %[converter_methods.count]}_#{from}_to_#{to}".to_sym, method_implementation
           include mod
@@ -105,5 +76,6 @@ module Yaoc
       end
 
     end
+
   end
 end

data/lib/yaoc/object_mapper.rb

@@ -6,16 +6,20 @@ module Yaoc
       apply_commands!
     end
 
-    def rule(to: nil, from: to, converter: nil,
+    def rule(to: nil,
+        from: to,
+        converter: nil,
         reverse_to: from,
         reverse_from: to,
         reverse_converter: nil,
         object_converter: nil,
+        reverse_object_converter: object_converter,
         is_collection: nil,
         lazy_loading: nil,
         reverse_lazy_loading: lazy_loading)
 
       object_converter = Array(object_converter)
+      reverse_object_converter = Array(reverse_object_converter)
 
       converter_builder.rule(
           to: to,
@@ -30,7 +34,7 @@ module Yaoc
           to: reverse_to,
           from: reverse_from,
           converter: reverse_converter,
-          object_converter: object_converter.map(&:reverse_converter),
+          object_converter: reverse_object_converter.map(&:reverse_converter),
           is_collection: is_collection,
           lazy_loading: reverse_lazy_loading
       )
@@ -51,6 +55,11 @@ module Yaoc
     def reverse_strategy(new_strategy)
       reverse_converter_builder.strategy = new_strategy
     end
+
+    def noop
+      ->(_, result){ result }
+    end
+
   end
 
   class ObjectMapper

data/lib/yaoc/transformation_command.rb

@@ -0,0 +1,53 @@
+module Yaoc
+  class TransformationCommand
+
+    protected
+    attr_accessor :to, :from, :fetcher , :proc, :value_fetcher_proc
+
+    public
+
+    def self.deferred_source
+      TransformationDeferredCommand
+    end
+
+    def self.default_source
+      TransformationCommand
+    end
+
+    def self.create(to: nil, from: nil, deferred: false, conversion_proc: nil, fetcher_proc: nil)
+      # will be executed in mapper object instance context later through :define_method
+      tc_source = deferred ? deferred_source : default_source
+
+      -> (to_convert, result){
+        tc_source.new(to: to, from: from, fetch_method: fetcher, conversion_proc: conversion_proc, fetcher_proc: fetcher_proc).call(to_convert, result)
+      }
+    end
+
+    def self.fill_result_with_value(result, key, value)
+      result.tap{|taped_result| taped_result[key] = value}
+    end
+
+    def initialize(to: nil, from: nil, fetch_method: nil, conversion_proc: nil, fetcher_proc: nil)
+      self.to = to
+      self.from = from
+      self.proc = conversion_proc
+      self.fetcher = fetch_method
+      self.value_fetcher_proc = fetcher_proc || ->(to_convert, fetcher, from){ to_convert.public_send(fetcher, from)}
+    end
+
+    def call(to_convert, result)
+
+      unless proc.nil?
+        instance_exec(to_convert, result, &proc)
+      else
+        TransformationCommand.fill_result_with_value(result, to, value(to_convert))
+      end
+
+    end
+
+    def value(to_convert)
+      value_fetcher_proc.call(to_convert, fetcher, from)
+    end
+
+  end
+end

data/lib/yaoc/transformation_deferred_command.rb

@@ -0,0 +1,17 @@
+module Yaoc
+  class TransformationDeferredCommand < TransformationCommand
+
+    def value(time_saved_to_convert)
+      proc = ->{
+        value_fetcher_proc.call(time_saved_to_convert, fetcher, from)
+      }
+
+      TransformationDeferredCommand.deferrer_strategy(proc)
+    end
+
+    def self.deferrer_strategy(proc)
+      Yaoc::Helper::ToProcDelegator.new(proc)
+    end
+
+  end
+end

data/lib/yaoc/version.rb

@@ -1,3 +1,3 @@
 module Yaoc
-  VERSION = "0.0.8"
+  VERSION = "0.0.9"
 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){ fill_result_with_value(result, :name, "#{source[:name]} Hello World") },
-             reverse_converter: ->(source, result){ fill_result_with_value(result, :name, source.name) }
+             converter: ->(source, result){ Yaoc::TransformationCommand.fill_result_with_value(result, :name, "#{source[:name]} Hello World") },
+             reverse_converter: ->(source, result){ Yaoc::TransformationCommand.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

@@ -49,6 +49,7 @@ feature "Map objects reusing other existing converters", %q{
         rule to: :roles,
              from: :o_roles,
              object_converter: other_converter,
+             reverse_object_converter: other_converter,
              is_collection: is_col
       end
     end

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

@@ -161,6 +161,17 @@ describe Yaoc::ConverterBuilder do
              lazy_loading: true
       end
     end
+
+    it "supports a do nothing" do
+      expected_args = default_map_args.clone.merge({converter: kind_of(Proc)})
+
+      expect(converter_class).to receive(:map).ordered.with(expected_args)
+
+      subject.add_mapping do
+        rule to: :id,
+             converter: noop
+      end
+    end
   end
 
   describe "#converter" do
@@ -181,4 +192,10 @@ describe Yaoc::ConverterBuilder do
     end
   end
 
+  describe "#noop" do
+    it "returns the input" do
+      expect(subject.noop.call(:some_thing, :expected_value)).to eq :expected_value
+    end
+  end
+
 end

data/spec/unit/lib/yaoc/helper/to_proc_delegator_spec.rb

@@ -41,6 +41,12 @@ describe Yaoc::Helper::ToProcDelegator do
 
   end
 
+  describe '#class' do
+    it 'is the lazy loaded object class' do
+      expect(subject.class).to eq Array
+    end
+  end
+
   describe '#nil?' do
     it "returns true when delegate value is nil" do
       subject = Yaoc::Helper::ToProcDelegator.new(->{nil})
@@ -52,4 +58,29 @@ describe Yaoc::Helper::ToProcDelegator do
     end
   end
 
+  describe '#_initialisation_proc_loaded?' do
+    it "returns true, when __getobj__ was accessed" do
+      expect(subject._initialisation_proc_loaded?).to be_falsy
+      subject.__getobj__
+      expect(subject._initialisation_proc_loaded?).to be_truthy
+    end
+  end
+
+  describe '_needs_conversion?' do
+    it 'returns true when the object was loaded and __getobj__ is not nil' do
+      subject.__getobj__
+      expect(subject._needs_conversion?).to be_truthy
+    end
+
+    it 'returns false when the object was not' do
+      expect(subject._needs_conversion?).to be_falsy
+    end
+
+    it 'returns false when the object was loaded but is nil' do
+      subject.__getobj__
+      subject.__setobj__(nil)
+      expect(subject._needs_conversion?).to be_falsy
+    end
+  end
+
 end

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

@@ -32,31 +32,11 @@ describe Yaoc::MappingBase do
                                                                                 {:foo=>:my_to_convert, :bar=>:my_result}]
     end
 
-    it "uses my converter when provided" do
+    it "delegates to TransformationCommand.create" do
+      expect(Yaoc::TransformationCommand).to receive(:create).with(to: :bar, from: :foo, deferred: false, conversion_proc: kind_of(Proc)).and_return(->(*){})
       subject.map(to: :bar, from: :foo, converter: ->(*){})
-
-      expect(subject.new(:my_to_convert).call()).to eq [nil]
-    end
-
-    it 'supports deferred mappings' do
-      subject.map(to: :bar, from: :foo, lazy_loading: true)
-      object_to_convert = {foo: [:my_result]}
-
-      expect(object_to_convert).not_to receive :fetch
-
-      subject.new(object_to_convert).call()
     end
 
-    it "returns results for deferred mappings" do
-      subject.map(to: :bar, from: :foo, lazy_loading: true)
-      object_to_convert = double("object_to_convert")
-
-      result = subject.new(object_to_convert).call()
-
-      expect(object_to_convert).to receive(:fetch).with(:foo).and_return([:my_result])
-
-      expect(result.first[:bar].first).to eq :my_result
-    end
   end
 
   describe "#converter_methods" do

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

@@ -88,6 +88,29 @@ describe Yaoc::ObjectMapper do
       end
     end
 
+    it "allows to use another converter as reverse converter" do
+      reverse_converter_double = double("reverse converter")
+
+      expected_params = expected_default_params.merge(
+          object_converter: [],
+      )
+
+      expected_params_reverse = expected_default_params.merge(
+          object_converter: [reverse_converter_double]
+      )
+
+
+      expect(converter_builder).to receive(:rule).with(expected_params)
+      expect(reverse_converter_builder).to receive(:rule).with(expected_params_reverse)
+
+      expect(reverse_converter_double).to receive(:reverse_converter).and_return(reverse_converter_double)
+
+      subject.add_mapping do
+        rule to: :id,
+             reverse_object_converter: reverse_converter_double
+      end
+    end
+
     it "accepts a reverse mapping for from and to" do
       expected_params = expected_default_params.merge(
           to: :id_r,
@@ -207,4 +230,10 @@ describe Yaoc::ObjectMapper do
 
   end
 
+  describe "#noop" do
+    it "returns the input" do
+      expect(subject.noop.call(:some_thing, :expected_value)).to eq :expected_value
+    end
+  end
+
 end

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

@@ -32,7 +32,7 @@ describe Yaoc::Strategies::ToArrayMapping do
 
     it "uses my converter proc" do
       subject.map(to: 0, from: :id)
-      subject.map(to: 3, from: :fullname, converter: ->(source, result){ fill_result_with_value(result, 3, "#{source.fetch(:name)} Hello World") })
+      subject.map(to: 3, from: :fullname, converter: ->(source, result){ Yaoc::TransformationCommand.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

@@ -41,7 +41,7 @@ describe Yaoc::Strategies::ToHashMapping do
 
     it "uses my converter proc" do
       subject.map(to: :id)
-      subject.map(to: :name, from: :fullname, converter: ->(source, result){ fill_result_with_value(result, :name, source.fetch(:name) + " Hello World") })
+      subject.map(to: :name, from: :fullname, converter: ->(source, result){ Yaoc::TransformationCommand.fill_result_with_value(result, :name, source.fetch(:name) + " Hello World") })
 
       ext_expectation = expected_hash.clone
       ext_expectation[:name] += " Hello World"

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

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe Yaoc::TransformationCommand do
+  subject{
+    Yaoc::TransformationCommand.new(to: :id, from: :name, fetch_method: :fetch)
+  }
+
+  let(:source){
+    {name: 'my_name'}
+  }
+
+  let(:result){
+    {}
+  }
+
+  describe '.create' do
+    subject{
+      Yaoc::TransformationCommand
+    }
+
+    it 'creates a proc' do
+      expect(subject.create(to: :to, from: :from)).to respond_to :call
+    end
+
+    it 'uses default_source when deferred is flase' do
+      expect(subject).to receive :default_source
+      subject.create(to: :to, from: :from)
+    end
+
+    it 'uses default_source when deferred is flase' do
+      expect(subject).to receive :deferred_source
+      subject.create(to: :to, from: :from, deferred: true)
+    end
+
+  end
+
+  describe '#call' do
+
+    it 'transfers data from source to result' do
+      subject.call(source, result)
+      expect(result[:id]).to eq source[:name]
+    end
+
+    it 'add the fetched value to result' do
+      new_result = subject.call(source, result)
+      expect(new_result).to eq result
+    end
+
+    it 'returns a result' do
+      new_result = subject.call(source, result)
+      expect(new_result).to eq result
+    end
+
+  end
+
+  describe '#value' do
+    subject {
+      Yaoc::TransformationCommand.new(to: :id, from: :name, fetch_method: :fetch, fetcher_proc: value_fetcher)
+    }
+
+    let(:value_fetcher) { double('value fetcher proc')}
+
+    it 'uses a given proc for value fetching' do
+      expect(value_fetcher).to receive(:call).with(source, :fetch, :name).and_return(:some_thing_to_store)
+
+      expect(subject.value(source)).to eq :some_thing_to_store
+    end
+
+  end
+end

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

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Yaoc::TransformationDeferredCommand do
+  subject{
+    Yaoc::TransformationDeferredCommand.new(to: :id, from: :name, fetch_method: :fetch)
+  }
+
+  let(:source){
+    {name: 'my_name'}
+  }
+
+  let(:result){
+    {}
+  }
+
+  describe '#value' do
+    let(:value_fetcher) { double('value fetcher proc')}
+
+    it 'deferres access to source object' do
+      expect(source).not_to receive :fetch
+
+      subject.value(source)
+    end
+
+    it 'access to source object, when data is needed' do
+      expect(source).to receive :fetch
+
+      subject.value(source).to_s
+    end
+
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: yaoc
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.0.9
 platform: ruby
 authors:
 - Dieter Späth
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-28 00:00:00.000000000 Z
+date: 2014-01-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -222,6 +222,8 @@ files:
 - lib/yaoc/object_mapper.rb
 - lib/yaoc/strategies/to_array_mapping.rb
 - lib/yaoc/strategies/to_hash_mapping.rb
+- lib/yaoc/transformation_command.rb
+- lib/yaoc/transformation_deferred_command.rb
 - lib/yaoc/version.rb
 - spec/acceptance/fill_existing_objects_spec.rb
 - spec/acceptance/map_objects_spec.rb
@@ -239,6 +241,8 @@ files:
 - 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
+- spec/unit/lib/yaoc/transformation_command_spec.rb
+- spec/unit/lib/yaoc/transformation_deferred_command_spec.rb
 - yaoc.gemspec
 homepage: https://github.com/slowjack2k/yaoc
 licenses:
@@ -281,3 +285,5 @@ test_files:
 - 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
+- spec/unit/lib/yaoc/transformation_command_spec.rb
+- spec/unit/lib/yaoc/transformation_deferred_command_spec.rb