datamappify 0.20.1 → 0.30.0

data/lib/datamappify/data/mapper/attribute.rb

@@ -0,0 +1,52 @@
+module Datamappify
+  module Data
+    class Mapper
+      # Represents an entity attribute and its associated data source
+      class Attribute
+        # @return [String]
+        attr_reader :name
+
+        # @return [String]
+        attr_reader :provider_name
+
+        # @return [String]
+        attr_reader :source_class_name
+
+        # @return [String]
+        attr_reader :source_attribute_name
+
+        # @param name [Symbol]
+        #   name of the attribute
+        #
+        # @param source [String]
+        #   data provider, class and attribute,
+        #   e.g. "ActiveRecord::User#surname"
+        def initialize(name, source)
+          @name = name.to_s
+
+          @provider_name, @source_class_name, @source_attribute_name = parse_source(source)
+        end
+
+        # @return [Class]
+        def source_class
+          @source_class ||= Record.find_or_build(provider_name, source_class_name)
+        end
+
+        # @return [Boolean]
+        def primary_key?
+          source_attribute_name == 'id'
+        end
+
+        private
+
+        # @return [Array<String>]
+        #   an array with provider name, source class name and source attribute name
+        def parse_source(source)
+          provider_name, source_class_and_attribute = source.split('::')
+
+          [provider_name, *source_class_and_attribute.split('#')]
+        end
+      end
+    end
+  end
+end

data/lib/datamappify/data/mapper.rb

@@ -0,0 +1,95 @@
+require 'set'
+require 'datamappify/data/mapper/attribute'
+
+module Datamappify
+  module Data
+    class Mapper
+      # @return [Class]
+      attr_accessor :entity_class
+
+      # @return [String]
+      attr_accessor :default_provider_name
+
+      # @return [Hash]
+      #   attribute name to source mapping as specified in {Repository::MappingDSL#map_attribute}
+      attr_accessor :custom_mapping
+
+      def initialize
+        @custom_mapping         = {}
+        @custom_attribute_names = []
+      end
+
+      # @return [Module]
+      def default_provider
+        @default_provider ||= Provider.const_get(default_provider_name)
+      end
+
+      # @return [Module]
+      def provider(provider_name)
+        Provider.const_get(provider_name)
+      end
+
+      # @return [Class]
+      def default_source_class
+        @default_source_class ||= default_provider.find_or_build_record_class(entity_class.name)
+      end
+
+      # @return [Hash]
+      #   attribute sets classified by the names of their data provider
+      def classified_attributes
+        @classified_attributes ||= Set.new(custom_attributes + default_attributes).classify(&:provider_name)
+      end
+
+      private
+
+      # @return [Array<Symbol>]
+      def all_attribute_names
+        entity_class.attribute_set.entries.collect(&:name)
+      end
+
+      # @return [Array<Symbol>]
+      def default_attribute_names
+        all_attribute_names - custom_attribute_names
+      end
+
+      # @return [Array<Symbol>]
+      def custom_attribute_names
+        # make sure custom attributes are always processed
+        custom_attributes
+
+        @custom_attribute_names
+      end
+
+      # @return [Array<Attribute>]
+      def default_attributes
+        @default_attributes ||= default_attribute_names.collect do |attribute|
+          Attribute.new(attribute, default_source_for(attribute))
+        end
+      end
+
+      # @return [Array<Attribute>]
+      def custom_attributes
+        @custom_attributes ||= custom_mapping.collect do |attribute, source|
+          map_attribute(attribute, source)
+        end
+      end
+
+      # @param (see Data::Mapper::Attribute#initialize)
+      #
+      # @return [Attribute]
+      def map_attribute(name, source)
+        @custom_attribute_names << name
+
+        Attribute.new(name, source)
+      end
+
+      # @param attribute [Symbol]
+      #   name of the attribute
+      #
+      # @return [String]
+      def default_source_for(attribute)
+        "#{default_provider_name}::#{entity_class.name}##{attribute}"
+      end
+    end
+  end
+end

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

@@ -1,14 +1,14 @@
-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))
+        extend CommonProvider
+
+        # @return [ActiveRecord::Base]
+        def self.build_record_class(source_class_name)
+          Datamappify::Data::Record::ActiveRecord.const_set(
+            source_class_name, Class.new(::ActiveRecord::Base)
+          )
         end
       end
     end

data/lib/datamappify/data/provider/common_provider.rb

@@ -0,0 +1,67 @@
+module Datamappify
+  module Data
+    module Provider
+      module CommonProvider
+        def self.extended(klass)
+          klass.extend ModuleMethods
+
+          klass.load_criterias
+        end
+
+        module ModuleMethods
+          # Loads all the criteria files from the data provider
+          #
+          # @return [void]
+          def load_criterias
+            Dir[Datamappify.root.join("data/criteria/#{path_name}/*.rb")].each { |file| require file }
+          end
+
+          # Non-namespaced class name
+          #
+          # @return [String]
+          def class_name
+            @class_name ||= name.demodulize
+          end
+
+          # @return [String]
+          def path_name
+            @path_name ||= class_name.underscore
+          end
+
+          # Finds or builds a data record class from the data provider
+          #
+          # @return [Class]
+          #   the data record class
+          def find_or_build_record_class(source_class_name)
+            if records_namespace.const_defined?(source_class_name, false)
+              records_namespace.const_get(source_class_name)
+            else
+              build_record_class(source_class_name)
+            end
+          end
+
+          private
+
+          # The namespace for the data records, e.g. +Datamappify::Data::Record::ActiveRecord+
+          #
+          # @return [Module]
+          def records_namespace
+            @records_namespace ||= Data::Record.const_set(class_name, Module.new)
+          end
+        end
+
+        # Builds a {Criteria}
+        #
+        # @param name [Symbol]
+        #
+        # @param args [any]
+        #
+        # @yield
+        #   an optional block passed to the +Criteria+ {Criteria::Common#initialize initialiser}
+        def build_criteria(name, *args, &block)
+          Data::Criteria.const_get(class_name).const_get(name).new(*args, &block).result
+        end
+      end
+    end
+  end
+end

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

@@ -1,16 +1,16 @@
-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))
-          )
+        extend CommonProvider
+
+        # @return [Sequel::Model]
+        def self.build_record_class(source_class_name)
+          Record::Sequel.const_set(
+            source_class_name, Class.new(::Sequel::Model(source_class_name.pluralize.underscore.to_sym))
+          ).tap do |klass|
+            klass.raise_on_save_failure = true
+          end
         end
       end
     end

data/lib/datamappify/data/provider.rb

@@ -0,0 +1,12 @@
+require 'datamappify/data/provider/common_provider'
+
+module Datamappify
+  module Data
+    module Provider
+      extend ActiveSupport::Autoload
+
+      autoload :ActiveRecord
+      autoload :Sequel
+    end
+  end
+end

data/lib/datamappify/data/record.rb

@@ -0,0 +1,13 @@
+module Datamappify
+  module Data
+    # A convenient class for finding or building a data record
+    module Record
+      # @param provider_name [String]
+      #
+      # @param source_class_name [String]
+      def self.find_or_build(provider_name, source_class_name)
+        Provider.const_get(provider_name).find_or_build_record_class(source_class_name)
+      end
+    end
+  end
+end

data/lib/datamappify/data.rb

@@ -1,4 +1,8 @@
 require 'datamappify/data/errors'
+require 'datamappify/data/criteria'
+require 'datamappify/data/mapper'
+require 'datamappify/data/provider'
+require 'datamappify/data/record'
 
 module Datamappify
   module Data

data/lib/datamappify/repository/mapping_dsl.rb

@@ -0,0 +1,28 @@
+module Datamappify
+  module Repository
+    module MappingDSL
+      # @param entity_class [Class]
+      #   entity class
+      #
+      # @return [void]
+      def for_entity(entity_class)
+        data_mapper.entity_class = entity_class
+      end
+
+      # @param provider_name [String]
+      #   name of data provider
+      #
+      # @return [void]
+      def default_provider(provider_name)
+        data_mapper.default_provider_name = provider_name.to_s
+      end
+
+      # @param (see Data::Mapper::Attribute#initialize)
+      #
+      # @return [void]
+      def map_attribute(name, source)
+        data_mapper.custom_mapping[name] = source
+      end
+    end
+  end
+end

data/lib/datamappify/repository/query_method/count.rb

@@ -0,0 +1,12 @@
+module Datamappify
+  module Repository
+    module QueryMethod
+      class Count < Method
+        # @return [Integer]
+        def result
+          dispatch_criteria_to_default_source(:Count)
+        end
+      end
+    end
+  end
+end

data/lib/datamappify/repository/query_method/destroy.rb

@@ -0,0 +1,25 @@
+module Datamappify
+  module Repository
+    module QueryMethod
+      class Destroy < Method
+        # @param mapper (see Method#initialize)
+        #
+        # @param id_or_ids_or_entity_or_entities [Entity, Array<Entity>]
+        #   an entity or a collection of ids or entities
+        def initialize(mapper, id_or_ids_or_entity_or_entities)
+          super
+          @id_or_ids_or_entity_or_entities = id_or_ids_or_entity_or_entities
+        end
+
+        # @return [void, false]
+        def result
+          entities = Array.wrap(@id_or_ids_or_entity_or_entities).map do |id_or_entity|
+            dispatch_criteria_to_default_source(:Destroy, extract_entity_id(id_or_entity))
+          end
+
+          @id_or_ids_or_entity_or_entities.is_a?(Array) ? entities : entities[0]
+        end
+      end
+    end
+  end
+end

data/lib/datamappify/repository/query_method/find.rb

@@ -0,0 +1,41 @@
+module Datamappify
+  module Repository
+    module QueryMethod
+      class Find < Method
+        # @param mapper (see Method#initialize)
+        #
+        # @param id_or_ids [Integer, Array<Integer>]
+        #   an entity id or a collection of entity ids
+        def initialize(mapper, id_or_ids)
+          super
+          @id_or_ids = id_or_ids
+        end
+
+        # @return [Entity, Array<Entity>, nil]
+        def result
+          entities = Array.wrap(@id_or_ids).map { |id| setup_new_entity(id) }.compact
+
+          @id_or_ids.is_a?(Array) ? entities : entities[0]
+        end
+
+        private
+
+        # @param id [Integer]
+        #
+        # @return [Entity, nil]
+        def setup_new_entity(id)
+          entity = @mapper.entity_class.new
+          entity.id = id
+
+          if dispatch_criteria_to_default_source(:Exists, entity)
+            dispatch_criteria_to_providers(:FindByKey, entity)
+          else
+            entity = nil
+          end
+
+          entity
+        end
+      end
+    end
+  end
+end

data/lib/datamappify/repository/query_method/method.rb

@@ -0,0 +1,73 @@
+module Datamappify
+  module Repository
+    module QueryMethod
+      # Provides a default set of methods to the varies {QueryMethod} classes
+      class Method
+        # @param mapper [Data::Mapper]
+        #
+        # @param args [any]
+        def initialize(mapper, *args)
+          @mapper = mapper
+        end
+
+        protected
+
+        # Dispatches a {Criteria} according to
+        # the {Data::Mapper data mapper}'s default provider and default source class
+        #
+        # @param criteria_name [Symbol]
+        #
+        # @param args [any]
+        def dispatch_criteria_to_default_source(criteria_name, *args)
+          @mapper.default_provider.build_criteria(criteria_name, @mapper.default_source_class, *args)
+        end
+
+        # Dispatches a {Criteria} via {#attributes_walker}
+        #
+        # @param criteria_name [Symbol]
+        #
+        # @param entity [Entity]
+        #
+        # @return [void]
+        def dispatch_criteria_to_providers(criteria_name, entity)
+          attributes_walker do |provider_name, source_class, attributes|
+            @mapper.provider(provider_name).build_criteria(
+              criteria_name, source_class, entity, attributes
+            )
+          end
+        end
+
+        # Walks through the attributes and performs actions on them
+        #
+        # @yield [provider_name, source_class, attributes]
+        #   action to be performed on the attributes grouped by their source class
+        #
+        # @yieldparam provider_name [String]
+        #
+        # @yieldparam source_class [Class]
+        #
+        # @yieldparam attributes [Set]
+        #
+        # @return [void]
+        def attributes_walker(&block)
+          Transaction.new(@mapper) do
+            @mapper.classified_attributes.each do |provider_name, attributes|
+              attributes.classify(&:source_class).each do |source_class, attrs|
+                block.call(provider_name, source_class, attrs)
+              end
+            end
+          end
+        end
+
+        # Extract the id out of an entity, unless the argument is already an id
+        #
+        # @param id_or_entity [Entity, Integer]
+        #
+        # @return [Integer]
+        def extract_entity_id(id_or_entity)
+          id_or_entity.is_a?(Integer) ? id_or_entity : id_or_entity.id
+        end
+      end
+    end
+  end
+end

data/lib/datamappify/repository/query_method/save.rb

@@ -0,0 +1,42 @@
+module Datamappify
+  module Repository
+    module QueryMethod
+      class Save < Method
+        # @param mapper (see Method#initialize)
+        #
+        # @param entity_or_entities [Entity, Array<Entity>]
+        #   an entity or a collection of entities
+        def initialize(mapper, entity_or_entities)
+          super
+          @entity_or_entities = entity_or_entities
+        end
+
+        # @return [Entity, Array<Entity>, false]
+        def result
+          Array.wrap(@entity_or_entities).each do |entity|
+            create_or_update(entity)
+          end
+
+          @entity_or_entities
+        rescue Data::EntityInvalid
+          false
+        end
+
+        private
+
+        # @param entity [Entity]
+        #
+        # @raise [Data::EntityInvalid]
+        #
+        # @return [Entity]
+        def create_or_update(entity)
+          raise Data::EntityInvalid.new(entity) if entity.invalid?
+
+          dispatch_criteria_to_providers(:SaveByKey, entity)
+
+          entity
+        end
+      end
+    end
+  end
+end

data/lib/datamappify/repository/query_method/transaction.rb

@@ -0,0 +1,18 @@
+module Datamappify
+  module Repository
+    module QueryMethod
+      class Transaction < Method
+        # @param mapper (see Method#initialize)
+        #
+        # @yield
+        #   queries to be performed in the transaction
+        #
+        # @return [void]
+        def initialize(mapper, &block)
+          mapper.default_provider.build_criteria(:Transaction, mapper.default_source_class, &block)
+        end
+      end
+    end
+  end
+end
+

data/lib/datamappify/repository/query_method.rb

@@ -0,0 +1,3 @@
+require 'datamappify/repository/query_method/method'
+
+Dir[Datamappify.root.join('repository/query_method/*')].each { |file| require file }