lotus-model 0.1.2 → 0.2.0

data/lib/lotus/model/config/mapper.rb

@@ -0,0 +1,45 @@
+require 'lotus/utils/kernel'
+
+module Lotus
+  module Model
+    module Config
+      # Read mapping file for mapping DSL
+      #
+      # @since 0.2.0
+      # @api private
+      class Mapper
+        EXTNAME = '.rb'
+
+        def initialize(path=nil, &blk)
+          if block_given?
+            @blk = blk
+          elsif path
+            @path = root.join(path)
+          else
+            raise Lotus::Model::InvalidMappingError.new('You must specify a block or a file.')
+          end
+        end
+
+        def to_proc
+          unless @blk
+            code = realpath.read
+            @blk = Proc.new { eval(code) }
+          end
+
+          @blk
+        end
+
+        private
+        def realpath
+          Utils::Kernel.Pathname("#{ @path }#{ EXTNAME }").realpath
+        rescue Errno::ENOENT
+          raise ArgumentError, 'You must specify a valid filepath.'
+        end
+
+        def root
+          Utils::Kernel.Pathname(Dir.pwd).realpath
+        end
+      end
+    end
+  end
+end

data/lib/lotus/model/configuration.rb

@@ -0,0 +1,187 @@
+require 'lotus/model/config/adapter'
+require 'lotus/model/config/mapper'
+
+module Lotus
+  module Model
+    # Configuration for the framework, models and adapters.
+    #
+    # Lotus::Model has its own global configuration that can be manipulated
+    # via `Lotus::Model.configure`.
+    #
+    # @since 0.2.0
+    class Configuration
+
+      # The persistence mapper
+      #
+      # @return [Lotus::Model::Mapper]
+      #
+      # @since 0.2.0
+      attr_reader :mapper
+
+      # An adapter configuration template
+      #
+      # @return [Lotus::Model::Config::Adapter]
+      #
+      # @since 0.2.0
+      attr_reader :adapter_config
+
+      # Initialize a configuration instance
+      #
+      # @return [Lotus::Model::Configuration] a new configuration's
+      #   instance
+      #
+      # @since 0.2.0
+      def initialize
+        reset!
+      end
+
+      # Reset all the values to the defaults
+      #
+      # @return void
+      #
+      # @since 0.2.0
+      def reset!
+        @adapter = nil
+        @adapter_config = nil
+        @mapper = NullMapper.new
+        @mapper_config = nil
+      end
+
+      alias_method :unload!, :reset!
+
+      # Load the configuration for the current framework
+      #
+      # @return void
+      #
+      # @since 0.2.0
+      def load!
+        _build_mapper
+        _build_adapter
+
+        mapper.load!(@adapter)
+      end
+
+      # Register adapter
+      #
+      # There could only 1 adapter can be registered per application
+      #
+      # @overload adapter
+      #   Retrieves the configured adapter
+      #   @return [Lotus::Model::Config::Adapter,NilClass] the adapter, if
+      #     present
+      #
+      # @overload adapter
+      #   Register the adapter
+      #     @param @options [Hash] A set of options to register an adapter
+      #     @option options [Symbol] :type The adapter type. Eg. :sql, :memory
+      #       (mandatory)
+      #     @option options [String] :uri The database uri string (mandatory)
+      #
+      # @return void
+      #
+      # @raise [ArgumentError] if one of the mandatory options is omitted
+      #
+      # @see Lotus::Model.configure
+      # @see Lotus::Model::Config::Adapter
+      #
+      # @example Register the adapter
+      #   require 'lotus/model'
+      #
+      #   Lotus::Model.configure do
+      #     adapter type: :sql, uri: 'sqlite3://localhost/database'
+      #   end
+      #
+      #   Lotus::Model.adapter_config
+      #
+      # @since 0.2.0
+      def adapter(options = nil)
+        if options.nil?
+          @adapter_config
+        else
+          _check_adapter_options!(options)
+          @adapter_config ||= Lotus::Model::Config::Adapter.new(options)
+        end
+      end
+
+      # Set global persistence mapping
+      #
+      # @overload mapping(blk)
+      #   Specify a set of mapping in the given block
+      #   @param blk [Proc] the mapping definitions
+      #
+      # @overload mapping(path)
+      #   Specify a relative path where to find the mapping file
+      #   @param path [String] the relative path
+      #
+      # @return void
+      #
+      # @see Lotus::Model.configure
+      # @see Lotus::Model::Mapper
+      #
+      # @example Set global persistence mapper
+      #   require 'lotus/model'
+      #
+      #   Lotus::Model.configure do
+      #     mapping do
+      #       collection :users do
+      #         entity User
+      #
+      #         attribute :id,   Integer
+      #         attribute :name, String
+      #       end
+      #     end
+      #   end
+      #
+      # @since 0.2.0
+      def mapping(path=nil, &blk)
+        @mapper_config = Lotus::Model::Config::Mapper.new(path, &blk)
+      end
+
+      # Duplicate by copying the settings in a new instance.
+      #
+      # @return [Lotus::Model::Configuration] a copy of the configuration
+      #
+      # @since 0.2.0
+      # @api private
+      def duplicate
+        Configuration.new.tap do |c|
+          c.instance_variable_set(:@adapter_config, @adapter_config)
+          c.instance_variable_set(:@mapper, @mapper)
+        end
+      end
+
+      private
+
+      # Instantiate mapper from mapping block
+      #
+      # @see Lotus::Model::Configuration#mapping
+      #
+      # @api private
+      # @since 0.2.0
+      def _build_mapper
+        @mapper = Lotus::Model::Mapper.new(&@mapper_config.to_proc) if @mapper_config
+      end
+
+      # @api private
+      # @since 0.1.0
+      def _build_adapter
+        @adapter = adapter_config.build(mapper)
+      end
+
+      # @api private
+      # @since 0.2.0
+      #
+      # NOTE Drop this manual check when Ruby 2.0 will not be supported anymore.
+      #   Use keyword arguments instead.
+      def _check_adapter_options!(options)
+        # TODO Maybe this is a candidate for Lotus::Utils::Options
+        # We already have two similar cases:
+        #   1. Lotus::Router :only/:except for RESTful resources
+        #   2. Lotus::Validations.validate_options!
+        [:type, :uri].each do |keyword|
+          raise ArgumentError.new("missing keyword: #{keyword}") if !options.keys.include?(keyword)
+        end
+      end
+    end
+  end
+end

data/lib/lotus/model/mapper.rb

@@ -2,6 +2,26 @@ require 'lotus/model/mapping'
 
 module Lotus
   module Model
+    # Error for missing mapper
+    # It's raised when loading model without mapper
+    #
+    # @since 0.2.0
+    #
+    # @see Lotus::Model::Configuration#mapping
+    class NoMappingError < ::StandardError
+      def initialize
+        super("Mapping is missing. Please check your framework configuration.")
+      end
+    end
+
+    # @since 0.2.0
+    # @api private
+    class NullMapper
+      def method_missing(m, *args)
+        raise NoMappingError.new
+      end
+    end
+
     # A persistence mapper that keeps entities independent from database details.
     #
     # This is database independent. It can work with SQL, document, and even
@@ -61,6 +81,7 @@ module Lotus
       def initialize(coercer = nil, &blk)
         @coercer     = coercer || Mapping::Coercer
         @collections = {}
+
         instance_eval(&blk) if block_given?
       end
 
@@ -81,7 +102,6 @@ module Lotus
         if block_given?
           @collections[name] = Mapping::Collection.new(name, @coercer, &blk)
         else
-          # TODO implement a getter with a private API.
           @collections[name] or raise Mapping::UnmappedCollectionError.new(name)
         end
       end
@@ -92,8 +112,11 @@ module Lotus
       # application.
       #
       # @since 0.1.0
-      def load!
-        @collections.each_value { |collection| collection.load! }
+      def load!(adapter = nil)
+        @collections.each_value do |collection|
+          collection.adapter = adapter
+          collection.load!
+        end
         self
       end
     end

data/lib/lotus/model/mapping.rb

@@ -19,6 +19,30 @@ module Lotus
           super("Cannot find collection: #{ name }")
         end
       end
+
+      # Invalid entity error.
+      #
+      # It gets raised when the application tries to access to a existing
+      # entity.
+      #
+      # @since 0.2.0
+      class EntityNotFound < ::StandardError
+        def initialize(name)
+          super("Cannot find class for entity: #{ name }")
+        end
+      end
+
+      # Invalid repository error.
+      #
+      # It gets raised when the application tries to access to a existing
+      # repository.
+      #
+      # @since 0.2.0
+      class RepositoryNotFound < ::StandardError
+        def initialize(name)
+          super("Cannot find class for repository: #{ name }")
+        end
+      end
     end
   end
 end

data/lib/lotus/model/mapping/coercer.rb

@@ -58,15 +58,15 @@ module Lotus
           instance_eval %{
             def to_record(entity)
               if entity.id
-                Hash[*[#{ @collection.attributes.map{|name,(_,mapped)| ":#{mapped},entity.#{name}"}.join(',') }]]
+                Hash[#{ @collection.attributes.map{|name,(_,mapped)| ":#{mapped},entity.#{name}"}.join(',') }]
               else
-                Hash[*[#{ @collection.attributes.reject{|name,_| name == @collection.identity }.map{|name,(_,mapped)| ":#{mapped},entity.#{name}"}.join(',') }]]
+                Hash[#{ @collection.attributes.reject{|name,_| name == @collection.identity }.map{|name,(_,mapped)| ":#{mapped},entity.#{name}"}.join(',') }]
               end
             end
 
             def from_record(record)
               #{ @collection.entity }.new(
-                Hash[*[#{ @collection.attributes.map{|name,(klass,mapped)| ":#{name},Lotus::Model::Mapping::Coercions.#{klass}(record[:#{mapped}])"}.join(',') }]]
+                Hash[#{ @collection.attributes.map{|name,(klass,mapped)| ":#{name},Lotus::Model::Mapping::Coercions.#{klass}(record[:#{mapped}])"}.join(',') }]
               )
             end
 

data/lib/lotus/model/mapping/coercions.rb

@@ -112,6 +112,21 @@ module Lotus
           Utils::Kernel.Integer(arg) unless arg.nil?
         end
 
+        # Coerce into a BigDecimal, unless the argument is nil
+        #
+        # @param arg [Object] the object to coerce
+        #
+        # @return [BigDecimal] the result of the coercion
+        #
+        # @raise [TypeError] if the argument can't be coerced
+        #
+        # @since 0.2.0
+        #
+        # @see http://rdoc.info/gems/lotus-utils/Lotus/Utils/Kernel#BigDecimal-class_method
+        def self.BigDecimal(arg)
+          Utils::Kernel.BigDecimal(arg) unless arg.nil?
+        end
+
         # Coerce into a Set, unless the argument is nil
         #
         # @param arg [Object] the object to coerce
@@ -142,6 +157,21 @@ module Lotus
           Utils::Kernel.String(arg) unless arg.nil?
         end
 
+        # Coerce into a Symbol, unless the argument is nil
+        #
+        # @param arg [Object] the object to coerce
+        #
+        # @return [Symbol] the result of the coercion
+        #
+        # @raise [TypeError] if the argument can't be coerced
+        #
+        # @since 0.2.0
+        #
+        # @see http://rdoc.info/gems/lotus-utils/Lotus/Utils/Kernel#Symbol-class_method
+        def self.Symbol(arg)
+          Utils::Kernel.Symbol(arg) unless arg.nil?
+        end
+
         # Coerce into a Time, unless the argument is nil
         #
         # @param arg [Object] the object to coerce

data/lib/lotus/model/mapping/collection.rb

@@ -1,3 +1,5 @@
+require 'lotus/utils/class'
+
 module Lotus
   module Model
     module Mapping
@@ -70,18 +72,27 @@ module Lotus
         # @api private
         attr_reader :attributes
 
+        # @attr_reader adapter [Lotus::Model::Adapters] the instance of adapter
+        #
+        # @since 0.1.0
+        # @api private
+        attr_accessor :adapter
+
         # Instantiate a new collection
         #
         # @param name [Symbol] the name of the mapped collection. If used with a
         #   SQL database it's the table name.
         #
+        # @param coercer_class [Class] the coercer class
         # @param blk [Proc] the block that maps the attributes of that collection.
         #
         # @since 0.1.0
         #
         # @see Lotus::Model::Mapper#collection
         def initialize(name, coercer_class, &blk)
-          @name, @coercer_class, @attributes = name, coercer_class, {}
+          @name = name
+          @coercer_class = coercer_class
+          @attributes = {}
           instance_eval(&blk) if block_given?
         end
 
@@ -90,11 +101,34 @@ module Lotus
         # The entity can be any kind of object as long as it implements the
         # following interface: `#initialize(attributes = {})`.
         #
-        # @param klass [Class] the entity persisted with this collection.
+        # @param klass [Class, String] the entity persisted with this collection.
         #
         # @since 0.1.0
         #
         # @see Lotus::Entity
+        #
+        # @example Set entity with class name
+        #   require 'lotus/model'
+        #
+        #   mapper = Lotus::Model::Mapper.new do
+        #     collection :articles do
+        #       entity Article
+        #     end
+        #   end
+        #
+        #   mapper.entity #=> Article
+        #
+        # @example Set entity with class name string
+        #   require 'lotus/model'
+        #
+        #   mapper = Lotus::Model::Mapper.new do
+        #     collection :articles do
+        #       entity 'Article'
+        #     end
+        #   end
+        #
+        #   mapper.entity #=> Article
+        #
         def entity(klass = nil)
           if klass
             @entity = klass
@@ -103,9 +137,50 @@ module Lotus
           end
         end
 
+        # Defines the repository that interacts with this collection.
+        #
+        # @param klass [Class, String] the repository that interacts with this collection.
+        #
+        # @since 0.2.0
+        #
+        # @see Lotus::Repository
+        #
+        # @example Set repository with class name
+        #   require 'lotus/model'
+        #
+        #   mapper = Lotus::Model::Mapper.new do
+        #     collection :articles do
+        #       entity Article
+        #
+        #       repository RemoteArticleRepository
+        #     end
+        #   end
+        #
+        #   mapper.repository #=> RemoteArticleRepository
+        #
+        # @example Set repository with class name string
+        #   require 'lotus/model'
+        #
+        #   mapper = Lotus::Model::Mapper.new do
+        #     collection :articles do
+        #       entity Article
+        #
+        #       repository 'RemoteArticleRepository'
+        #     end
+        #   end
+        #
+        #   mapper.repository #=> RemoteArticleRepository
+        def repository(klass = nil)
+          if klass
+            @repository = klass
+          else
+            @repository ||= default_repository_klass
+          end
+        end
+
         # Defines the identity for a collection.
         #
-        # An identity is an unique value that identifies a record.
+        # An identity is a unique value that identifies a record.
         # If used with an SQL table it corresponds to the primary key.
         #
         # This is an optional feature.
@@ -182,6 +257,7 @@ module Lotus
         #   * Integer
         #   * Set
         #   * String
+        #   * Symbol
         #   * Time
         #
         # @param name [Symbol] the name of the attribute, as we want it to be
@@ -208,7 +284,7 @@ module Lotus
         #   #
         #   # class User
         #   #   include Lotus::Entity
-        #   #   self.attributes = :name
+        #   #   attributes :name
         #   # end
         #
         #   mapper = Lotus::Model::Mapper.new do
@@ -245,7 +321,7 @@ module Lotus
         #   #
         #   # class Article
         #   #   include Lotus::Entity
-        #   #   self.attributes = :user_id, :title, :comments_count
+        #   #   attributes :user_id, :title, :comments_count
         #   # end
         #
         #   mapper = Lotus::Model::Mapper.new do
@@ -314,22 +390,64 @@ module Lotus
         # @api private
         # @since 0.1.0
         def load!
-          @coercer = coercer_class.new(self)
-          configure_repository!
+          _load_entity!
+          _load_repository!
+          _load_coercer!
+
+          _configure_repository!
         end
 
         private
+
         # Assigns a repository to an entity
         #
         # @see Lotus::Repository
         #
         # @api private
         # @since 0.1.0
-        def configure_repository!
-          repository = Object.const_get("#{ entity.name }#{ REPOSITORY_SUFFIX }")
+        def _configure_repository!
           repository.collection = name
+          repository.adapter = adapter if adapter
+        end
+
+        # Convert repository string to repository class
+        #
+        # @api private
+        # @since 0.2.0
+        def _load_repository!
+          @repository = Utils::Class.load!(repository)
+        rescue NameError
+          raise Lotus::Model::Mapping::RepositoryNotFound.new(repository.to_s)
+        end
+
+        # Convert entity string to entity class
+        #
+        # @api private
+        # @since 0.2.0
+        def _load_entity!
+          @entity = Utils::Class.load!(entity)
         rescue NameError
+          raise Lotus::Model::Mapping::EntityNotFound.new(entity.to_s)
         end
+
+        # Load coercer
+        #
+        # @api private
+        # @since 0.1.0
+        def _load_coercer!
+          @coercer = coercer_class.new(self)
+        end
+
+        # Retrieves the default repository class
+        #
+        # @see Lotus::Repository
+        #
+        # @api private
+        # @since 0.2.0
+        def default_repository_klass
+          "#{ entity }#{ REPOSITORY_SUFFIX }"
+        end
+
       end
     end
   end