yaoc 0.0.13 → 0.0.14

data/lib/yaoc/helper/struct_hash_constructor.rb

@@ -6,11 +6,11 @@ module Yaoc
       end
 
       module Initializer
-        def initialize(params={})
+        def initialize(params = {})
           super()
 
           params.each do |attr, value|
-            self.public_send("#{attr}=", value)
+            public_send("#{attr}=", value)
           end if params
         end
       end
@@ -28,6 +28,5 @@ module Yaoc
         include Equalizer.new(*args)
       end
     end
-
   end
-end
+end

data/lib/yaoc/helper/to_proc_delegator.rb

@@ -12,11 +12,10 @@ module Yaoc
         end
       end
 
-
       def __getobj__
-        unless self._initialisation_proc_loaded
+        unless _initialisation_proc_loaded
           self._initialisation_proc_loaded = true
-          __setobj__(self._initialisation_proc.call())
+          __setobj__(_initialisation_proc.call)
         end
 
         super
@@ -35,13 +34,12 @@ module Yaoc
       end
 
       def _initialisation_proc_loaded?
-        self._initialisation_proc_loaded
+        _initialisation_proc_loaded
       end
 
       def _needs_conversion?
         _initialisation_proc_loaded? && ! nil?
       end
-
     end
   end
-end
+end

data/lib/yaoc/many_to_one_mapper_chain.rb

@@ -10,18 +10,18 @@ module Yaoc
       self.converter = converter
     end
 
-    def load_first(input_object, object_to_fill=nil)
+    def load_first(input_object, object_to_fill = nil)
       converter_iterator.rewind
       self.next_result = converter_iterator.next.load(input_object, object_to_fill)
     end
 
     def load_next(input_object)
-      self.next_result = converter_iterator.next.load(input_object, self.next_result)
+      self.next_result = converter_iterator.next.load(input_object, next_result)
     rescue StopIteration
-      raise "ToManyInputObjects"
+      raise 'ToManyInputObjects'
     end
 
-    def load_all(input_objects, object_to_fill=nil)
+    def load_all(input_objects, object_to_fill = nil)
       each_object_with_converter(input_objects) do |converter, input_object|
         object_to_fill = converter.load(input_object, object_to_fill)
       end
@@ -29,17 +29,16 @@ module Yaoc
       self.last_result = object_to_fill
     end
 
-    def dump_first(input_object, object_to_fill=nil)
+    def dump_first(input_object, object_to_fill = nil)
       converter_iterator.rewind
       self.next_result = converter_iterator.next.dump(input_object, object_to_fill)
     end
 
     def dump_next(input_object)
-      self.next_result = converter_iterator.next.dump(input_object, self.next_result)
+      self.next_result = converter_iterator.next.dump(input_object, next_result)
     end
 
-    def dump_all(input_objects, object_to_fill=nil)
-
+    def dump_all(input_objects, object_to_fill = nil)
       each_object_with_converter(input_objects) do |converter, input_object|
         object_to_fill = converter.dump(input_object, object_to_fill)
       end
@@ -50,16 +49,16 @@ module Yaoc
     protected
 
     def converter=(new_converter)
-      @converter = new_converter.map{|converter| converter.is_a?(Symbol) ? ManyToOneMapperChain.registry.for(converter) : converter}
+      @converter = new_converter.map { |converter| converter.is_a?(Symbol) ? ManyToOneMapperChain.registry.for(converter) : converter }
     end
 
     def converter_iterator
-      @converter_iterator ||= self.converter.each
+      @converter_iterator ||= converter.each
     end
 
     def each_object_with_converter(input_objects)
       it_input_objects = input_objects.each
-      it_converters = self.converter.each
+      it_converters = converter.each
 
       loop do
         begin
@@ -73,6 +72,5 @@ module Yaoc
         end
       end
     end
-
   end
-end
+end

data/lib/yaoc/mapper_registry.rb

@@ -3,11 +3,11 @@ module Yaoc
     module_function
 
     def scope_storage(new_storage)
-      @scope = ScopedStorage::Scope.new("mappings", new_storage)
+      @scope = ScopedStorage::Scope.new('mappings', new_storage)
     end
 
     def scope
-      @scope ||= ScopedStorage::Scope.new("mappings")
+      @scope ||= ScopedStorage::Scope.new('mappings')
     end
 
     def add(key, mapper)
@@ -17,6 +17,5 @@ module Yaoc
     def for(key)
       scope[key.to_sym]
     end
-
   end
-end
+end

data/lib/yaoc/mapping_base.rb

@@ -1,12 +1,11 @@
 module Yaoc
   module MappingBase
-
     def self.included(other)
       other.extend(ClassMethods)
     end
 
     def to_proc
-      ->(to_convert){
+      ->(to_convert)do
         old_to_convert = self.to_convert
         begin
           self.to_convert = to_convert
@@ -14,7 +13,7 @@ module Yaoc
         ensure
           self.to_convert = old_to_convert
         end
-      }
+      end
     end
 
     def call
@@ -26,7 +25,6 @@ module Yaoc
     end
     alias_method :to_hash_or_array, :call
 
-
     def converter_methods
       self.class.converter_methods
     end
@@ -36,7 +34,6 @@ module Yaoc
     end
 
     module ClassMethods
-
       def mapping_strategy=(new_strat)
         @mapping_strategy = new_strat
       end
@@ -49,18 +46,22 @@ module Yaoc
         class_private_module(:Mapping).tap do |mod|
           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
+          method_name = "map_#{"%04d" % [converter_methods.count]}_#{from}_to_#{to}".to_sym
+          converter_methods << method_name
+
+          converter_methods.sort!.uniq!
+
+          mod.send :define_method, method_name, method_implementation
           include mod
         end
       end
 
       def converter_methods
-        class_private_module(:Mapping).instance_methods(false).sort
+        @converter_methods ||= []
       end
 
       # inspired by Avdi Grimm, rubytapas.com 028-macros-and-modules
-      def class_private_module(name=:Mapping)
-
+      def class_private_module(name = :Mapping)
         if const_defined?(name, false)
           const_get(name)
         else
@@ -76,8 +77,6 @@ module Yaoc
           const_set(name, new_mod)
         end
       end
-
     end
-
   end
-end
+end

data/lib/yaoc/mapping_to_class.rb

@@ -1,14 +1,13 @@
 module Yaoc
   module MappingToClass
-
     def self.included(other)
       other.send(:include, MappingBase)
       other.send(:include, InstanceMethods)
     end
 
     module InstanceMethods
-      def call(pre_created_object=nil)
-        source_converted_to_hash_or_array = to_hash_or_array()
+      def call(pre_created_object = nil)
+        source_converted_to_hash_or_array = 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)
@@ -22,21 +21,21 @@ module Yaoc
       alias_method :to_object, :call
 
       def source_method
-        self.target_source.respond_to?(:call) ? :call : :new
+        target_source.respond_to?(:call) ? :call : :new
       end
 
       def create_target_from_class(args)
         array_based_constructor = args.is_a? Array
 
         if array_based_constructor
-          self.target_source.send(source_method, *args)
+          target_source.send(source_method, *args)
         else
-          self.target_source.send(source_method, args)
+          target_source.send(source_method, args)
         end
       end
 
       def fill_target_object(attribute_hash, pre_created_object)
-        raise "UnexpectedStrategy" unless attribute_hash.respond_to? :each_pair
+        fail 'UnexpectedStrategy' unless attribute_hash.respond_to? :each_pair
 
         attribute_hash.each_pair do |key, value|
           pre_created_object.send("#{key}=", value)
@@ -49,6 +48,5 @@ module Yaoc
         [self]
       end
     end
-
   end
-end
+end

data/lib/yaoc/object_mapper.rb

@@ -1,5 +1,4 @@
 module Yaoc
-
   module MapperDSLMethods
     def add_mapping(&block)
       instance_eval &block
@@ -18,8 +17,8 @@ module Yaoc
         lazy_loading: nil,
         reverse_lazy_loading: lazy_loading)
 
-      object_converter = Array(object_converter).map{|converter| converter.is_a?(Symbol) ? registry.for(converter) : converter}
-      reverse_object_converter = Array(reverse_object_converter).map{|converter| converter.is_a?(Symbol) ? registry.for(converter) : converter}
+      object_converter = Array(object_converter).map { |converter| converter.is_a?(Symbol) ? registry.for(converter) : converter }
+      reverse_object_converter = Array(reverse_object_converter).map { |converter| converter.is_a?(Symbol) ? registry.for(converter) : converter }
 
       converter_builder.rule(
           to: to,
@@ -57,13 +56,12 @@ module Yaoc
     end
 
     def noop
-      ->(_, result){ result }
+      ->(_, result) { result }
     end
 
     def register_as(name)
       registry.add(name, self) unless name.nil?
     end
-
   end
 
   class ObjectMapper
@@ -71,25 +69,25 @@ module Yaoc
 
     attr_accessor :load_result_source, :dump_result_source, :registry
 
-    def initialize(load_result_source, dump_result_source=nil, registry=Yaoc::MapperRegistry)
+    def initialize(load_result_source, dump_result_source = nil, registry = Yaoc::MapperRegistry)
       self.load_result_source = load_result_source
       self.dump_result_source = dump_result_source
       self.registry = registry
     end
 
-    def load(fetch_able, object_to_fill=nil)
+    def load(fetch_able, object_to_fill = nil)
       converter(fetch_able).call(object_to_fill)
     end
 
-    def dump(object, object_to_fill=nil)
+    def dump(object, object_to_fill = nil)
       reverse_converter(object).call(object_to_fill)
     end
 
-    def converter(fetch_able=nil)
+    def converter(fetch_able = nil)
       converter_builder.converter(fetch_able, load_result_source)
     end
 
-    def reverse_converter(fetch_able=nil)
+    def reverse_converter(fetch_able = nil)
       reverse_converter_builder.converter(fetch_able, dump_result_source)
     end
 
@@ -113,12 +111,11 @@ module Yaoc
     end
 
     def converter_builder
-      @converter_builder ||= Yaoc::ConverterBuilder.new()
+      @converter_builder ||= Yaoc::ConverterBuilder.new
     end
 
     def reverse_converter_builder
       @reverse_converter_builder ||= Yaoc::ConverterBuilder.new(:reverse_order, :public_send)
     end
-
   end
-end
+end

data/lib/yaoc/one_to_many_mapper_chain.rb

@@ -10,7 +10,7 @@ module Yaoc
       self.converter = converter
     end
 
-    def load_all(input_object, objects_to_fill=[])
+    def load_all(input_object, objects_to_fill = [])
       objects_to_fill = Array(objects_to_fill)
       results = []
 
@@ -21,7 +21,7 @@ module Yaoc
       self.last_result = results
     end
 
-    def dump_all(input_object, objects_to_fill=nil)
+    def dump_all(input_object, objects_to_fill = nil)
       objects_to_fill = Array(objects_to_fill)
       results = []
 
@@ -35,17 +35,15 @@ module Yaoc
     protected
 
     def converter=(new_converter)
-      @converter = new_converter.map{|converter| converter.is_a?(Symbol) ? OneToManyMapperChain.registry.for(converter) : converter}
+      @converter = new_converter.map { |converter| converter.is_a?(Symbol) ? OneToManyMapperChain.registry.for(converter) : converter }
     end
 
     def each_object_with_converter(objects_to_fill)
-
       converter.each_with_index do |converter, index|
         object_to_fill = objects_to_fill[index]
 
         yield converter, object_to_fill
       end
     end
-
   end
-end
+end

data/lib/yaoc/strategies/to_array_mapping.rb

@@ -1,7 +1,6 @@
 module Yaoc
   module Strategies
     module ToArrayMapping
-
       def self.call(conv_object)
         [].tap do |result|
           conv_object.converter_methods.each do |method_name|
@@ -9,7 +8,6 @@ module Yaoc
           end
         end
       end
-
     end
   end
-end
+end

data/lib/yaoc/strategies/to_hash_mapping.rb

@@ -1,13 +1,11 @@
 module Yaoc
   module Strategies
     module ToHashMapping
-
       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
-
     end
   end
-end
+end

data/lib/yaoc/transformation_command.rb

@@ -1,7 +1,19 @@
 module Yaoc
   class TransformationCommand
+    module WithProc
+      def call(to_convert, result)
+        instance_exec(to_convert, result, &proc)
+      end
+    end
+
+    module WithoutProc
+      def call(to_convert, result)
+        TransformationCommand.fill_result_with_value(result, to, value(to_convert))
+      end
+    end
 
     protected
+
     attr_accessor :to, :from, :fetcher , :proc, :value_fetcher_proc
 
     public
@@ -18,13 +30,13 @@ module Yaoc
       # will be executed in mapper object instance context later through :define_method
       tc_source = deferred ? deferred_source : default_source
 
-      -> (to_convert, result){
+      -> (to_convert, result)do
         tc_source.new(to: to, from: from, fetch_method: fetcher, conversion_proc: conversion_proc, fetcher_proc: fetcher_proc).call(to_convert, result)
-      }
+      end
     end
 
     def self.fill_result_with_value(result, key, value)
-      result.tap{|taped_result| taped_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)
@@ -32,22 +44,29 @@ module Yaoc
       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)}
+      self.value_fetcher_proc = fetcher_proc || ->(to_convert, fetcher, from) { to_convert.public_send(fetcher, from) }
     end
 
-    def call(to_convert, result)
+    def proc=(new_proc)
+      @proc = new_proc
+
+      if new_proc.nil?
+        extend WithoutProc
+      else
+        extend WithProc
+      end
+    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
+end