datamappify 0.20.1 → 0.30.0

data/lib/datamappify/repository.rb

@@ -1,118 +1,84 @@
-require 'singleton'
-require 'datamappify/util'
-require 'datamappify/repository/mapping_hash'
-require 'datamappify/repository/dsl'
-require 'datamappify/repository/attributes_mapper'
+require 'datamappify/repository/mapping_dsl'
+require 'datamappify/repository/query_method'
+require 'datamappify/data'
 
 module Datamappify
   module Repository
     def self.included(klass)
       klass.class_eval do
-        mattr_accessor :entity_class
-        mattr_accessor :default_provider_class_name
-        mattr_accessor :default_data_class_name
-        mattr_accessor :custom_attributes_mapping
-        mattr_accessor :data_mapping
-
-        klass.custom_attributes_mapping = {}
-        klass.data_mapping              = {}
-
         include Singleton
-        extend DSL
-      end
-    end
+        extend  SingletonWrapper
 
-    def initialize
-      AttributesMapper.new(self).build_data_classes
-      self
-    end
+        cattr_accessor :data_mapper
 
-    def find(id_or_ids)
-      entities = Array.wrap(id_or_ids).map { |id| entity_class.new(:id => id) }
+        self.data_mapper = Data::Mapper.new
 
-      data_mapping_walker do |provider_class_name, data_class_name, data_fields_mapping|
-        persistence_class(provider_class_name).new(
-          provider_class_name, entities, data_class_name
-        ).find(data_fields_mapping)
+        extend  MappingDSL
+        include InstanceMethods
       end
-
-      id_or_ids.is_a?(Array) ? entities : entities[0]
     end
 
-    def save(entity_or_entities)
-      Array.wrap(entity_or_entities).each do |entity|
-        create_or_update(entity)
+    module InstanceMethods
+      # @param id_or_ids [Integer, Array<Integer>]
+      #   an entity id or a collection of entity ids
+      #
+      # @return [Entity, Array<Entity>, nil]
+      def find(id_or_ids)
+        QueryMethod::Find.new(data_mapper, id_or_ids).result
       end
 
-      entity_or_entities
-    rescue Datamappify::Data::EntityInvalid
-      false
-    end
-
-    def save!(entity_or_entities)
-      save(entity_or_entities) || raise(Datamappify::Data::EntityNotSaved)
-    end
-
-    def destroy(id_ids_or_entity_entities)
-      ids = Array.wrap(id_ids_or_entity_entities).map do |id_or_entity|
-        Util.extract_entity_id(id_or_entity)
+      # @param entity_or_entities [Entity, Array<Entity>]
+      #   an entity or a collection of entities
+      #
+      # @return [Entity, Array<Entity>, false]
+      def save(entity_or_entities)
+        QueryMethod::Save.new(data_mapper, entity_or_entities).result
       end
 
-      default_persistence.destroy(ids)
-    end
-
-    def destroy!(id_ids_or_entity_entities)
-      destroy(id_ids_or_entity_entities) || raise(Datamappify::Data::EntityNotDestroyed)
-    end
-
-    def method_missing(symbol, *args)
-      default_persistence.send symbol, *args
-    end
-
-    private
-
-    def default_persistence
-      persistence_class(default_provider_class_name).new(
-        default_provider_class_name, [], default_data_class_name
-      )
-    end
-
-    def persistence_class(provider_class_name)
-      "Datamappify::Data::Provider::#{provider_class_name}::Persistence".constantize
-    end
-
-    def create_or_update(entity)
-      raise Datamappify::Data::EntityInvalid.new(entity) if entity.invalid?
-
-      default_persistence.exists?(entity.id) ? update(entity) : create(entity)
-    end
-
-    def create(entity)
-      data_mapping_walker do |provider_class_name, data_class_name, data_fields_mapping|
-        persistence_class(provider_class_name).new(
-          provider_class_name, [entity], data_class_name
-        ).create(data_fields_mapping)
+      # @param (see #save)
+      #
+      # @raise [Data::EntityNotSaved]
+      #
+      # @return [Entity, Array<Entity>]
+      def save!(entity_or_entities)
+        save(entity_or_entities) || raise(Data::EntityNotSaved)
       end
 
-      entity
-    end
+      # @param id_or_ids_or_entity_or_entities [Entity, Array<Entity>]
+      #   an entity or a collection of ids or entities
+      #
+      # @return [void, false]
+      def destroy(id_or_ids_or_entity_or_entities)
+        QueryMethod::Destroy.new(data_mapper, id_or_ids_or_entity_or_entities).result
+      end
 
-    def update(entity)
-      data_mapping_walker do |provider_class_name, data_class_name, data_fields_mapping|
-        persistence_class(provider_class_name).new(
-          provider_class_name, [entity], data_class_name
-        ).update(data_fields_mapping)
+      # @param (see #destroy)
+      #
+      # @raise [Data::EntityNotDestroyed]
+      #
+      # @return [void]
+      def destroy!(id_or_ids_or_entity_or_entities)
+        destroy(id_or_ids_or_entity_or_entities) || raise(Data::EntityNotDestroyed)
       end
 
-      entity
+      # @return [Integer]
+      def count
+        QueryMethod::Count.new(data_mapper).result
+      end
     end
 
-    def data_mapping_walker
-      default_persistence.transaction do
-        data_mapping.each do |provider_class_name, data_class_mapping|
-          data_class_mapping.each do |data_class_name, data_fields_mapping|
-            yield(provider_class_name, data_class_name, data_fields_mapping)
-          end
+    # Wraps a ruby Singleton class so that calling `instance` is no longer necessary.
+    #
+    # @example With `instance`
+    #   UserRepository.instance.count
+    #
+    # @example Without `instance`
+    #   UserRepository.count
+    module SingletonWrapper
+      def self.extended(klass)
+        class << klass
+          extend Forwardable
+          def_delegators :instance, *InstanceMethods.instance_methods
         end
       end
     end

data/lib/datamappify/version.rb

@@ -1,3 +1,3 @@
 module Datamappify
-  VERSION = '0.20.1'
+  VERSION = '0.30.0'
 end

data/lib/datamappify.rb

@@ -1,8 +1,13 @@
-require "active_support/inflector"
-require "datamappify/version"
-require "datamappify/entity"
-require "datamappify/data"
-require "datamappify/repository"
+require 'active_support'
+require 'datamappify/version'
 
 module Datamappify
+  # @return [Pathname]
+  def self.root
+    Pathname.new("#{File.dirname(__FILE__)}/datamappify")
+  end
 end
+
+require 'datamappify/entity'
+require 'datamappify/data'
+require 'datamappify/repository'

data/spec/repository/persistence_spec.rb

@@ -1,22 +1,20 @@
 require_relative '../spec_helper'
 
 shared_examples_for "repository persistence" do |data_provider|
-  let!(:user_repository)     { "UserRepository#{data_provider}".constantize.instance }
-  let(:existing_user)        { User.new(:id => 1, :first_name => 'Fred', :driver_license => 'FREDWU42') }
+  let!(:user_repository)     { "UserRepository#{data_provider}".constantize }
+  let(:existing_user)        { user_repository.save(User.new(:first_name => 'Fred', :driver_license => 'FREDWU42')) }
   let(:new_valid_user)       { User.new(:first_name => 'Batman', :driver_license => 'ARKHAMCITY') }
   let(:new_valid_user2)      { User.new(:first_name => 'Ironman', :driver_license => 'NEWYORKCITY') }
   let(:new_invalid_user)     { User.new(:first_name => 'a') }
   let(:new_invalid_user2)    { User.new(:first_name => 'b') }
-  let(:data_passports)       { "Datamappify::Data::#{data_provider}::UserPassport".constantize }
-  let(:data_driver_licenses) { "Datamappify::Data::#{data_provider}::UserDriverLicense".constantize }
+  let(:data_passports)       { "Datamappify::Data::Record::#{data_provider}::UserPassport".constantize }
+  let(:data_driver_licenses) { "Datamappify::Data::Record::#{data_provider}::UserDriverLicense".constantize }
 
   describe "#find" do
     describe "resource" do
-      let!(:user) { user_repository.save(existing_user) }
-
       it "found" do
-        user_repository.find(user.id).should == existing_user
-        user_repository.find([user.id]).should == [existing_user]
+        user_repository.find(existing_user.id).should == existing_user
+        user_repository.find([existing_user.id]).should == [existing_user]
       end
 
       it "not found" do
@@ -25,14 +23,12 @@ shared_examples_for "repository persistence" do |data_provider|
     end
 
     describe "collection" do
-      let!(:user) { user_repository.save(existing_user) }
-
       it "found" do
-        user_repository.find([user.id]).should == [existing_user]
+        user_repository.find([existing_user.id]).should == [existing_user]
       end
 
       it "partial found" do
-        user_repository.find([user.id, 42]).should == [existing_user]
+        user_repository.find([existing_user.id, 42]).should == [existing_user]
       end
 
       it "not found" do
@@ -98,14 +94,12 @@ shared_examples_for "repository persistence" do |data_provider|
 
     describe "update an existing entity" do
       it "updates existing records" do
-        user = user_repository.save(existing_user)
-
-        user.first_name = 'Vivian'
-        user.driver_license = 'LOCOMOTE'
+        existing_user.first_name = 'Vivian'
+        existing_user.driver_license = 'LOCOMOTE'
 
         updated_user = nil
 
-        expect { updated_user = user_repository.save(user) }.to change { user_repository.count }.by(0)
+        expect { updated_user = user_repository.save(existing_user) }.to change { user_repository.count }.by(0)
 
         updated_user.first_name.should == 'Vivian'
         updated_user.driver_license.should == 'LOCOMOTE'
@@ -117,14 +111,12 @@ shared_examples_for "repository persistence" do |data_provider|
       end
 
       it "updates existing and new records" do
-        user = user_repository.save(existing_user)
-
-        user.first_name = 'Vivian'
-        user.health_care = 'BATMANCAVE'
+        existing_user.first_name = 'Vivian'
+        existing_user.health_care = 'BATMANCAVE'
 
         updated_user = nil
 
-        expect { updated_user = user_repository.save(user) }.to change { user_repository.count }.by(0)
+        expect { updated_user = user_repository.save(existing_user) }.to change { user_repository.count }.by(0)
 
         updated_user.first_name.should == 'Vivian'
         updated_user.health_care.should == 'BATMANCAVE'
@@ -170,7 +162,7 @@ describe Datamappify::Repository do
   end
 
   describe "entity composed from multiple data providers" do
-    let!(:hero_repository) { HeroUserRepository.instance }
+    let!(:hero_repository) { HeroUserRepository }
     let!(:hero)            { HeroUser.new :first_name => 'Aaron', :last_name => 'Patterson' }
 
     it "#find" do

data/spec/repository_spec.rb

@@ -1,12 +1,16 @@
 require_relative 'spec_helper'
 
 shared_examples_for "a repository" do |data_provider|
-  let(:data_provider_module) { "Datamappify::Data::#{data_provider}".constantize }
-  let!(:user_repository)     { "UserRepository#{data_provider}".constantize.instance }
-  subject                    { data_provider_module }
+  let(:namespace)       { "Datamappify::Data::Record::#{data_provider}".constantize }
+  let(:user_repository) { "UserRepository#{data_provider}".constantize.instance }
 
-  it "defines the data class after the repository is initialised" do
-    subject.const_defined?(:User, false).should == true
+  it "defines the data class" do
+    user_repository.data_mapper.default_source_class
+    namespace.const_defined?(:User, false).should == true
+  end
+
+  it "delegates methods to the instance singleton" do
+    expect { "UserRepository#{data_provider}".constantize.find(1) }.to_not raise_error
   end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: datamappify
 version: !ruby/object:Gem::Version
-  version: 0.20.1
+  version: 0.30.0
 platform: ruby
 authors:
 - Fred Wu
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-19 00:00:00.000000000 Z
+date: 2013-04-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: virtus
@@ -72,6 +72,34 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -210,7 +238,7 @@ dependencies:
     - - <
       - !ruby/object:Gem::Version
         version: '2'
-description: Separate domain logic from data persistence.
+description: Compose and manage domain logic and data persistence separately and intelligently.
 email:
 - ifredwu@gmail.com
 executables: []
@@ -220,6 +248,7 @@ files:
 - .gitignore
 - .rspec
 - .travis.yml
+- .yardopts
 - CHANGELOG.md
 - Gemfile
 - README.md
@@ -227,22 +256,47 @@ files:
 - datamappify.gemspec
 - lib/datamappify.rb
 - lib/datamappify/data.rb
+- lib/datamappify/data/criteria.rb
+- lib/datamappify/data/criteria/active_record/count.rb
+- lib/datamappify/data/criteria/active_record/destroy.rb
+- lib/datamappify/data/criteria/active_record/exists.rb
+- lib/datamappify/data/criteria/active_record/find.rb
+- lib/datamappify/data/criteria/active_record/find_by_key.rb
+- lib/datamappify/data/criteria/active_record/save.rb
+- lib/datamappify/data/criteria/active_record/save_by_key.rb
+- lib/datamappify/data/criteria/active_record/transaction.rb
+- lib/datamappify/data/criteria/common.rb
+- lib/datamappify/data/criteria/relational/count.rb
+- lib/datamappify/data/criteria/relational/find.rb
+- lib/datamappify/data/criteria/relational/find_by_key.rb
+- lib/datamappify/data/criteria/relational/save.rb
+- lib/datamappify/data/criteria/relational/save_by_key.rb
+- lib/datamappify/data/criteria/sequel/count.rb
+- lib/datamappify/data/criteria/sequel/destroy.rb
+- lib/datamappify/data/criteria/sequel/exists.rb
+- lib/datamappify/data/criteria/sequel/find.rb
+- lib/datamappify/data/criteria/sequel/find_by_key.rb
+- lib/datamappify/data/criteria/sequel/save.rb
+- lib/datamappify/data/criteria/sequel/save_by_key.rb
+- lib/datamappify/data/criteria/sequel/transaction.rb
 - lib/datamappify/data/errors.rb
+- lib/datamappify/data/mapper.rb
+- lib/datamappify/data/mapper/attribute.rb
+- lib/datamappify/data/provider.rb
 - lib/datamappify/data/provider/active_record.rb
-- lib/datamappify/data/provider/active_record/persistence.rb
-- lib/datamappify/data/provider/common/persistence.rb
-- lib/datamappify/data/provider/common/relational/persistence.rb
-- lib/datamappify/data/provider/common/relational/record/mapper.rb
-- lib/datamappify/data/provider/common/relational/record/writer.rb
+- lib/datamappify/data/provider/common_provider.rb
 - lib/datamappify/data/provider/sequel.rb
-- lib/datamappify/data/provider/sequel/persistence.rb
+- lib/datamappify/data/record.rb
 - lib/datamappify/entity.rb
 - lib/datamappify/repository.rb
-- lib/datamappify/repository/attribute_source_data_class_builder.rb
-- lib/datamappify/repository/attributes_mapper.rb
-- lib/datamappify/repository/dsl.rb
-- lib/datamappify/repository/mapping_hash.rb
-- lib/datamappify/util.rb
+- lib/datamappify/repository/mapping_dsl.rb
+- lib/datamappify/repository/query_method.rb
+- lib/datamappify/repository/query_method/count.rb
+- lib/datamappify/repository/query_method/destroy.rb
+- lib/datamappify/repository/query_method/find.rb
+- lib/datamappify/repository/query_method/method.rb
+- lib/datamappify/repository/query_method/save.rb
+- lib/datamappify/repository/query_method/transaction.rb
 - lib/datamappify/version.rb
 - spec/entity_spec.rb
 - spec/repository/persistence_spec.rb
@@ -287,7 +341,7 @@ rubyforge_project:
 rubygems_version: 2.0.0
 signing_key: 
 specification_version: 4
-summary: Separate domain logic from data persistence.
+summary: Compose and manage domain logic and data persistence separately and intelligently.
 test_files:
 - spec/entity_spec.rb
 - spec/repository/persistence_spec.rb
@@ -309,3 +363,4 @@ test_files:
 - spec/support/repositories/sequel/user_repository.rb
 - spec/support/tables/active_record.rb
 - spec/support/tables/sequel.rb
+has_rdoc: 

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

@@ -1,31 +0,0 @@
-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/common/persistence.rb

@@ -1,57 +0,0 @@
-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

@@ -1,85 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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