datamappify 0.10.1 → 0.20.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ef8038f0a59981b26cab34b79e9358f9333d476d
-  data.tar.gz: d39950946d1bafd3232ad8188242e1bb8e3b150f
+  metadata.gz: 657efe5662156ed237a7ff2a7abf02304ea48053
+  data.tar.gz: a5a1ab8c879d4948099679cdc12276970e80f8f3
 SHA512:
-  metadata.gz: d41dc6a2da7f5fa2f72e1a6c3b9a7a6d6e3c68fe741a5845bd31f1081914343916a91b4f74b63c4f678b37e2b8dcdb2870830ad92d8cb31d9b738d3bccedffd4
-  data.tar.gz: 14c092eda2c25e9d8b71853dd691ad7ffaf0b2fd63c3d6248654bfcc349c6e68b613d761b6732a9fcfa2b2a0edf923c8d28d1e17c91ea524c7079eab3e64b1e8
+  metadata.gz: 9d0fdeabfd8ba423d31bc70b7948c28419a10ae635e0189aa0e70be80db3c39a850532b2135c83c1df574204b0d7e48d84a67bd207e57ab7a3a150a7e0949869
+  data.tar.gz: b7ee5ed125413a9a5207355c018450d2440d738bc5fa9438a648c38848070eb708b28b5716b3f8f860ea21e4053a60cb803271323e430ccc9fcfa5bb3aa18476

data/.rspec

@@ -0,0 +1 @@
+--colour --order random

data/.travis.yml

@@ -2,5 +2,7 @@ language: ruby
 rvm:
   - 1.9.3
   - 2.0.0
+env:
+  - COV=2
 script:
   - bundle exec rake --trace

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 ## master
 
+## 0.20.0 [2013-03-19]
+
+- __Completely rewritten Repository__
+  - Repository now handles data construction from different ORM objects
+  - ActiveRecord has now been demoted to being a data provider, it is no longer tightly coupled with Repository, this means __we could have multiple data providers__!
+  - Repository is now much more robust
+  - As a result of robustness, it fixed an issue where updating an existing entity with new data records from mapped attributes will not persist the new data records correctly
+  - `#save` and `#destroy` now support accepting an array as their argument
+  - Added support for Sequel!
+  - Added support for mapping entity attributes to different ORMs!
+
 ## 0.10.1 [2013-03-16]
 
 - Fixed `#save` for creating new objects.

data/README.md

@@ -1,24 +1,20 @@
-# Datamappify [![Gem Version](https://badge.fury.io/rb/datamappify.png)](http://badge.fury.io/rb/datamappify) [![Build Status](https://api.travis-ci.org/fredwu/datamappify.png)](http://travis-ci.org/fredwu/datamappify) [![Code Climate](https://codeclimate.com/github/fredwu/datamappify.png)](https://codeclimate.com/github/fredwu/datamappify)
+# Datamappify [![Gem Version](https://badge.fury.io/rb/datamappify.png)](http://badge.fury.io/rb/datamappify) [![Build Status](https://api.travis-ci.org/fredwu/datamappify.png)](http://travis-ci.org/fredwu/datamappify) [![Coverage Status](https://coveralls.io/repos/fredwu/datamappify/badge.png)](https://coveralls.io/r/fredwu/datamappify) [![Code Climate](https://codeclimate.com/github/fredwu/datamappify.png)](https://codeclimate.com/github/fredwu/datamappify)
 
 Separate domain logic from data persistence, based on the [Repository Pattern](http://martinfowler.com/eaaCatalog/repository.html).
 
-__This library is current in Proof-of-Concept stage, do NOT use it for anything other than experimentation.__
+Datamappify is NOT associated with the [Datamapper](https://github.com/datamapper/) project.
+
+__Datamappify is current in Proof-of-Concept stage, do NOT use it for anything other than experimentation.__
 
 ## Overview
 
-Datamappify is a thin layer on top of ActiveRecord and [Virtus](https://github.com/solnic/virtus). The design goal is to utilise ActiveRecord but separate domain logic (behaviour) and data persistence.
+Datamappify is a thin layer on top of [Virtus](https://github.com/solnic/virtus) and existing ORMs (ActiveRecord, etc). The design goal is to utilise the powerfulness of existing ORMs but separate domain logic (behaviour) from data persistence.
 
 Datamappify consists of three components:
 
-- Entity
-- Data
-- Repository
-
-__Entity__ is your model, it is responsible for mainly storing behaviour. Some structure (i.e. model relationships) is also stored here for convenience.
-
-__Data__ as the name suggests, holds your model data. It is an ActiveRecord object.
-
-__Repository__ is responsible for data retrieval and persistence, e.g. `find`, `save` and `destroy`, etc.
+- __Entity__ is your model, it is responsible for mainly storing behaviour.
+- __Data__ as the name suggests, holds your model data. It is an ActiveRecord object.
+- __Repository__ is responsible for data retrieval and persistence, e.g. `find`, `save` and `destroy`, etc.
 
 ## Installation
 
@@ -38,15 +34,18 @@ Or install it yourself as:
 
 ### Entity
 
+Entity uses [Virtus](https://github.com/solnic/virtus) DSL for defining attributes and [ActiveModel::Validations](http://api.rubyonrails.org/classes/ActiveModel/Validations.html) DSL for validations.
+
 ```ruby
 class User
   include Datamappify::Entity
 
-  attribute :first_name, String
-  attribute :last_name,  String
-  attribute :gender,     String
-  attribute :age,        Integer
-  attribute :passport,   String
+  attribute :first_name,     String
+  attribute :last_name,      String
+  attribute :age,            Integer
+  attribute :passport,       String
+  attribute :driver_license, String
+  attribute :health_care,    String
 
   validates :first_name, :presence => true,
                          :length   => { :minimum => 2 }
@@ -61,6 +60,8 @@ end
 
 ### Repository
 
+Map entity attributes to DB columns - better yet, you can even map attributes to __different ORMs__!
+
 ```ruby
 class UserRepository
   include Datamappify::Repository
@@ -68,39 +69,63 @@ class UserRepository
   # specify the entity class
   for_entity User
 
+  # specify the default data provider for unmapped attributes
+  default_provider :ActiveRecord
+
   # specify any attributes that need to be mapped
   #
   # for example:
-  #   - 'gender' is mapped to the 'User' ActiveRecord class and its 'sex' attribute
-  #   - 'passport' is mapped to the 'UserPassport' ActiveRecord class and its 'number' attribute
-  #   - attributes not specified here are mapped automatically (in this case, 'User')
-  map_attribute :gender,   'User#sex'
-  map_attribute :passport, 'UserPassport#number'
+  #   - 'last_name' is mapped to the 'User' ActiveRecord class and its 'surname' attribute
+  #   - 'driver_license' is mapped to the 'UserDriverLicense' ActiveRecord class and its 'number' attribute
+  #   - 'passport' is mapped to the 'UserPassport' Sequel class and its 'number' attribute
+  #   - attributes not specified here are mapped automatically to 'ActiveRecord::User'
+  map_attribute :last_name,      'ActiveRecord::User#surname'
+  map_attribute :driver_license, 'ActiveRecord::UserDriverLicense#number'
+  map_attribute :passport,       'Sequel::UserPassport#number'
+  map_attribute :health_care,    'Sequel::UserHealthCare#number'
 end
-
-user_repository = UserRepository.instance
 ```
 
-#### Retrieving an entity
+#### Retrieving entities
+
+Pass in an id or an array of ids.
 
 ```ruby
-user = user_repository.find(1)
+user  = UserRepository.instance.find(1)
+users = UserRepository.instance.find([1, 2, 3])
 ```
 
-#### Saving/updating an entity
+#### Saving/updating entities
+
+Pass in an entity or an array of entities.
+
+There is also `save!` that raises `Datamappify::Data::EntityNotSaved`.
 
 ```ruby
-user_repository.save(user)
+UserRepository.instance.save(user)
+UserRepository.instance.save([user, user2, user3])
 ```
 
 #### Destroying an entity
 
+Pass in an entity, an id, an array of entities or an array of ids.
+
+There is also `destroy!` that raises `Datamappify::Data::EntityNotDestroyed`.
+
 Note that due to the attributes mapping, any data found in mapped ActiveRecord objects are not touched.
 
 ```ruby
-user_repository.destroy(user)
+UserRepository.instance.destroy(1)
+UserRepository.instance.destroy([1, 2, 3])
+UserRepository.instance.destroy(user)
+UserRepository.instance.destroy([user, user2, user3])
 ```
 
+## Supported ORMs
+
+- ActiveRecord
+- Sequel
+
 ## Changelog
 
 Refer to [CHANGELOG](CHANGELOG.md).
@@ -117,6 +142,7 @@ Refer to [CHANGELOG](CHANGELOG.md).
 
 - [Curator](https://github.com/braintree/curator)
 - [Edr](https://github.com/nulogy/edr)
+- [Minimapper](https://github.com/joakimk/minimapper)
 
 ## Author
 

data/datamappify.gemspec

@@ -20,16 +20,16 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency "virtus",        "~> 0.5"
   spec.add_dependency "activesupport", ">= 4.0.0.beta1", "< 5"
-  spec.add_dependency "activerecord",  ">= 4.0.0.beta1", "< 5"
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "minitest"
-  spec.add_development_dependency "minitest-colorize"
-  spec.add_development_dependency "testrbl"
+  spec.add_development_dependency "rspec"
   spec.add_development_dependency "pry"
   spec.add_development_dependency "simplecov"
   spec.add_development_dependency "cane"
+  spec.add_development_dependency "coveralls"
   spec.add_development_dependency "sqlite3"
+  spec.add_development_dependency "sequel"
+  spec.add_development_dependency "activerecord",  ">= 4.0.0.beta1", "< 5"
   spec.add_development_dependency "database_cleaner", ">= 1.0.0.RC1", "< 2"
 end

data/lib/datamappify/data/errors.rb

@@ -3,6 +3,9 @@ module Datamappify
     class Error < StandardError
     end
 
+    class MethodNotImplemented < NoMethodError
+    end
+
     class EntityInvalid < Error
       def initialize(entity)
         super entity.errors.full_messages.join(', ')

data/lib/datamappify/data/provider/active_record/persistence.rb

@@ -0,0 +1,31 @@
+require 'datamappify/data/provider/common/relational/persistence'
+require 'datamappify/data/provider/common/relational/record/mapper'
+require 'datamappify/data/provider/common/relational/record/writer'
+
+module Datamappify
+  module Data
+    module Provider
+      module ActiveRecord
+        class Persistence < Data::Provider::Common::Relational::Persistence
+          def destroy(ids)
+            data_class.destroy(ids)
+          end
+
+          def exists?(id)
+            data_class.exists?(id)
+          end
+
+          def transaction(&block)
+            data_class.transaction(&block)
+          end
+
+          private
+
+          def record_attributes_method
+            :attributes
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datamappify/data/provider/active_record.rb

@@ -0,0 +1,16 @@
+require 'datamappify/data/provider/active_record/persistence'
+
+module Datamappify
+  module Data
+    module ActiveRecord
+    end
+
+    module Provider
+      module ActiveRecord
+        def self.build_data_class(data_class_name)
+          Datamappify::Data::ActiveRecord.const_set(data_class_name, Class.new(::ActiveRecord::Base))
+        end
+      end
+    end
+  end
+end

data/lib/datamappify/data/provider/common/persistence.rb

@@ -0,0 +1,57 @@
+module Datamappify
+  module Data
+    module Provider
+      module Common
+        class Persistence
+          def initialize(provider_class_name, entities, data_class_name)
+            @provider_class_name = provider_class_name
+            @entities            = entities
+            @data_class_name     = data_class_name
+          end
+
+          def find(data_fields_mapping)
+            raise Data::MethodNotImplemented
+          end
+
+          def create(data_fields_mapping)
+            raise Data::MethodNotImplemented
+          end
+
+          def update(data_fields_mapping)
+            raise Data::MethodNotImplemented
+          end
+
+          def destroy(id_or_entity)
+            raise Data::MethodNotImplemented
+          end
+
+          def exists?(id)
+            raise Data::MethodNotImplemented
+          end
+
+          def transaction(&block)
+            raise Data::MethodNotImplemented
+          end
+
+          def method_missing(symbol, *args)
+            data_class.send symbol, *args
+          end
+
+          private
+
+          def data_class
+            "Datamappify::Data::#{@provider_class_name}::#{@data_class_name}".constantize
+          end
+
+          def entity_class_name
+            @entities[0].class.name
+          end
+
+          def is_entity_class?
+            @data_class_name == entity_class_name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datamappify/data/provider/common/relational/persistence.rb

@@ -0,0 +1,85 @@
+require 'datamappify/data/provider/common/persistence'
+
+module Datamappify
+  module Data
+    module Provider
+      module Common
+        module Relational
+          class Persistence < Data::Provider::Common::Persistence
+            def find(data_fields_mapping)
+              records = find_records(data_fields_mapping)
+
+              entities_walker do |entity|
+                if record = find_record_for_entity(entity, records)
+                  Common::Relational::RecordMapper.new(
+                    entity, record.send(record_attributes_method)
+                  ).map_attributes(data_fields_mapping)
+                end
+              end
+            end
+
+            def create(data_fields_mapping)
+              entities_walker do |entity|
+                if has_data_to_insert?(entity, data_fields_mapping)
+                  Common::Relational::RecordWriter.new(
+                    entity, data_class, key_field_name
+                  ).insert_record(data_fields_mapping)
+                end
+              end
+            end
+
+            def update(data_fields_mapping)
+              records = find_records(data_fields_mapping)
+
+              entities_walker do |entity|
+                record_writer = Common::Relational::RecordWriter.new(entity, data_class, key_field_name)
+
+                if record = find_record_for_entity(entity, records)
+                  record_writer.update_record(record, data_fields_mapping)
+                elsif has_data_to_insert?(entity, data_fields_mapping)
+                  record_writer.insert_record(data_fields_mapping)
+                end
+              end
+            end
+
+            private
+
+            def find_record_for_entity(entity, records)
+              records.find { |r| r.send(key_field_name) == entity.id }
+            end
+
+            def find_records(data_fields_mapping)
+              data_class.select(
+                *field_names(data_fields_mapping)
+              ).where(
+                key_field_name => @entities.map(&:id)
+              )
+            end
+
+            def entities_walker
+              walker_method = is_entity_class? ? :keep_if : :each
+
+              @entities.send(walker_method) do |entity|
+                yield(entity)
+              end
+            end
+
+            def key_field_name
+              is_entity_class? ? :id : "#{entity_class_name.underscore}_id".to_sym
+            end
+
+            def field_names(data_fields_mapping)
+              (data_fields_mapping.field_names << key_field_name << :id).uniq
+            end
+
+            def has_data_to_insert?(entity, data_fields_mapping)
+              attribute_names = entity.attributes.keys & data_fields_mapping.attribute_names
+
+              attribute_names.any? && Util.attributes_filtered_by(entity, attribute_names).values.compact.any?
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datamappify/data/provider/common/relational/record/mapper.rb

@@ -0,0 +1,24 @@
+module Datamappify
+  module Data
+    module Provider
+      module Common
+        module Relational
+          class RecordMapper
+            def initialize(entity, record_attributes)
+              @entity            = entity
+              @record_attributes = record_attributes
+            end
+
+            def map_attributes(data_fields_mapping)
+              @record_attributes.each do |name, value|
+                return unless data_fields_mapping.has_key?(name.to_sym)
+
+                @entity.send(:"#{data_fields_mapping[name.to_sym]}=", value)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datamappify/data/provider/common/relational/record/writer.rb

@@ -0,0 +1,67 @@
+module Datamappify
+  module Data
+    module Provider
+      module Common
+        module Relational
+          class RecordWriter
+            def initialize(entity, data_class, key_field_name)
+              @entity         = entity
+              @data_class     = data_class
+              @key_field_name = key_field_name
+            end
+
+            def insert_record(data_fields_mapping)
+              if is_foreign_record?
+                insert_foreign_record(data_fields_mapping)
+              else
+                new_record = insert_primary_record(data_fields_mapping)
+                update_entity_with_new_record_id(new_record.id)
+              end
+            end
+
+            def update_record(record, data_fields_mapping)
+              update_record_with_fields(record, data_fields_mapping)
+            end
+
+            private
+
+            def is_foreign_record?
+              @key_field_name != :id
+            end
+
+            def is_an_empty_primary_key?(attribute_name)
+              (attribute_name == :id) && @entity.attributes[attribute_name].nil?
+            end
+
+            def insert_foreign_record(data_fields_mapping)
+              new_record = @data_class.new
+              new_record.send "#{@key_field_name}=", @entity.id
+              update_record_with_fields(new_record, data_fields_mapping)
+            end
+
+            def insert_primary_record(data_fields_mapping)
+              update_record_with_fields(@data_class.new, data_fields_mapping)
+            end
+
+            def update_record_with_fields(record, data_fields_mapping)
+              data_fields_mapping.field_names.each do |field_name|
+                attribute_name = data_fields_mapping[field_name]
+
+                unless is_an_empty_primary_key?(attribute_name)
+                  record.send "#{field_name}=", @entity.attributes[attribute_name]
+                end
+              end
+
+              record.save
+              record
+            end
+
+            def update_entity_with_new_record_id(id)
+              @entity.id = id
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datamappify/data/provider/sequel/persistence.rb

@@ -0,0 +1,31 @@
+require 'datamappify/data/provider/common/relational/persistence'
+require 'datamappify/data/provider/common/relational/record/mapper'
+require 'datamappify/data/provider/common/relational/record/writer'
+
+module Datamappify
+  module Data
+    module Provider
+      module Sequel
+        class Persistence < Data::Provider::Common::Relational::Persistence
+          def destroy(ids)
+            data_class.where(:id => ids).destroy
+          end
+
+          def exists?(id)
+            data_class.where(:id => id).any?
+          end
+
+          def transaction(&block)
+            data_class.db.transaction(&block)
+          end
+
+          private
+
+          def record_attributes_method
+            :values
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datamappify/data/provider/sequel.rb

@@ -0,0 +1,18 @@
+require 'datamappify/data/provider/sequel/persistence'
+
+module Datamappify
+  module Data
+    module Sequel
+    end
+
+    module Provider
+      module Sequel
+        def self.build_data_class(data_class_name)
+          Datamappify::Data::Sequel.const_set(
+            data_class_name, Class.new(::Sequel::Model(data_class_name.pluralize.underscore.to_sym))
+          )
+        end
+      end
+    end
+  end
+end

data/lib/datamappify/data.rb

@@ -1,5 +1,4 @@
 require 'datamappify/data/errors'
-require 'datamappify/data/base'
 
 module Datamappify
   module Data

data/lib/datamappify/repository/attribute_source_data_class_builder.rb

@@ -1,22 +1,27 @@
 module Datamappify
   module Repository
     class AttributeSourceDataClassBuilder
-      class << self
-        def build(data_class_name, data_fields_mapping)
-          @data_class_name = data_class_name
+      def initialize(provider_class_name, data_class_name)
+        @provider_class_name = provider_class_name
+        @data_class_name     = data_class_name
+      end
+
+      def build(data_fields_mapping)
+        require "datamappify/data/provider/#{@provider_class_name.underscore}"
 
-          build_data_class unless data_class_is_defined?
+        unless data_class_is_defined?
+          provider_module.build_data_class(@data_class_name)
         end
+      end
 
-        private
+      private
 
-        def build_data_class
-          Data.const_set(@data_class_name, Class.new(Data::Base))
-        end
+      def provider_module
+        @provider_module ||= "Datamappify::Data::Provider::#{@provider_class_name}".constantize
+      end
 
-        def data_class_is_defined?
-          Data.const_defined?(@data_class_name, false)
-        end
+      def data_class_is_defined?
+        provider_module.const_defined?(@data_class_name, false)
       end
     end
   end

data/lib/datamappify/repository/attributes_mapper.rb

@@ -6,27 +6,29 @@ module Datamappify
       def initialize(repository)
         @repository = repository
 
-        map_entity_attributes
+        map_non_custom_entity_attributes
+        map_custom_entity_attributes
       end
 
       def build_data_classes
-        @repository.data_mapping.each do |data_class_name, data_fields_mapping|
-          AttributeSourceDataClassBuilder.build(data_class_name, data_fields_mapping)
+        @repository.data_mapping.each do |provider_class_name, data_class_mapping|
+          data_class_mapping.each do |data_class_name, data_fields_mapping|
+            AttributeSourceDataClassBuilder.new(provider_class_name, data_class_name).build(data_fields_mapping)
+          end
         end
       end
 
       private
 
-      def map_entity_attributes
-        map_non_custom_entity_attributes
-        map_custom_entity_attributes
-      end
-
       def map_non_custom_entity_attributes
-        @repository.data_mapping[@repository.entity_class.name] = {}
+        provider_name   = @repository.default_provider_class_name
+        data_class_name = @repository.entity_class.name
+
+        @repository.data_mapping[provider_name] ||= {}
+        @repository.data_mapping[provider_name][data_class_name] ||= MappingHash.new
 
         non_custom_attributes.each do |attribute_name|
-          @repository.data_mapping[@repository.entity_class.name][attribute_name] = attribute_name
+          @repository.data_mapping[provider_name][data_class_name][attribute_name] = attribute_name
         end
       end
 
@@ -41,10 +43,12 @@ module Datamappify
       end
 
       def map_custom_entity_attribute(attribute_name, source)
-        data_class_name, data_field_name = source.split('#')
+        namespaced_data_class_name, data_field_name = source.split('#')
+        provider_name, data_class_name = namespaced_data_class_name.split('::')
 
-        @repository.data_mapping[data_class_name] ||= {}
-        @repository.data_mapping[data_class_name][data_field_name.to_sym] = attribute_name
+        @repository.data_mapping[provider_name] ||= {}
+        @repository.data_mapping[provider_name][data_class_name] ||= MappingHash.new
+        @repository.data_mapping[provider_name][data_class_name][data_field_name.to_sym] = attribute_name
       end
     end
   end