yaoc 0.0.6 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 12e7c498b11d4f4f205c85146f98f715d49d9f52
-  data.tar.gz: aba743b04f8bb624c80758aa6f4466ad467ae4d9
+  metadata.gz: 115be6510d49cc1ed39509369d8a13b35574afff
+  data.tar.gz: 77bc38e239f5ee0dad8a86e4e4e22fa6fa294c46
 SHA512:
-  metadata.gz: 05c3efaa5c1e2862b10194039dbaca983dfdd366fab365aab1a1aa93551265aa286f68387979d69f939409dec3c21bb28f79a876a851855979116afb8d4dfd22
-  data.tar.gz: b4919d5988c9b6cc7c9e36a082e5fe8b2c9eaf712157533a85736c7bf9a081a4a90b90caaa6239b56d62612f6654af67dc67dfaa5c3d6ea3e6b7924492ef03ef
+  metadata.gz: 49986fe1421711286cbc6e67ac58285fb625ad143e5f00bd280807a900884936d43b62fe7e5921cfb40f01603f1393c1c9eefc654b4b5fdd142c3f8b5db3f2b3
+  data.tar.gz: 41ccc8c0e963f2839e7f610fe313b371e8199fdd9ac521a132ae01bbe6a5ff50336148b4bdb158e3e74d271031f89a2a7db640c93b451d1e318ec4ffd3c8e2ec

data/README.md

@@ -1,6 +1,6 @@
 # Yaoc [![Code Climate](https://codeclimate.com/github/slowjack2k/yaoc.png)](https://codeclimate.com/github/slowjack2k/yaoc) [![Build Status](https://travis-ci.org/slowjack2k/yaoc.png?branch=master)](https://travis-ci.org/slowjack2k/yaoc) [![Coverage Status](https://coveralls.io/repos/slowjack2k/yaoc/badge.png?branch=master)](https://coveralls.io/r/slowjack2k/yaoc?branch=master) [![Gem Version](https://badge.fury.io/rb/yaoc.png)](http://badge.fury.io/rb/yaoc)
 
-Indentation of this gem is to learn and train a little ruby.
+Converting one ruby object into another with some rules.
 
 ## Installation
 
@@ -307,6 +307,57 @@ puts new_user5
 
 ```
 
+### How can I lazy load some expensive to convert attributes?
+
+```ruby
+require 'yaoc'
+
+include Yaoc::Helper
+
+puts "\n" * 5
+
+
+OldUser6 = StructHE(:id) do
+
+  def names=(new_names)
+    @names = new_names
+  end
+
+  def names
+    puts 'some expensive operation in progress ...'
+    sleep 10
+    @names
+  end
+
+end
+User6 = StructHE(:id, :names)
+
+
+user_mapper = Yaoc::ObjectMapper.new(User6, OldUser6).tap do |mapper|
+  mapper.add_mapping do
+    fetcher :public_send
+    rule to: [:id, :names],
+         lazy_loading: [false, true]
+  end
+end
+
+old_user6 = OldUser6.new(id: 'my_id_1', names: ['one', 'two', 'three', 'four'])
+new_user6 = user_mapper.load(old_user6)
+
+puts new_user6.id.inspect
+puts new_user6.names.inspect
+puts new_user6
+
+
+puts "\n" * 5
+
+# "my_id_1"
+# some expensive operation in progress ...
+# ["one", "two", "three", "four"]
+#<struct User6 id="my_id_1", names=["one", "two", "three", "four"]>
+
+```
+
 ## Contributing
 
 1. Fork it ( http://github.com/slowjack2k/yaoc/fork )

data/Rakefile

@@ -8,6 +8,6 @@ task :test => :spec
 
 desc "Run RSpec with code coverage"
 task :coverage do
-  ENV['COVERAGE'] = "true"
+  ENV['SIMPLE_COVERAGE'] = "true"
   Rake::Task["spec"].execute
 end

data/examples/06_lazy_loading.rb

@@ -0,0 +1,47 @@
+require 'bundler/setup'
+Bundler.require(:development)
+
+require 'yaoc'
+
+include Yaoc::Helper
+
+puts "\n" * 5
+
+
+OldUser6 = StructHE(:id) do
+
+  def names=(new_names)
+    @names = new_names
+  end
+
+  def names
+    puts 'some expensive operation in progress ...'
+    sleep 10
+    @names
+  end
+
+end
+User6 = StructHE(:id, :names)
+
+
+user_mapper = Yaoc::ObjectMapper.new(User6, OldUser6).tap do |mapper|
+  mapper.add_mapping do
+    fetcher :public_send
+    rule to: [:id, :names],
+         lazy_loading: [false, true]
+  end
+end
+
+old_user6 = OldUser6.new(id: 'my_id_1', names: ['one', 'two', 'three', 'four'])
+new_user6 = user_mapper.load(old_user6)
+
+puts new_user6.id.inspect
+puts new_user6.names.inspect
+puts new_user6
+
+
+puts "\n" * 5
+
+
+
+

data/examples/all_examples.rb

@@ -0,0 +1,7 @@
+Dir[File.join(File.expand_path(__dir__ ), "*.rb")].sort.each do |f|
+  unless f =~ /#{__FILE__}$/
+    command = %W(ruby #{f})
+    puts "executing #{command.join(" ")}"
+    system *command
+  end
+end

data/lib/yaoc.rb

@@ -1,5 +1,4 @@
 require "yaoc/version"
-require 'abstract_type'
 require 'yaoc/mapping_base'
 require 'yaoc/mapping_to_class'
 

data/lib/yaoc/converter_builder.rb

@@ -1,22 +1,28 @@
 module Yaoc
 
   class NormalizedParameters
-    attr_accessor :to_s, :from_s, :converter_s
+    attr_accessor :to_s, :from_s, :converter_s, :lazy_loading_s
 
-    def initialize(to, from, converter, object_converter, is_collection)
+    def initialize(to, from, converter, object_converter, is_collection, lazy_loading)
       self.to_s = Array(to)
       self.from_s = Array(from)
       self.converter_s = Array(converter)
+      self.lazy_loading_s = Array(lazy_loading)
 
       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
+        lazy_loading_s[index] ||= false
       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])
+        converter_s[index] = converter_to_proc(to_s[index],
+                                               from_s[index],
+                                               object_converter,
+                                               !!is_collection_s[index],
+                                               !!lazy_loading_s[index])
       end
 
     end
@@ -25,30 +31,64 @@ module Yaoc
       return to_enum(__callee__) unless block_given?
 
       self.to_s.each_with_index do |to, index|
-        yield to, from_s[index] , converter_s[index]
+        yield to, from_s[index] , converter_s[index], lazy_loading_s[index]
       end
     end
 
-    def converter_to_proc(to, from, converter, is_collection)
+    def converter_to_proc(to, from, converter, is_collection, deferred)
       ->(source, result){
-        object_to_convert = source.public_send(fetcher, from)
-        converted_object = nil
+        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)
+      }
+    end
 
-        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
+  end
 
-        fill_result_with_value(result, to, converted_object)
-      }
+  module BuilderDSLMethods
+    def add_mapping(&block)
+      instance_eval &block
+      apply_commands!
     end
 
+    def rule(to: nil, from: to, converter: nil, object_converter: nil, is_collection: nil, lazy_loading: nil)
+      self.all_commands_applied = false
+
+      NormalizedParameters.new(to, from, converter, object_converter, is_collection, lazy_loading).each do |to, from, converter, lazy_loading|
+        build_commands.push  ->{ converter_class.map(to: to, from: from , converter: converter, lazy_loading: lazy_loading) }
+      end
+    end
+
+    def fetch_with(new_fetcher)
+      self.fetcher = new_fetcher
+    end
+
+    def with_strategy(new_strategy)
+      self.strategy = new_strategy
+    end
+
+    def build_commands_ordered
+      if command_order == :recorded_order
+        build_commands
+      else
+        build_commands.reverse
+      end
+    end
   end
 
 
   class ConverterBuilder
+    include BuilderDSLMethods
+
     attr_accessor  :build_commands, :command_order,
                    :strategy, :all_commands_applied
 
@@ -60,19 +100,6 @@ module Yaoc
       self.all_commands_applied = false
     end
 
-    def add_mapping(&block)
-      instance_eval &block
-      apply_commands!
-    end
-
-    def rule(to: nil, from: to, converter: nil, object_converter: nil, is_collection: nil)
-      self.all_commands_applied = false
-
-      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
-
     def apply_commands!
       reset_converters!
       self.all_commands_applied = true
@@ -120,22 +147,6 @@ module Yaoc
       @fetcher ||= :fetch
     end
 
-    def fetch_with(new_fetcher)
-      self.fetcher = new_fetcher
-    end
-
-    def with_strategy(new_strategy)
-      self.strategy = new_strategy
-    end
-
-    def build_commands_ordered
-      if command_order == :recorded_order
-        build_commands
-      else
-        build_commands.reverse
-      end
-    end
-
     def reset_converters!
       @converter_class = nil
     end

data/lib/yaoc/helper/to_proc_delegator.rb

@@ -0,0 +1,33 @@
+module Yaoc
+  module Helper
+    class ToProcDelegator < SimpleDelegator
+      attr_accessor :_initialisation_proc, :_initialisation_proc_loaded
+
+      def initialize(_initialisation_proc)
+        super(nil).tap do
+          self._initialisation_proc = _initialisation_proc
+          self._initialisation_proc_loaded = false
+        end
+      end
+
+
+      def __getobj__
+        unless self._initialisation_proc_loaded
+          self._initialisation_proc_loaded = true
+          __setobj__(self._initialisation_proc.call())
+        end
+
+        super
+      end
+
+      def class
+        __getobj__.class
+      end
+
+      def kind_of?(some_class)
+        super || __getobj__.kind_of?(some_class)
+      end
+
+    end
+  end
+end

data/lib/yaoc/mapping_base.rb

@@ -1,6 +1,5 @@
 module Yaoc
   module MappingBase
-    include AbstractType
 
     def self.included(other)
       other.extend(ClassMethods)
@@ -19,13 +18,31 @@ module Yaoc
     end
 
     def call
-      self.class.mapping_strategy.call(self)
+      unless to_convert.nil?
+        self.class.mapping_strategy.call(self)
+      else
+        nil
+      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
@@ -36,11 +53,14 @@ module Yaoc
     end
 
     module ClassMethods
-      include AbstractType
 
-      def converter_proc(to, from)
+      def converter_proc(to, from, deferred=false)
         -> (to_convert, result){
-          fill_result_with_value(result, to, to_convert.public_send(fetcher, from))
+          get_value_with = ->{
+            to_convert.public_send(fetcher, from)
+          }
+
+          fill_result_from_proc(result, to, get_value_with, deferred)
         }
       end
 
@@ -52,9 +72,11 @@ module Yaoc
         @mapping_strategy
       end
 
-      def map(to, from, block=nil)
+      def map(to: nil, from: to, converter: nil, lazy_loading: false)
         class_private_module(:Mapping).tap do |mod|
-          mod.send :define_method, "map_#{"%04d" %[converter_methods.count]}_#{from}_to_#{to}".to_sym, (block || converter_proc(to, from))
+          method_implementation = converter || converter_proc(to, from, lazy_loading)
+
+          mod.send :define_method, "map_#{"%04d" %[converter_methods.count]}_#{from}_to_#{to}".to_sym, method_implementation
           include mod
         end
       end

data/lib/yaoc/mapping_to_class.rb

@@ -9,10 +9,14 @@ module Yaoc
     module InstanceMethods
       def call(pre_created_object=nil)
         source_converted_to_hash_or_array = super()
-        if pre_created_object.nil?
-          create_target_from_class(source_converted_to_hash_or_array)
+        unless source_converted_to_hash_or_array.nil?
+          if pre_created_object.nil?
+            create_target_from_class(source_converted_to_hash_or_array)
+          else
+            fill_target_object(source_converted_to_hash_or_array, pre_created_object)
+          end
         else
-          fill_target_object(source_converted_to_hash_or_array, pre_created_object)
+          nil
         end
       end
 

data/lib/yaoc/object_mapper.rb

@@ -1,47 +1,18 @@
 module Yaoc
 
-  class ObjectMapper
-    attr_accessor :load_result_source, :dump_result_source
-
-    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, object_to_fill=nil)
-      converter(fetch_able).call(object_to_fill)
-    end
-
-    def dump(object, object_to_fill=nil)
-      reverse_converter(object).call(object_to_fill)
-    end
-
+  module MapperDSLMethods
     def add_mapping(&block)
       instance_eval &block
-      apply_commands
-    end
-
-    def converter(fetch_able=nil)
-      converter_builder.converter(fetch_able, load_result_source)
-    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!
+      apply_commands!
     end
 
     def rule(to: nil, from: to, converter: nil,
-             reverse_to: from,
-             reverse_from: to,
-             reverse_converter: nil,
-             object_converter: nil,
-             is_collection: nil)
+        reverse_to: from,
+        reverse_from: to,
+        reverse_converter: nil,
+        object_converter: nil,
+        is_collection: nil,
+        lazy_loading: nil)
 
       object_converter = Array(object_converter)
 
@@ -51,6 +22,7 @@ module Yaoc
           converter: converter,
           object_converter: object_converter.map(&:converter),
           is_collection: is_collection,
+          lazy_loading: lazy_loading
       )
 
       reverse_converter_builder.rule(
@@ -59,6 +31,7 @@ module Yaoc
           converter: reverse_converter,
           object_converter: object_converter.map(&:reverse_converter),
           is_collection: is_collection,
+          lazy_loading: lazy_loading
       )
     end
 
@@ -77,6 +50,40 @@ module Yaoc
     def reverse_strategy(new_strategy)
       reverse_converter_builder.strategy = new_strategy
     end
+  end
+
+  class ObjectMapper
+    include MapperDSLMethods
+
+    attr_accessor :load_result_source, :dump_result_source
+
+    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, object_to_fill=nil)
+      converter(fetch_able).call(object_to_fill)
+    end
+
+    def dump(object, object_to_fill=nil)
+      reverse_converter(object).call(object_to_fill)
+    end
+
+    def converter(fetch_able=nil)
+      converter_builder.converter(fetch_able, load_result_source)
+    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 converter_builder
       @converter_builder ||= Yaoc::ConverterBuilder.new()

data/lib/yaoc/version.rb

@@ -1,3 +1,3 @@
 module Yaoc
-  VERSION = "0.0.6"
+  VERSION = "0.0.7"
 end

data/spec/acceptance/map_to_objects_with_lazy_loading_spec.rb

@@ -0,0 +1,59 @@
+require "spec_helper"
+
+feature "Map objects to classes with lazy loading", %q{
+   In order to defer object mapping
+   as a lib user
+   I want to map object from an input object to an output object with lazy loading support
+} do
+
+  given(:mapper){
+    Yaoc::ObjectMapper.new(new_user_class, old_user_class).tap do |mapper|
+      mapper.add_mapping do
+        fetcher :public_send
+        rule to: [:id, :names],
+             lazy_loading: [false, true]
+      end
+    end
+  }
+
+  given(:new_user_class){
+    Yaoc::Helper::StructHE(:id, :names)
+  }
+
+  given(:old_user_class){
+    Yaoc::Helper::StructHE(:id, :names)
+  }
+
+  given(:existing_old_user){
+    old_user_class.new(
+        id: 'existing_user_2',
+        names: ['first_name', 'second_name']
+    )
+  }
+
+  given(:existing_user){
+    new_user_class.new(
+        id: 'existing_user_2',
+        names: ['first_name', 'second_name']
+    )
+  }
+
+  scenario "creates an result object from an input_object deferred" do
+    converted_user = mapper.load(existing_old_user)
+    new_names = ["new_name1", "new_name2"]
+
+    existing_old_user.names = new_names # show defer through changes after loading an object
+
+    expect(converted_user.names).to eq new_names
+  end
+
+  scenario "dumps an result object as source object defered" do
+    converted_user = mapper.dump(existing_user)
+    new_names = ["new_name1", "new_name2"]
+
+    existing_user.names = new_names # show defer through changes after loading an object
+
+    expect(converted_user.names).to eq new_names
+  end
+
+end

data/spec/spec_helper.rb

@@ -1,18 +1,17 @@
 require 'bundler/setup'
 Bundler.require(:development)
 
+require 'coveralls'
+Coveralls.wear! unless ENV["SIMPLE_COVERAGE"]
 
 begin
-  if ENV["COVERAGE"]
+  if ENV["SIMPLE_COVERAGE"]
     require 'simplecov'
     SimpleCov.start do
       add_group "Lib", "lib"
 
       add_filter "/spec/"
     end
-  else
-    require 'coveralls'
-    Coveralls.wear!
   end
 rescue LoadError
   warn "=" * 80

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

@@ -16,13 +16,27 @@ describe Yaoc::ConverterBuilder do
     double("converter", call: nil)
   }
 
+  let(:default_map_args){
+    {
+        to: :id,
+        from: :id,
+        converter: nil,
+        lazy_loading: false
+    }
+  }
+
   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)
+      expected_args_first = default_map_args.clone
+      expected_args_second = default_map_args.clone
+
+      expected_args_second[:to] = expected_args_second[:from] = :name
+
+      expect(converter_class).to receive(:map).ordered.with(expected_args_first)
+      expect(converter_class).to receive(:map).ordered.with(expected_args_second)
 
       subject.add_mapping do
         rule to: :id
@@ -34,8 +48,11 @@ describe Yaoc::ConverterBuilder do
     it "applies command in reverse recorded order when wanted" do
       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)
+      expected_args_first = default_map_args.clone.merge({to: :name, from: :name})
+      expected_args_second = default_map_args.clone
+
+      expect(converter_class).to receive(:map).ordered.with(expected_args_first)
+      expect(converter_class).to receive(:map).ordered.with(expected_args_second)
 
       subject.add_mapping do
         rule to: :id
@@ -64,8 +81,7 @@ describe Yaoc::ConverterBuilder do
 
   describe "#rule" do
     it "creates a converter" do
-
-      expect(converter_class).to receive(:map).with(:id, :id2, :some_proc)
+      expect(converter_class).to receive(:map).with(to: :id, from: :id2, converter: :some_proc, lazy_loading: false)
 
       subject.add_mapping do
         rule to: :id,
@@ -76,7 +92,7 @@ describe Yaoc::ConverterBuilder do
     end
 
     it "uses defaults" do
-      expect(converter_class).to receive(:map).with(:id, :id, nil)
+      expect(converter_class).to receive(:map).with(default_map_args)
 
       subject.add_mapping do
         rule to: :id
@@ -85,8 +101,11 @@ describe Yaoc::ConverterBuilder do
     end
 
     it "allows to use array of attributes" do
-      expect(converter_class).to receive(:map).ordered.with(:id, :id, nil)
-      expect(converter_class).to receive(:map).ordered.with(:name, :name, nil)
+      expected_args_first = default_map_args.clone
+      expected_args_second = default_map_args.clone.merge({to: :name, from: :name})
+
+      expect(converter_class).to receive(:map).ordered.with(expected_args_first)
+      expect(converter_class).to receive(:map).ordered.with(expected_args_second)
 
       subject.add_mapping do
         rule to: [:id, :name]
@@ -94,8 +113,12 @@ describe Yaoc::ConverterBuilder do
     end
 
     it "use the right 'to' when 'from' in arrays is missing" do
-      expect(converter_class).to receive(:map).ordered.with(:id, :r_id, nil)
-      expect(converter_class).to receive(:map).ordered.with(:name, :name, nil)
+      expected_args_first = default_map_args.clone.merge({from: :r_id})
+      expected_args_second = default_map_args.clone.merge({to: :name, from: :name})
+
+
+      expect(converter_class).to receive(:map).ordered.with(expected_args_first)
+      expect(converter_class).to receive(:map).ordered.with(expected_args_second)
 
       subject.add_mapping do
         rule to: [:id, :name],
@@ -104,7 +127,7 @@ describe Yaoc::ConverterBuilder do
     end
 
     it "supports the use of a object converter" do
-      expect(converter_class).to receive(:map).ordered.with(:id, :id, kind_of(Proc))
+      expect(converter_class).to receive(:map).ordered.with(to: :id, from: :id, converter: kind_of(Proc), lazy_loading: false)
       other_converter = :some_converter
 
       subject.add_mapping do
@@ -115,7 +138,9 @@ describe Yaoc::ConverterBuilder do
     end
 
     it "supports the collection flag for object converters" do
-      expect(converter_class).to receive(:map).ordered.with(:id, :id, kind_of(Proc))
+      expected_args = default_map_args.clone.merge({converter: kind_of(Proc)})
+
+      expect(converter_class).to receive(:map).ordered.with(expected_args)
       other_converter = :some_converter
 
       subject.add_mapping do
@@ -125,6 +150,17 @@ describe Yaoc::ConverterBuilder do
       end
 
     end
+
+    it "supports lazy loading" do
+      expected_args = default_map_args.clone.merge({lazy_loading: true})
+
+      expect(converter_class).to receive(:map).ordered.with(expected_args)
+
+      subject.add_mapping do
+        rule to: :id,
+             lazy_loading: true
+      end
+    end
   end
 
   describe "#converter" do

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

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe Yaoc::Helper::ToProcDelegator do
+  subject{
+    Yaoc::Helper::ToProcDelegator.new(lazy_proc)
+  }
+
+  let(:lazy_proc){
+    ->{
+      [:some_value]
+    }
+  }
+
+  it 'evaluates a proc not with initialisation' do
+    expect(lazy_proc).not_to receive :call
+    Yaoc::Helper::ToProcDelegator.new(lazy_proc)
+  end
+
+  it 'evaluates a proc when methods are delegated' do
+    expect(lazy_proc).to receive(:call)
+    subject.respond_to? :some_method_name
+  end
+
+  it 'delegates to the proc result' do
+    expect(subject.first).to eq :some_value
+  end
+
+  describe 'kind_of?' do
+
+    it 'returns true when class is "real class"' do
+      expect(subject).to be_kind_of Yaoc::Helper::ToProcDelegator
+    end
+
+    it 'returns true when class is delegated class' do
+      expect(subject).to be_kind_of lazy_proc.call.class
+    end
+
+    it 'returns false for other classes' do
+      expect(subject).not_to be_kind_of String
+    end
+
+  end
+
+end

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

@@ -17,7 +17,7 @@ describe Yaoc::MappingBase do
 
   describe "created module" do
     it "can be inspected" do
-      subject.map(:foo, :bar)
+      subject.map(to: :foo, from: :bar)
       expect(subject.class_private_module.inspect).to include("map_0000_bar_to_foo")
     end
   end
@@ -25,24 +25,44 @@ describe Yaoc::MappingBase do
   describe ".map" do
 
     it "creates a bunch of mapping methods" do
-      subject.map(:foo, :bar)
-      subject.map(:bar, :foo)
+      subject.map(to: :foo, from: :bar)
+      subject.map(to: :bar, from: :foo)
 
       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
-      subject.map(:bar, :foo, ->(*){})
+      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
     it "preserves method order" do
-      subject.map(0, 1, ->(*){})
-      subject.map(1, :a, ->(*){})
+      subject.map(to: 0, from: 1, converter: ->(*){})
+      subject.map(to: 1, from: :a, converter: ->(*){})
 
       expect(subject.converter_methods).to eq [:map_0000_1_to_0, :map_0001_a_to_1]
     end
@@ -71,13 +91,21 @@ describe Yaoc::MappingBase do
   end
 
   describe "#call" do
-    it "delegates execution to strategy" do
-      mapper = subject.new()
+    let(:mapper){
+      subject.new(:some_thing)
+    }
 
+    it "delegates execution to strategy" do
       expect(subject.mapping_strategy).to receive(:call).with mapper
 
       mapper.call
     end
+
+    it "return nil when to_convert is nil" do
+      mapper.to_convert = nil
+      expect(mapper.call).to be_nil
+    end
+
   end
 
   describe "#to_proc" do

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

@@ -25,6 +25,10 @@ describe Yaoc::MappingToClass do
           {:name => :new_name}
         }
 
+        def to_convert
+          :some_thing
+        end
+
       end.new(expected_class)
     }
 
@@ -61,6 +65,11 @@ describe Yaoc::MappingToClass do
       expect(obj.name).to eq :new_name
       expect(obj.id).to eq :my_id
     end
+
+    it "returns nil when nothing to convert" do
+      subject.stub(to_convert: nil)
+      expect(subject.call).to be_nil
+    end
   end
 
   describe "#to_a" do

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

@@ -30,7 +30,8 @@ describe Yaoc::ObjectMapper do
         from: :id,
         converter: nil,
         object_converter: [],
-        is_collection: nil
+        is_collection: nil,
+        lazy_loading: nil,
     }
   }
 

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

@@ -23,16 +23,16 @@ describe Yaoc::Strategies::ToArrayMapping do
   describe ".call" do
 
     it "creates a hash from a object" do
-      subject.map(0, :id)
-      subject.map(1, :name)
+      subject.map(to: 0, from: :id)
+      subject.map(to: 1, from: :name)
 
       expect(mapper.call).to eq(expected_array)
     end
 
 
     it "uses my converter proc" do
-      subject.map(0, :id)
-      subject.map(3, :fullname, ->(source, result){ fill_result_with_value(result, 3, "#{source.fetch(:name)} Hello World") })
+      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") })
 
       ext_expectation = expected_array.clone
       ext_expectation[3] = "#{ext_expectation[1]} Hello World"
@@ -48,8 +48,8 @@ describe Yaoc::Strategies::ToArrayMapping do
       }
 
       it "uses custom fetcher methods" do
-        subject.map(0, :id)
-        subject.map(1, :name)
+        subject.map(to: 0, from: :id)
+        subject.map(to: 1, from: :name)
 
         def mapper.fetcher
           :public_send
@@ -59,8 +59,8 @@ describe Yaoc::Strategies::ToArrayMapping do
       end
 
       it "works with arrays" do
-        subject.map(1, 0)
-        subject.map(0, 1)
+        subject.map(to: 1, from: 0)
+        subject.map(to: 0, from: 1)
 
         def mapper.fetcher
           :[]

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

@@ -23,15 +23,15 @@ describe Yaoc::Strategies::ToHashMapping do
   describe "#call" do
 
     it "creates a hash from a object" do
-      subject.map(:id, :id)
-      subject.map(:name, :name)
+      subject.map(to: :id, from: :id)
+      subject.map(to: :name, from: :name)
 
       expect(mapper.call).to eq(expected_hash)
     end
 
     it "renames attributes" do
-      subject.map(:id, :id)
-      subject.map(:fullname, :name)
+      subject.map(to: :id)
+      subject.map(to: :fullname, from: :name)
 
       renamed_expectation = expected_hash.clone
       renamed_expectation[:fullname] = renamed_expectation.delete :name
@@ -40,8 +40,8 @@ describe Yaoc::Strategies::ToHashMapping do
     end
 
     it "uses my converter proc" do
-      subject.map(:id, :id)
-      subject.map(:name, :fullname, ->(source, result){ fill_result_with_value(result, :name, source.fetch(:name) + " Hello World") })
+      subject.map(to: :id)
+      subject.map(to: :name, from: :fullname, converter: ->(source, result){ fill_result_with_value(result, :name, source.fetch(:name) + " Hello World") })
 
       ext_expectation = expected_hash.clone
       ext_expectation[:name] += " Hello World"
@@ -55,8 +55,8 @@ describe Yaoc::Strategies::ToHashMapping do
       }
 
       it "uses custom fetcher methods" do
-        subject.map(:id, :id)
-        subject.map(:name, :name)
+        subject.map(to: :id)
+        subject.map(to: :name)
 
         def mapper.fetcher
           :public_send
@@ -66,8 +66,8 @@ describe Yaoc::Strategies::ToHashMapping do
       end
 
       it "works with arrays" do
-        subject.map(:id, 0)
-        subject.map(:name, 1)
+        subject.map(to: :id, from: 0)
+        subject.map(to: :name, from: 1)
 
         def mapper.fetcher
           :[]

data/yaoc.gemspec

@@ -20,8 +20,6 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = '>= 2.0.0'
 
-  spec.add_runtime_dependency "abstract_type", '~> 0.0.7'
-
   spec.add_development_dependency "bundler", "~> 1.5"
   spec.add_development_dependency "rake"
 

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: yaoc
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.7
 platform: ruby
 authors:
 - Dieter Späth
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-27 00:00:00.000000000 Z
+date: 2014-01-28 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: abstract_type
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.0.7
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.0.7
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -225,9 +211,12 @@ files:
 - examples/03_positional_constructors.rb
 - examples/04_compositions.rb
 - examples/05_fill_existing_objects.rb
+- examples/06_lazy_loading.rb
+- examples/all_examples.rb
 - lib/yaoc.rb
 - lib/yaoc/converter_builder.rb
 - lib/yaoc/helper/struct_hash_constructor.rb
+- lib/yaoc/helper/to_proc_delegator.rb
 - lib/yaoc/mapping_base.rb
 - lib/yaoc/mapping_to_class.rb
 - lib/yaoc/object_mapper.rb
@@ -237,12 +226,14 @@ files:
 - spec/acceptance/fill_existing_objects_spec.rb
 - spec/acceptance/map_objects_spec.rb
 - spec/acceptance/map_to_objects_using_other_converters_spec.rb
+- spec/acceptance/map_to_objects_with_lazy_loading_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/helper/struct_hash_constructor_spec.rb
+- spec/unit/lib/yaoc/helper/to_proc_delegator_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
@@ -277,12 +268,14 @@ test_files:
 - spec/acceptance/fill_existing_objects_spec.rb
 - spec/acceptance/map_objects_spec.rb
 - spec/acceptance/map_to_objects_using_other_converters_spec.rb
+- spec/acceptance/map_to_objects_with_lazy_loading_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/helper/struct_hash_constructor_spec.rb
+- spec/unit/lib/yaoc/helper/to_proc_delegator_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