activerecord_to_poro 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 73555a31ecff01b8d794c304d390d6a742480dff
-  data.tar.gz: 7966c2cd299ba10bb133ee76e421b928990c826d
+  metadata.gz: 22303b2e1fdea401dba91cc9d58cd87f13d3f711
+  data.tar.gz: 83b8bf5c084aa93fb5b5614369a049aaa763dd24
 SHA512:
-  metadata.gz: 0980c84cee2f41eed81bf1e588b849be5cdd0e435f125a42ade0631f13d970ce6e187e15a690c01c35d7010c2c83e81b458c19ec1abf5db2e07c0572726e31f4
-  data.tar.gz: c1de463a85bec7018d6bdfa855acd24758ba9a46523a8abf96f45cbeb78811acea5190d87b8941b824c5e4031407b9f3f91164203032978b389188f04a80119d
+  metadata.gz: 906060ece82669221ba6883bd97dfeb3ee0a862b634025896cfe97b5ddb4731fdf4c169e34bfd5d1dc8b6abb7551a50a0d3bcf16b5c08fd40b765a69032b9b53
+  data.tar.gz: 9b59fdd62577e984c6d0fdfc4a84cc8e31b12c53c29ada165f30de83302765c79e652b036c9551e511c3f1a42cca71f875e8cea640018d0c0b75b8c97ab9d4d2

data/Gemfile

@@ -7,4 +7,4 @@ gemspec
 gem 'simplecov', require:  false, group: :test
 gem 'coveralls', require: false
 
-gem 'yaoc', github: 'slowjack2k/yaoc', branch: 'master'
+gem 'yaoc', github: 'slowjack2k/yaoc', branch: 'master'

data/README.md

@@ -48,27 +48,29 @@ end
 
 # You can convert them to poro's like this (automatic genereation of a poro class out of you'r AR class)
 
-roles_converter = ActiverecordToPoro::Converter.new(Role)
-salutation_converter = ActiverecordToPoro::Converter.new(Salutation)
-user_converter = ActiverecordToPoro::Converter.new(User, convert_associations: {roles: roles_converter, salutation: salutation_converter})
+ActiverecordToPoro::ObjectMapper.create(Role, name: :roles_converter)
+ActiverecordToPoro::ObjectMapper.create(Salutation, name: :salutation_converter)
+user_converter = ActiverecordToPoro::ObjectMapper.create(User,
+                                                         name: :user_converter,
+                                                         convert_associations: {roles: :roles_converter, salutation: :salutation_converter})
 
 
 poro = user_converter.load(User.first)
 
-# Or with you'r custom class
+# Or with you'r custom poro class
 
-roles_converter = ActiverecordToPoro::Converter.new(Role,
-                                                    load_source: YourPoroClass
-                                                    )
+roles_converter = ActiverecordToPoro::ObjectMapper.create(Role,
+                                                          load_source: YourPoroClass
+                                                         )
 
 
 # default 1:1 mapping only or except
 
-roles_converter = ActiverecordToPoro::Converter.new(Role,
+roles_converter = ActiverecordToPoro::ObjectMapper.create(Role,
                                                     except: [:lock_version]
                                                     )
 
-roles_converter = ActiverecordToPoro::Converter.new(Role,
+roles_converter = ActiverecordToPoro::ObjectMapper.create(Role,
                                                     only: [:name]
                                                     )
 
@@ -83,7 +85,7 @@ end
 roles_converter.extend_mapping do
   association_rule to: association_name,
                    lazy_loading: true,
-                   converter: association_converter
+                   converter: association_converter #or :association_converter when you'r converter has a name
                    # optional
                    # from: ...,
                    # reverse_to: ...,

data/lib/activerecord_to_poro/mapper_extension.rb

@@ -2,26 +2,57 @@ module ActiverecordToPoro
   module MapperExtension
 
     def association_rule(to: nil,
-                         from: to,
-                         reverse_to: from,
-                         reverse_from: to,
-                         converter: nil,
-                         is_collection: false,
-                         lazy_loading: nil
-                        )
-
-      map_collection = (self.dump_result_source.reflections[from] &&
-                        self.dump_result_source.reflections[from].collection?) || is_collection
-
-      rule to: to,
-           from: from,
-           reverse_to: reverse_to,
-           reverse_from: reverse_from,
-           reverse_lazy_loading: false, #AR doesn't like ToProcDelegator
-           object_converter: converter.mapper,
-           is_collection: map_collection,
-           lazy_loading: lazy_loading
+        from: to,
+        reverse_to: from,
+        reverse_from: to,
+        converter: nil,
+        reverse_converter: converter,
+        is_collection: false,
+        lazy_loading: nil
+    )
+
+      map_collection =  ActiverecordToPoro::MapperExtension.is_an_ar_collection?(self.dump_result_source, from) || is_collection
+
+      options ={
+          to: to,
+          from: from,
+          reverse_to: reverse_to,
+          reverse_from: reverse_from,
+          reverse_lazy_loading: false, #AR doesn't like ToProcDelegator
+          is_collection: map_collection,
+          lazy_loading: lazy_loading
+      }
+
+      if converter.nil?
+        options[:converter] = noop
+        options[:object_converter] = nil
+      else
+        options[:object_converter] = converter#.mapper
+      end
+
+      if reverse_converter.nil? ||  ActiverecordToPoro::MapperExtension.is_an_has_many_through(self.dump_result_source, from)
+        options[:reverse_converter] = noop
+        options[:reverse_object_converter] = nil
+      else
+        options[:reverse_object_converter] =  reverse_converter#.mapper
+      end
+
+      rule options
 
     end
+
+    module_function
+
+    def is_an_ar_collection?(ar_class, association_name)
+      (ar_class.reflections[association_name] &&
+       ar_class.reflections[association_name].collection?)
+    end
+
+    def is_an_has_many_through(ar_class, association_name)
+      ar_class.reflections[association_name] &&
+      ar_class.reflections[association_name].macro == :has_many &&
+      ar_class.reflections[association_name].options.has_key?(:through)
+    end
+
   end
 end

data/lib/activerecord_to_poro/metadata.rb

@@ -1,21 +1,56 @@
 module ActiverecordToPoro
+  SourceObjectInfo = Yaoc::Helper::StructH(:class_name, :column, :value, :lock_version, :object_id) do
+
+    include Equalizer.new(:class_name, :column, :value)
+
+    def to_hash
+      {
+       class_name: class_name,
+       primary_key: {column: column, value: value},
+       object_id: object_id,
+       lock_version: lock_version
+      }
+    end
+
+    def as_scope_hash
+      result = column.nil? ? {} : {column => value}
+      result[:lock_version] = lock_version unless lock_version.nil?
+
+      result
+    end
+  end
+
   class Metadata
-    attr_accessor :primary_key_column, :primary_key_value
+    attr_accessor :source_object_info
 
+    def initialize()
+      self.source_object_info = Set.new()
+    end
 
     def initialize_from_ar(ar_object=nil)
       unless ar_object.nil?
-        set_primary_key(ar_object)
+        set_source_info(ar_object)
       end
     end
 
-    def set_primary_key(ar_object)
-      self.primary_key_column = ar_object.class.primary_key
-      self.primary_key_value = ar_object.send(self.primary_key_column)
+    def for_ar_class(ar_class_name)
+      Set.new.find
+      source_object_info.find(->{SourceObjectInfo.new}){|data|
+        data.class_name == ar_class_name
+      }
+    end
+
+    def set_source_info(ar_object)
+      self.source_object_info << SourceObjectInfo.new(class_name: ar_object.class.name,
+                                                      column: ar_object.class.primary_key,
+                                                      value: ar_object.send(ar_object.class.primary_key),
+                                                      object_id: ar_object.object_id,
+                                                      lock_version: ar_object.respond_to?(:lock_version) ? ar_object.lock_version : nil
+                                                     )
     end
 
     def to_hash
-      { self.primary_key_column => self.primary_key_value }
+      { source_objects_info: source_object_info.map(&:to_hash)  }
     end
 
   end

data/lib/activerecord_to_poro/metadata_enabled.rb

@@ -11,12 +11,4 @@ module ActiverecordToPoro
 
   end
 
-  module MetadataToAr
-    def _set_metadata_to_ar=(metadata)
-      metadata.each_pair do |attr, value|
-        self.send("#{attr}=", value)
-        @new_record = false
-      end
-    end
-  end
 end

data/lib/activerecord_to_poro/metadata_enabled_ar.rb

@@ -0,0 +1,32 @@
+module ActiverecordToPoro
+
+  module MetadataEnabledAr
+
+    def _from_attrs_with_metadata(attrs={}, pre_created_object= nil)
+      record_by_primary_key = _record_from_metadata!(attrs)
+
+      record = pre_created_object || record_by_primary_key || new
+
+      record.tap do |new_obj|
+        new_obj.attributes = attrs
+      end
+
+    end
+
+    def _as_scope(attr)
+      attr.empty? ? none : where(attr)
+    end
+
+    def _extract_metadata!(attrs)
+      metadata = (attrs || {}).delete(:_set_metadata_to_ar) {|*| Metadata.new}
+      metadata.for_ar_class(self.name)
+    end
+
+    def _record_from_metadata!(attrs)
+      specific_metadata = _extract_metadata!(attrs)
+      _as_scope(specific_metadata.as_scope_hash).first
+    end
+
+  end
+
+end

data/lib/activerecord_to_poro/object_mapper.rb

@@ -0,0 +1,103 @@
+module ActiverecordToPoro
+
+  module MappingToArClass
+    def call(pre_created_object=nil)
+      self.target_source._from_attrs_with_metadata(to_hash_or_array(), pre_created_object)
+    end
+  end
+
+  class ObjectMapper < Yaoc::ObjectMapper
+    include ColumnHelper
+    include ActiverecordToPoro::MapperExtension
+
+    attr_accessor :association_converters,
+                  :use_lazy_loading,
+                  :except_attributes,
+                  :only_attributes
+
+    class << self
+      private :new
+    end
+
+    def self.create(ar_class,
+                    use_lazy_loading=true,
+                    except: nil,
+                    only: nil,
+                    name: nil,
+                    load_source: DefaultPoroClassBuilder.new(ar_class).(),
+                    convert_associations: {})
+
+      new(load_source, ar_class).tap do|new_mapper|
+        new_mapper.fetcher(:public_send)
+
+        new_mapper.association_converters = convert_associations
+        new_mapper.use_lazy_loading = use_lazy_loading
+
+        new_mapper.except_attributes = Array(except)
+        new_mapper.only_attributes = only.nil? ? nil : Array(only) # an empty array can be wanted, so that there is no default mapping @ all
+
+        new_mapper.add_default_mapping_for_current_class
+        new_mapper.add_mapping_for_associations
+
+        new_mapper.register_as(name)
+      end
+    end
+
+    alias_method :extend_mapping, :add_mapping
+
+    def attributes_for_default_mapping
+      self.only_attributes || (
+                                columns(self.dump_result_source) -
+                                primary_keys(self.dump_result_source) -
+                                association_specific_columns(self.dump_result_source) -
+                                associated_object_accessors(self.dump_result_source) -
+                                self.except_attributes
+                              )
+    end
+
+    def load_result_source=(new_load_result)
+      @load_result_source = new_load_result.tap do |source|
+        unless source.instance_methods.include?(:_metadata)
+          source.send(:include, MetadataEnabled)
+        end
+      end
+    end
+
+    def dump_result_source=(new_dump_result)
+      @dump_result_source = new_dump_result.tap do |source|
+        unless source.respond_to? :_from_attrs_with_metadata
+          source.send(:extend, MetadataEnabledAr)
+        end
+      end
+    end
+
+    def add_default_mapping_for_current_class
+      add_mapping do
+        rule to: attributes_for_default_mapping
+
+        rule to: :_set_metadata,
+             converter: ->(source, result){ self.class.fill_result_with_value(result, :_set_metadata_from_ar, source) },
+             reverse_converter: ->(source, result){ self.class.fill_result_with_value(result, :_set_metadata_to_ar, source._metadata) }
+      end
+    end
+
+    def add_mapping_for_associations
+      association_converters.each_pair do |association_name, association_converter|
+
+        add_mapping do
+          association_rule to: association_name,
+                           lazy_loading: use_lazy_loading,
+                           converter: association_converter
+        end
+      end
+    end
+
+    def reverse_converter(fetch_able=nil)
+      reverse_converter_builder.converter(fetch_able, dump_result_source).tap do |new_converter|
+        new_converter.extend(MappingToArClass)
+      end
+    end
+
+  end
+
+end

data/lib/activerecord_to_poro/version.rb

@@ -1,3 +1,3 @@
 module ActiverecordToPoro
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/lib/activerecord_to_poro.rb

@@ -1,10 +1,12 @@
 require 'yaoc'
+require 'equalizer'
 require 'activerecord_to_poro/version'
 require 'activerecord_to_poro/metadata_enabled'
+require 'activerecord_to_poro/metadata_enabled_ar'
 require 'activerecord_to_poro/metadata'
 require 'activerecord_to_poro/default_poro_class_builder'
 require 'activerecord_to_poro/mapper_extension'
-require 'activerecord_to_poro/converter'
+require 'activerecord_to_poro/object_mapper'
 
 module ActiverecordToPoro
 

data/spec/acceptance/map_ar_associations_spec.rb

@@ -7,19 +7,29 @@ feature 'Map active record associations', %q{
 } do
 
   given!(:mapper){
-    ActiverecordToPoro::Converter.new(a_active_record_class, convert_associations: {roles: roles_converter, salutation: salutation_converter} )
+    ActiverecordToPoro::ObjectMapper.create(a_active_record_class, convert_associations: {roles: roles_converter,
+                                                                                       salutation: salutation_converter}).tap do |m|
+      quirk_converter = permissions_converter
+
+      m.extend_mapping do
+        association_rule to: :permissions,
+                         converter: quirk_converter,
+                         reverse_converter: nil,
+                         lazy_loading: true
+      end
+    end
   }
 
   given!(:roles_converter){
-    ActiverecordToPoro::Converter.new(Role)
+    ActiverecordToPoro::ObjectMapper.create(Role, convert_associations: {permissions: permissions_converter})
   }
 
   given!(:permissions_converter){
-    ActiverecordToPoro::Converter.new(Permission)
+    ActiverecordToPoro::ObjectMapper.create(Permission, name: :permissions_converter)
   }
 
   given!(:salutation_converter){
-    ActiverecordToPoro::Converter.new(Salutation)
+    ActiverecordToPoro::ObjectMapper.create(Salutation)
   }
 
   given!(:a_active_record_class){
@@ -53,22 +63,25 @@ feature 'Map active record associations', %q{
   }
 
   given(:mapper_with_custom_source){
-    ActiverecordToPoro::Converter.new(a_active_record_class,
-                                      load_source: a_custom_poro_class,
-                                      except: [:lock_version]
+    ActiverecordToPoro::ObjectMapper.create(a_active_record_class,
+                                         load_source: a_custom_poro_class,
+                                         except: [:lock_version]
     )
   }
 
 
   scenario "creates a poro out of an ActiveRecord object with associations set" do
     expect(mapper.load(a_active_record_object).roles.size).to eq 2
+    expect(mapper.load(a_active_record_object).permissions.size).to eq 3
     expect(mapper.load(a_active_record_object).salutation.name).to eq "Mister"
   end
 
   scenario "creates an ActiveRecord object from a poro object with associations set" do
     poro = mapper.load(a_active_record_object)
     expect(mapper.dump(poro).roles.size).to eq 2
-    expect(mapper.dump(poro).permissions.size).to eq 3
+
+    expect(mapper.dump(poro).roles.first.permissions.size).to eq 2
+    expect(mapper.dump(poro).roles.last.permissions.size).to eq 1
   end
 
   scenario "lazy loads associated objects" do
@@ -79,13 +92,12 @@ feature 'Map active record associations', %q{
   end
 
   scenario 'add custom association mappings' do
-    quirk_converter = permissions_converter
 
     mapper_with_custom_source.extend_mapping do
 
       association_rule to: :some_other_name,
                        from: :permissions,
-                       converter: quirk_converter,
+                       converter: :permissions_converter,
                        lazy_loading: true
 
     end

data/spec/acceptance/map_ar_objects_spec.rb

@@ -7,13 +7,13 @@ feature "Map active record objects", %q{
 } do
 
   given(:mapper){
-    ActiverecordToPoro::Converter.new(a_active_record_class)
+    ActiverecordToPoro::ObjectMapper.create(a_active_record_class)
   }
 
   given(:mapper_with_custom_source){
-    ActiverecordToPoro::Converter.new(a_active_record_class,
-                                      load_source: custom_poro_class,
-                                      except: [:lock_version]
+    ActiverecordToPoro::ObjectMapper.create(a_active_record_class,
+                                         load_source: custom_poro_class,
+                                         except: [:lock_version]
     )
   }
 
@@ -35,7 +35,7 @@ feature "Map active record objects", %q{
 
   scenario "creates an ActiveRecord object from a poro object" do
     poro = mapper.load(a_active_record_object)
-    expect(mapper.dump(poro)).to eq a_active_record_object
+    expect(mapper.dump(poro).attributes).to eq a_active_record_object.attributes
   end
 
   scenario "use my own source class for converting ActiveRecord objects" do

data/spec/ar_spec_helper.rb

@@ -1,8 +1,10 @@
-require 'sqlite3'
 require 'active_record'
 require 'database_cleaner'
 
 db_dir = File.join(File.expand_path(__dir__ ), "ar_support/db/")
+# ENV['DATABASE_URL']="sqlite3://localhost/:memory:?pool=5&timeout=5000"
+
+
 
 ActiveRecord::Base.establish_connection({
                                             pool: 5,

data/spec/integration/lib/activerecord_to_poro/mapper_extension_spec.rb

@@ -0,0 +1,89 @@
+require 'integration_spec_helper'
+
+describe ActiverecordToPoro::MapperExtension do
+  subject{
+    Yaoc::ObjectMapper.new(target, source).tap do |mapper|
+      mapper.extend ActiverecordToPoro::MapperExtension
+      mapper.fetcher(:public_send)
+    end
+  }
+
+  let(:source){ User }
+
+  let(:target){ActiverecordToPoro::DefaultPoroClassBuilder.new(source).()}
+
+  let(:default_expected_params){
+    {
+        :to=>:roles,
+        :from=>:roles,
+        :reverse_to=>:roles,
+        :reverse_from=>:roles,
+        :reverse_lazy_loading=>false,
+        :is_collection=>true,
+        :lazy_loading=>nil,
+        :object_converter=>converter,
+        :reverse_object_converter=>converter
+    }
+  }
+
+  let(:converter){
+    double("converter")
+  }
+
+  describe '#association_rule' do
+    it "uses defaults" do
+      expect(subject).to receive(:rule).with default_expected_params
+      subject.association_rule(to: :roles,
+                               converter: converter
+      )
+    end
+
+    it "does not convert forward when converter is nil" do
+      expected_params = default_expected_params.merge(converter: kind_of(Proc),
+                                                      reverse_converter: kind_of(Proc),
+                                                      object_converter: nil,
+                                                      reverse_object_converter: nil
+      )
+
+      expect(subject).to receive(:rule).with expected_params
+
+      subject.association_rule(
+          to: :roles,
+          converter: nil
+      )
+    end
+
+    it "does not convert reverse when reverse converter is nil" do
+      expected_params = default_expected_params.merge(
+                                                      reverse_converter: kind_of(Proc),
+                                                      reverse_object_converter: nil
+      )
+
+      expect(subject).to receive(:rule).with expected_params
+
+      subject.association_rule(
+          to: :roles,
+          converter: converter,
+          reverse_converter: nil
+      )
+    end
+
+    it "disables reverse converter when the association is kind of has many through (no setter from rails)" do
+      expected_params = default_expected_params.merge(
+          reverse_converter: kind_of(Proc),
+          reverse_object_converter: nil,
+          to: :permissions,
+          from: :permissions,
+          reverse_to: :permissions,
+          reverse_from: :permissions,
+      )
+
+      expect(subject).to receive(:rule).with expected_params
+
+      subject.association_rule(
+          to: :permissions,
+          converter: converter
+      )
+    end
+  end
+end

data/spec/integration/lib/activerecord_to_poro/metadata_enabled_ar_spec.rb

@@ -0,0 +1,32 @@
+require 'integration_spec_helper'
+
+describe ActiverecordToPoro::MetadataEnabledAr do
+  subject{
+    User.extend ActiverecordToPoro::MetadataEnabledAr
+    User
+  }
+
+  let(:ar_object){
+    User.create!(name: 'my name', email: 'my_name@example.com')
+  }
+
+  let(:metadata){
+    ActiverecordToPoro::Metadata.new.tap do |meta|
+      meta.initialize_from_ar(ar_object)
+    end
+  }
+
+  describe '._from_attrs_with_metadata' do
+    it 'loads a record from db' do
+      new_user = subject._from_attrs_with_metadata({_set_metadata_to_ar: metadata })
+      expect(new_user.new_record?).to be_falsy
+    end
+
+    it 'uses a precreated object' do
+      new_user = subject._from_attrs_with_metadata({_set_metadata_to_ar: metadata }, ar_object)
+      expect(new_user.object_id).to eq ar_object.object_id
+    end
+
+  end
+
+end

data/spec/integration/lib/activerecord_to_poro/{converter_spec.rb → object_mapper_spec.rb}

@@ -1,19 +1,19 @@
 require 'integration_spec_helper'
 
-describe ActiverecordToPoro::Converter do
+describe ActiverecordToPoro::ObjectMapper do
 
   describe '.new' do
     subject{
-      ActiverecordToPoro::Converter
+      ActiverecordToPoro::ObjectMapper
     }
 
     it 'removes "except" attributes from default mapping' do
-      object = subject.new(User, except: :lock_version)
+      object = subject.create(User, except: :lock_version)
       expect(object.attributes_for_default_mapping).not_to include :lock_version
     end
 
     it 'uses "only" attributes for default mapping' do
-      object = subject.new(User, only: :id)
+      object = subject.create(User, only: :id)
       expect(object.attributes_for_default_mapping).to eq [:id]
     end
 
@@ -21,15 +21,15 @@ describe ActiverecordToPoro::Converter do
 
   context 'instance methods' do
     subject!{
-      ActiverecordToPoro::Converter.new(User,  convert_associations: {roles: roles_converter, salutation: salutation_converter})
+      ActiverecordToPoro::ObjectMapper.create(User,  convert_associations: {roles: roles_converter, salutation: salutation_converter})
     }
 
     let(:roles_converter){
-      ActiverecordToPoro::Converter.new(Role)
+      ActiverecordToPoro::ObjectMapper.create(Role)
     }
 
     let(:salutation_converter){
-      ActiverecordToPoro::Converter.new(Salutation)
+      ActiverecordToPoro::ObjectMapper.create(Salutation)
     }
 
     let(:ar_object){
@@ -50,7 +50,6 @@ describe ActiverecordToPoro::Converter do
 
       it 'sets metadata for loaded objects' do
         expect(loaded_poro_object._metadata).not_to be_nil
-        expect(loaded_poro_object._metadata.primary_key_value).to eq ar_object.id
       end
 
       it 'converts also associated objects' do
@@ -62,18 +61,19 @@ describe ActiverecordToPoro::Converter do
         subject.load(ar_object)
       end
 
+      it 'fills an existing poro' do
+        poro_to_fill = subject.load_result_source.new
+        expect(subject.load(ar_object, poro_to_fill).object_id).to eq poro_to_fill.object_id
+      end
+
     end
 
     describe '#dump' do
-      it 'creates an ActiveRecordObject' do
+      it 'creates an ActiveRecord object' do
         expect(subject.dump(loaded_poro_object)).to be_kind_of ActiveRecord::Base
       end
 
-      it 'sets the primary key when it existed before' do
-        expect(subject.dump(loaded_poro_object).id).to eq ar_object.id
-      end
-
-      it 'sets new_record to false when it is an existing record' do
+      it 'loads the object from database when primary key and value are given in metadata' do
         expect(subject.dump(loaded_poro_object).new_record?).to be_falsy
       end
 
@@ -82,6 +82,11 @@ describe ActiverecordToPoro::Converter do
 
         expect(subject.dump(loaded_poro_object).roles.size).to eq count_roles
       end
+
+      it 'fills an existing ActiveRecord object' do
+        new_ar_object = User.new
+        expect(subject.dump(loaded_poro_object, new_ar_object).object_id).to eq new_ar_object.object_id
+      end
     end
 
   end

data/spec/unit/lib/activerecord_to_poro/metadata_spec.rb

@@ -1,32 +1,62 @@
 require 'unit_spec_helper'
 
 describe ActiverecordToPoro::Metadata do
-  let(:ar_object){
+  let(:ar_class){
     Struct.new(:id) do
       def self.primary_key
         "id"
       end
 
-    end.new(1)
+      def self.name
+        "MyNameIsStruct"
+      end
+
+    end
+  }
+
+  let(:ar_object_1){
+    ar_class.new(1)
+  }
+
+  let(:ar_object_2){
+    ar_class.new(2)
   }
 
+
   describe "#initialize_from_ar" do
 
     it "sets the primary_key" do
-      subject.initialize_from_ar(ar_object)
+      subject.initialize_from_ar(ar_object_1)
 
-      expect(subject.primary_key_column).to eq "id"
-      expect(subject.primary_key_value).to eq 1
+      expect(subject.to_hash).to include( source_objects_info: [{class_name: "MyNameIsStruct",
+                                                                 primary_key: {:column=>"id", :value=>1},
+                                                                 object_id: ar_object_1.object_id,
+                                                                 lock_version: nil
+                                                                }])
+    end
+
+    it "adds multiple objects" do
+      subject.initialize_from_ar(ar_object_1)
+      subject.initialize_from_ar(ar_object_2)
+
+      expect(subject.to_hash[:source_objects_info].size).to eq 2
+    end
+
+    it "adds the same object only once" do
+      subject.initialize_from_ar(ar_class.new(1))
+      subject.initialize_from_ar(ar_class.new(1))
+
+      expect(subject.to_hash[:source_objects_info].size).to eq 1
     end
 
   end
 
-  describe "set_primary_key" do
-    it "sets the primary_key" do
-      subject.set_primary_key(ar_object)
+  describe '#for_ar_class' do
+    it 'returns metadata for a ActiveRecord class' do
+      subject.initialize_from_ar(ar_object_1)
 
-      expect(subject.primary_key_column).to eq "id"
-      expect(subject.primary_key_value).to eq 1
+      expect(subject.for_ar_class(ar_class.name).to_hash).to include({primary_key: {column: "id", value: 1}})
     end
   end
+
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord_to_poro
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Dieter Späth
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-29 00:00:00.000000000 Z
+date: 2014-02-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: abstract_type
@@ -278,11 +278,12 @@ files:
 - Rakefile
 - activerecord_to_poro.gemspec
 - lib/activerecord_to_poro.rb
-- lib/activerecord_to_poro/converter.rb
 - lib/activerecord_to_poro/default_poro_class_builder.rb
 - lib/activerecord_to_poro/mapper_extension.rb
 - lib/activerecord_to_poro/metadata.rb
 - lib/activerecord_to_poro/metadata_enabled.rb
+- lib/activerecord_to_poro/metadata_enabled_ar.rb
+- lib/activerecord_to_poro/object_mapper.rb
 - lib/activerecord_to_poro/version.rb
 - spec/acceptance/map_ar_associations_spec.rb
 - spec/acceptance/map_ar_objects_spec.rb
@@ -294,8 +295,10 @@ files:
 - spec/ar_support/models/role.rb
 - spec/ar_support/models/salutation.rb
 - spec/ar_support/models/user.rb
-- spec/integration/lib/activerecord_to_poro/converter_spec.rb
 - spec/integration/lib/activerecord_to_poro/default_poro_class_builder_spec.rb
+- spec/integration/lib/activerecord_to_poro/mapper_extension_spec.rb
+- spec/integration/lib/activerecord_to_poro/metadata_enabled_ar_spec.rb
+- spec/integration/lib/activerecord_to_poro/object_mapper_spec.rb
 - spec/integration_spec_helper.rb
 - spec/spec_helper.rb
 - spec/support/feature.rb
@@ -336,8 +339,10 @@ test_files:
 - spec/ar_support/models/role.rb
 - spec/ar_support/models/salutation.rb
 - spec/ar_support/models/user.rb
-- spec/integration/lib/activerecord_to_poro/converter_spec.rb
 - spec/integration/lib/activerecord_to_poro/default_poro_class_builder_spec.rb
+- spec/integration/lib/activerecord_to_poro/mapper_extension_spec.rb
+- spec/integration/lib/activerecord_to_poro/metadata_enabled_ar_spec.rb
+- spec/integration/lib/activerecord_to_poro/object_mapper_spec.rb
 - spec/integration_spec_helper.rb
 - spec/spec_helper.rb
 - spec/support/feature.rb

data/lib/activerecord_to_poro/converter.rb

@@ -1,112 +0,0 @@
-module ActiverecordToPoro
-  class Converter
-    include ColumnHelper
-
-    attr_accessor :load_source_class,
-                  :dump_source_class,
-                  :association_converters,
-                  :use_lazy_loading,
-                  :except_attributes,
-                  :only_attributes
-
-    def initialize(ar_class,
-                   use_lazy_loading=true,
-                   except: nil,
-                   only: nil,
-                   load_source: nil,
-                   convert_associations: {})
-      self.load_source_class = ar_class
-      self.dump_source_class = load_source || DefaultPoroClassBuilder.new(ar_class).()
-      self.association_converters = convert_associations
-      self.use_lazy_loading = use_lazy_loading
-      self.except_attributes = Array(except)
-      self.only_attributes = only.nil? ? nil : Array(only) # an empty array can be wanted, so that there is no default mapping @ all
-    end
-
-    def load(to_convert)
-      mapper.load(to_convert)
-    end
-
-    def dump(to_convert)
-      mapper.dump(to_convert)
-    end
-
-    def extend_mapping(&block)
-      mapper.add_mapping &block
-    end
-
-
-    def mapper
-      @mapper||= Yaoc::ObjectMapper.new(self.dump_source_class, self.load_source_class).tap do |mapper|
-        mapper.extend ActiverecordToPoro::MapperExtension
-        mapper.fetcher(:public_send)
-
-        add_default_mapping_for_current_class(mapper)
-        add_mapping_for_associations(mapper)
-      end
-    end
-
-    def attributes_for_default_mapping
-      self.only_attributes || (
-                                columns(self.load_source_class) -
-                                primary_keys(self.load_source_class) -
-                                association_specific_columns(self.load_source_class) -
-                                associated_object_accessors(self.load_source_class) -
-                                self.except_attributes
-                              )
-    end
-
-    protected
-
-    def add_default_mapping_for_current_class(mapper)
-      tmp_quirk = attributes_for_default_mapping
-
-      mapper.add_mapping do
-        rule to: tmp_quirk
-
-        rule to: :_set_metadata,
-             converter: ->(source, result){ fill_result_with_value(result, :_set_metadata_from_ar, source) },
-             reverse_converter: ->(source, result){
-
-               needs_conversion = if source.respond_to?("_needs_conversion?")
-                                    source._needs_conversion?
-                                  else
-                                    ! source.nil? #would trigger lazy loading when it is a ToProcDelegator
-                                  end
-
-               fill_result_with_value(result, :_set_metadata_to_ar, source._metadata.to_hash) if needs_conversion
-             }
-      end
-    end
-
-    def add_mapping_for_associations(mapper)
-      association_converters.each_pair do |association_name, association_converter|
-
-        lazy_quirk = self.use_lazy_loading
-
-        mapper.add_mapping do
-          association_rule to: association_name,
-                           lazy_loading: lazy_quirk,
-                           converter: association_converter
-        end
-      end
-    end
-
-    def dump_source_class=(new_dump_source)
-      @dump_source_class = new_dump_source.tap do |source|
-        unless source.respond_to? :_metadata
-          source.send(:include, MetadataEnabled)
-        end
-      end
-    end
-
-    def load_source_class=(new_source)
-      @load_source_class=new_source.tap do |source|
-        unless source.respond_to? :_set_metadata_to_ar=
-          source.send(:include, ActiverecordToPoro::MetadataToAr)
-        end
-      end
-    end
-
-  end
-end