lotus-model 0.4.1 → 0.5.0

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

@@ -1,4 +1,5 @@
 require 'lotus/utils/class'
+require 'lotus/model/mapping/attribute'
 
 module Lotus
   module Model
@@ -227,7 +228,7 @@ module Lotus
         # Think of Redis, where everything is stored as a string or integer,
         # the mapper translates values from/to the database.
         #
-        # It supports the following types:
+        # It supports the following types (coercers):
         #
         #   * Array
         #   * Boolean
@@ -245,13 +246,17 @@ module Lotus
         # @param name [Symbol] the name of the attribute, as we want it to be
         #   mapped in the object
         #
-        # @param klass [Class] the Ruby type that we want to assign as value
+        # @param coercer [.load, .dump] a class that implements coercer interface
         #
         # @param options [Hash] a set of options to customize the mapping
         # @option options [Symbol] :as the name of the original column
         #
+        # @raise [NameError] if coercer cannot be found
+        #
         # @since 0.1.0
         #
+        # @see Lotus::Model::Coercer
+        #
         # @example Default schema
         #   require 'lotus/model'
         #
@@ -281,8 +286,8 @@ module Lotus
         #   # The first argument (`:name`) always corresponds to the `User`
         #   # attribute.
         #
-        #   # The second one (`:klass`) is the Ruby type that we want for our
-        #   # attribute.
+        #   # The second one (`:coercer`) is the Ruby type coercer that we want
+        #   # for our attribute.
         #
         #   # We don't need to use `:as` because the database columns match the
         #   # `User` attributes.
@@ -322,7 +327,7 @@ module Lotus
         #   # The first argument (`:name`) always corresponds to the `Article`
         #   # attribute.
         #
-        #   # The second one (`:klass`) is the Ruby type that we want for our
+        #   # The second one (`:coercer`) is the Ruby type that we want for our
         #   # attribute.
         #
         #   # The third option (`:as`) is mandatory only when the database
@@ -330,8 +335,57 @@ module Lotus
         #   #
         #   # For instance: we need to use it for translate `:s_title` to
         #   # `:title`, but not for `:comments_count`.
-        def attribute(name, klass, options = {})
-          @attributes[name] = [klass, (options.fetch(:as) { name }).to_sym]
+        #
+        # @example Custom coercer
+        #   require 'lotus/model'
+        #
+        #   # Given the following schema:
+        #   #
+        #   # CREATE TABLE articles (
+        #   #   id     integer NOT NULL,
+        #   #   title  varchar(128),
+        #   #   tags   text[],
+        #   # );
+        #   #
+        #   # The following entity:
+        #   #
+        #   # class Article
+        #   #   include Lotus::Entity
+        #   #   attributes :title, :tags
+        #   # end
+        #   #
+        #   # And the following custom coercer:
+        #   #
+        #   # require 'lotus/model/coercer'
+        #   # require 'sequel/extensions/pg_array'
+        #   #
+        #   # class PGArray < Lotus::Model::Coercer
+        #   #   def self.dump(value)
+        #   #     ::Sequel.pg_array(value) rescue nil
+        #   #   end
+        #   #
+        #   #   def self.load(value)
+        #   #     ::Kernel.Array(value) unless value.nil?
+        #   #   end
+        #   # end
+        #
+        #   mapper = Lotus::Model::Mapper.new do
+        #     collection :articles do
+        #       entity Article
+        #
+        #       attribute :id,    Integer
+        #       attribute :title, String
+        #       attribute :tags,  PGArray
+        #     end
+        #   end
+        #
+        #   # When an entity is persisted as record into the database,
+        #   # `PGArray.dump` is invoked.
+        #
+        #   # When an entity is retrieved from the database, it will be
+        #   # deserialized as an Array via `PGArray.load`.
+        def attribute(name, coercer, options = {})
+          @attributes[name] = Attribute.new(name, coercer, options)
         end
 
         # Serializes an entity to be persisted in the database.

data/lib/lotus/model/mapping/{coercer.rb → collection_coercer.rb}

@@ -1,5 +1,3 @@
-require 'lotus/model/mapping/coercer'
-
 module Lotus
   module Model
     module Mapping
@@ -7,7 +5,7 @@ module Lotus
       #
       # @api private
       # @since 0.1.0
-      class Coercer
+      class CollectionCoercer
         # Initialize a coercer for the given collection.
         #
         # @param collection [Lotus::Model::Mapping::Collection] the collection
@@ -47,10 +45,10 @@ module Lotus
         # @api private
         # @since 0.1.0
         def _compile!
-          code = @collection.attributes.map do |_,(klass,mapped)|
+          code = @collection.attributes.map do |_,attr|
             %{
-            def deserialize_#{ mapped }(value)
-              Lotus::Model::Mapping::Coercions.#{klass}(value)
+            def deserialize_#{ attr.mapped }(value)
+              #{ attr.load_coercer }(value)
             end
             }
           end.join("\n")
@@ -58,17 +56,17 @@ module Lotus
           instance_eval <<-EVAL, __FILE__, __LINE__
             def to_record(entity)
               if entity.id
-                Hash[#{ @collection.attributes.map{|name,(klass,mapped)| ":#{mapped},Lotus::Model::Mapping::Coercions.#{klass}(entity.#{name})"}.join(',') }]
+                Hash[#{ @collection.attributes.map{|name,attr| ":#{ attr.mapped },#{ attr.dump_coercer }(entity.#{name})"}.join(',') }]
               else
                 Hash[].tap do |record|
-                  #{ @collection.attributes.reject{|name,_| name == @collection.identity }.map{|name,(klass,mapped)| "value = Lotus::Model::Mapping::Coercions.#{klass}(entity.#{name}); record[:#{mapped}] = value unless value.nil?"}.join('; ') }
+                  #{ @collection.attributes.reject{|name,_| name == @collection.identity }.map{|name,attr| "value = #{ attr.dump_coercer }(entity.#{name}); record[:#{attr.mapped}] = value unless value.nil?"}.join('; ') }
                 end
               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,attr| ":#{name},#{attr.load_coercer}(record[:#{attr.mapped}])"}.join(',') }]
               )
             end
 

data/lib/lotus/model/migrator.rb

@@ -1,5 +1,6 @@
 require 'sequel'
 require 'sequel/extensions/migration'
+require 'lotus/model/migrator/connection'
 require 'lotus/model/migrator/adapter'
 
 module Lotus
@@ -314,7 +315,7 @@ module Lotus
       # @since 0.4.0
       # @api private
       def self.migrations?
-        migrations.children.any?
+        Dir["#{ migrations }/*.rb"].any?
       end
     end
   end

data/lib/lotus/model/migrator/adapter.rb

@@ -46,7 +46,7 @@ module Lotus
         # @since 0.4.0
         # @api private
         def initialize(connection)
-          @connection = connection
+          @connection = Connection.new(connection)
         end
 
         # Create database.
@@ -57,7 +57,7 @@ module Lotus
         #
         # @see Lotus::Model::Migrator.create
         def create
-          raise MigrationError.new("Current adapter (#{ @connection.database_type }) doesn't support create.")
+          raise MigrationError.new("Current adapter (#{ connection.database_type }) doesn't support create.")
         end
 
         # Drop database.
@@ -68,7 +68,7 @@ module Lotus
         #
         # @see Lotus::Model::Migrator.drop
         def drop
-          raise MigrationError.new("Current adapter (#{ @connection.database_type }) doesn't support drop.")
+          raise MigrationError.new("Current adapter (#{ connection.database_type }) doesn't support drop.")
         end
 
         # Load database schema.
@@ -79,7 +79,7 @@ module Lotus
         #
         # @see Lotus::Model::Migrator.prepare
         def load
-          raise MigrationError.new("Current adapter (#{ @connection.database_type }) doesn't support load.")
+          raise MigrationError.new("Current adapter (#{ connection.database_type }) doesn't support load.")
         end
 
         # Database version.
@@ -87,25 +87,32 @@ module Lotus
         # @since 0.4.0
         # @api private
         def version
-          return unless @connection.tables.include?(MIGRATIONS_TABLE)
+          return unless connection.adapter_connection.tables.include?(MIGRATIONS_TABLE)
 
-          if record = @connection[MIGRATIONS_TABLE].order(MIGRATIONS_TABLE_VERSION_COLUMN).last
+          if record = connection.adapter_connection[MIGRATIONS_TABLE].order(MIGRATIONS_TABLE_VERSION_COLUMN).last
             record.fetch(MIGRATIONS_TABLE_VERSION_COLUMN).scan(/\A[\d]{14}/).first.to_s
           end
         end
 
         private
 
-        # @since 0.4.0
+        # @since 0.5.0
         # @api private
-        def new_connection
-          uri = URI.parse(@connection.uri)
-          scheme, userinfo, host, port = uri.select(:scheme, :userinfo, :host, :port)
+        attr_reader :connection
 
-          uri  = "#{ scheme }://"
-          uri += "#{ userinfo }@" unless userinfo.nil?
-          uri += host
-          uri += ":#{ port }" unless port.nil?
+        # Returns a database connection
+        #
+        # Given a DB connection URI we can connect to a specific database or not, we need this when creating
+        # or droping a database. Important to notice that we can't always open a _global_ DB connection,
+        # because most of the times application's DB user has no rights to do so.
+        #
+        # @param global [Boolean] determine whether or not a connection should specify an database.
+        #
+        # @since 0.5.0
+        # @api private
+        #
+        def new_connection(global: false)
+          uri = global ? connection.global_uri : connection.uri
 
           Sequel.connect(uri)
         end
@@ -113,31 +120,31 @@ module Lotus
         # @since 0.4.0
         # @api private
         def database
-          escape options.fetch(:database)
+          escape connection.database
         end
 
         # @since 0.4.0
         # @api private
-        def host
-          escape options.fetch(:host)
+        def port
+          escape connection.port
         end
 
         # @since 0.4.0
         # @api private
-        def port
-          escape options.fetch(:port)
+        def host
+          escape connection.host
         end
 
         # @since 0.4.0
         # @api private
         def username
-          escape options.fetch(:user)
+          escape connection.user
         end
 
         # @since 0.4.0
         # @api private
         def password
-          escape options.fetch(:password)
+          escape connection.password
         end
 
         # @since 0.4.0
@@ -152,12 +159,6 @@ module Lotus
           escape MIGRATIONS_TABLE
         end
 
-        # @since 0.4.0
-        # @api private
-        def options
-          @connection.opts
-        end
-
         # @since 0.4.0
         # @api private
         def escape(string)

data/lib/lotus/model/migrator/connection.rb

@@ -0,0 +1,133 @@
+module Lotus
+  module Model
+    module Migrator
+      # Sequel connection wrapper
+      #
+      # Normalize external adapters interfaces
+      #
+      # @since 0.5.0
+      # @api private
+      class Connection
+        attr_reader :adapter_connection
+
+        def initialize(adapter_connection)
+          @adapter_connection = adapter_connection
+        end
+
+        # Returns DB connection host
+        #
+        # Even when adapter doesn't provide it explicitly it tries to parse
+        #
+        # @since 0.5.0
+        # @api private
+        def host
+          @host ||= opts.fetch(:host, parsed_uri.host)
+        end
+
+        # Returns DB connection port
+        #
+        # Even when adapter doesn't provide it explicitly it tries to parse
+        #
+        # @since 0.5.0
+        # @api private
+        def port
+          @port ||= opts.fetch(:port, parsed_uri.port)
+        end
+
+        # Returns DB name from conenction
+        #
+        # Even when adapter doesn't provide it explicitly it tries to parse
+        #
+        # @since 0.5.0
+        # @api private
+        def database
+          @database ||= opts.fetch(:database, parsed_uri.path[1..-1])
+        end
+
+        # Returns DB type
+        #
+        # @example
+        #   connection.database_type
+        #   # => 'postgres'
+        #
+        # @since 0.5.0
+        # @api private
+        def database_type
+          adapter_connection.database_type
+        end
+
+        # Returns user from DB connection
+        #
+        # Even when adapter doesn't provide it explicitly it tries to parse
+        #
+        # @since 0.5.0
+        # @api private
+        def user
+          @user ||= opts.fetch(:user, parsed_opt('user'))
+        end
+
+        # Returns user from DB connection
+        #
+        # Even when adapter doesn't provide it explicitly it tries to parse
+        #
+        # @since 0.5.0
+        # @api private
+        def password
+          @password ||= opts.fetch(:password, parsed_opt('password'))
+        end
+
+        # Returns DB connection URI directly from adapter
+        #
+        # @since 0.5.0
+        # @api private
+        def uri
+          adapter_connection.uri
+        end
+
+        # Returns DB connection wihout specifying database name
+        #
+        # @since 0.5.0
+        # @api private
+        def global_uri
+          adapter_connection.uri.sub(parsed_uri.select(:path).first, '')
+        end
+
+        # Returns a boolean telling if a DB connection is from JDBC or not
+        #
+        # @since 0.5.0
+        # @api private
+        def jdbc?
+          !adapter_connection.uri.scan('jdbc:').empty?
+        end
+
+        # Returns database connection URI instance without JDBC namespace
+        #
+        # @since 0.5.0
+        # @api private
+        def parsed_uri
+          @uri ||= URI.parse(adapter_connection.uri.sub('jdbc:', ''))
+        end
+
+        private
+
+        # Returns a value of a given query string param
+        #
+        # @param option [String] which option from database connection will be extracted from URI
+        #
+        # @since 0.5.0
+        # @api private
+        def parsed_opt(option)
+          parsed_uri.to_s.match(/[\?|\&]#{ option }=(\w+)\&?/).to_a.last
+        end
+
+        # Fetch connection options from adapter
+        #
+        # @since 0.5.0
+        # @api private
+        def opts
+          adapter_connection.opts
+        end
+      end
+    end
+  end
+end

data/lib/lotus/model/migrator/mysql_adapter.rb

@@ -9,13 +9,13 @@ module Lotus
         # @since 0.4.0
         # @api private
         def create
-          new_connection.run %(CREATE DATABASE #{ database };)
+          new_connection(global: true).run %(CREATE DATABASE #{ database };)
         end
 
         # @since 0.4.0
         # @api private
         def drop
-          new_connection.run %(DROP DATABASE #{ database };)
+          new_connection(global: true).run %(DROP DATABASE #{ database };)
         rescue Sequel::DatabaseError => e
           message = if e.message.match(/doesn\'t exist/)
             "Cannot find database: #{ database }"