hanami-model 0.6.1 → 0.7.0

data/lib/hanami/model/sql/consoles/postgresql.rb

@@ -0,0 +1,68 @@
+require_relative 'abstract'
+
+module Hanami
+  module Model
+    module Sql
+      module Consoles
+        # PostgreSQL adapter
+        #
+        # @since 0.7.0
+        # @api private
+        class Postgresql < Abstract
+          # @since 0.7.0
+          # @api private
+          COMMAND = 'psql'.freeze
+
+          # @since 0.7.0
+          # @api private
+          PASSWORD = 'PGPASSWORD'.freeze
+
+          # @since 0.7.0
+          # @api private
+          def connection_string
+            configure_password
+            concat(command, host, database, port, username)
+          end
+
+          private
+
+          # @since 0.7.0
+          # @api private
+          def command
+            COMMAND
+          end
+
+          # @since 0.7.0
+          # @api private
+          def host
+            " -h #{@uri.host}"
+          end
+
+          # @since 0.7.0
+          # @api private
+          def database
+            " -d #{database_name}"
+          end
+
+          # @since 0.7.0
+          # @api private
+          def port
+            " -p #{@uri.port}" unless @uri.port.nil?
+          end
+
+          # @since 0.7.0
+          # @api private
+          def username
+            " -U #{@uri.user}" unless @uri.user.nil?
+          end
+
+          # @since 0.7.0
+          # @api private
+          def configure_password
+            ENV[PASSWORD] = @uri.password unless @uri.password.nil?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hanami/model/sql/consoles/sqlite.rb

@@ -0,0 +1,46 @@
+require_relative 'abstract'
+require 'shellwords'
+
+module Hanami
+  module Model
+    module Sql
+      module Consoles
+        # SQLite adapter
+        #
+        # @since 0.7.0
+        # @api private
+        class Sqlite < Abstract
+          # @since 0.7.0
+          # @api private
+          COMMAND = 'sqlite3'.freeze
+
+          # @since 0.7.0
+          # @api private
+          def connection_string
+            concat(command, ' ', host, database)
+          end
+
+          private
+
+          # @since 0.7.0
+          # @api private
+          def command
+            COMMAND
+          end
+
+          # @since 0.7.0
+          # @api private
+          def host
+            @uri.host unless @uri.host.nil?
+          end
+
+          # @since 0.7.0
+          # @api private
+          def database
+            Shellwords.escape(@uri.path)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hanami/model/sql/entity/schema.rb

@@ -0,0 +1,125 @@
+require 'hanami/entity/schema'
+require 'hanami/model/types'
+require 'hanami/model/association'
+
+module Hanami
+  module Model
+    module Sql
+      module Entity
+        # SQL Entity schema
+        #
+        # This schema setup is automatic.
+        #
+        # Hanami looks at the database columns, associations and potentially to
+        # the mapping in the repository (optional, only for legacy databases).
+        #
+        # @since 0.7.0
+        # @api private
+        #
+        # @see Hanami::Entity::Schema
+        class Schema < Hanami::Entity::Schema
+          # Build a new instance of Schema according to database columns,
+          # associations and potentially to mapping defined by the repository.
+          #
+          # @param registry [Hash] a registry that keeps reference between
+          #   entities klass and their underscored names
+          # @param relation [ROM::Relation] the database relation
+          # @param mapping [Hanami::Model::Mapping] the optional repository
+          #   mapping
+          #
+          # @return [Hanami::Model::Sql::Entity::Schema] the schema
+          #
+          # @since 0.7.0
+          # @api private
+          def initialize(registry, relation, mapping)
+            attributes  = build(registry, relation, mapping)
+            @schema     = Types::Coercible::Hash.schema(attributes)
+            @attributes = Hash[attributes.map { |k, _| [k, true] }]
+            freeze
+          end
+
+          # Check if the attribute is known
+          #
+          # @param name [Symbol] the attribute name
+          #
+          # @return [TrueClass,FalseClass] the result of the check
+          #
+          # @since 0.7.0
+          # @api private
+          def attribute?(name)
+            attributes.key?(name)
+          end
+
+          private
+
+          # @since 0.7.0
+          # @api private
+          attr_reader :attributes
+
+          # Build the schema
+          #
+          # @param registry [Hash] a registry that keeps reference between
+          #   entities klass and their underscored names
+          # @param relation [ROM::Relation] the database relation
+          # @param mapping [Hanami::Model::Mapping] the optional repository
+          #   mapping
+          #
+          # @return [Dry::Types::Constructor] the inner schema
+          #
+          # @since 0.7.0
+          # @api private
+          def build(registry, relation, mapping)
+            build_attributes(relation, mapping).merge(
+              build_associations(registry, relation.associations)
+            )
+          end
+
+          # Extract a set of attributes from the database table or from the
+          # optional repository mapping.
+          #
+          # @param relation [ROM::Relation] the database relation
+          # @param mapping [Hanami::Model::Mapping] the optional repository
+          #   mapping
+          #
+          # @return [Hash] a set of attributes
+          #
+          # @since 0.7.0
+          # @api private
+          def build_attributes(relation, mapping)
+            schema = relation.schema.to_h
+            schema.each_with_object({}) do |(attribute, type), result|
+              attribute = mapping.translate(attribute) if mapping.reverse?
+              result[attribute] = coercible(type)
+            end
+          end
+
+          # Merge attributes and associations
+          #
+          # @param registry [Hash] a registry that keeps reference between
+          #   entities klass and their underscored names
+          # @param associations [ROM::AssociationSet] a set of associations for
+          #   the current relation
+          #
+          # @return [Hash] attributes with associations
+          #
+          # @since 0.7.0
+          # @api private
+          def build_associations(registry, associations)
+            associations.each_with_object({}) do |(name, association), result|
+              target       = registry.fetch(name)
+              result[name] = Association.lookup(association).schema_type(target)
+            end
+          end
+
+          # Converts given ROM type into coercible type for entity attribute
+          #
+          # @since 0.7.0
+          # @api private
+          def coercible(type)
+            Types::Schema.coercible(type)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hanami/model/sql/types.rb

@@ -0,0 +1,95 @@
+require 'hanami/model/types'
+require 'rom/types'
+
+module Hanami
+  module Model
+    module Sql
+      # Types definitions for SQL databases
+      #
+      # @since 0.7.0
+      module Types
+        include Dry::Types.module
+
+        # Types for schema definitions
+        #
+        # @since 0.7.0
+        module Schema
+          require 'hanami/model/sql/types/schema/coercions'
+
+          String   = Types::Optional::Coercible::String
+
+          Int      = Types::Strict::Nil | Types::Int.constructor(Coercions.method(:int))
+          Float    = Types::Strict::Nil | Types::Float.constructor(Coercions.method(:float))
+          Decimal  = Types::Strict::Nil | Types::Float.constructor(Coercions.method(:decimal))
+
+          Bool     = Types::Strict::Nil | Types::Strict::Bool
+
+          Date     = Types::Strict::Nil | Types::Date.constructor(Coercions.method(:date))
+          DateTime = Types::Strict::Nil | Types::DateTime.constructor(Coercions.method(:datetime))
+          Time     = Types::Strict::Nil | Types::Time.constructor(Coercions.method(:time))
+
+          Array    = Types::Strict::Nil | Types::Array.constructor(Coercions.method(:array))
+          Hash     = Types::Strict::Nil | Types::Array.constructor(Coercions.method(:hash))
+
+          # @since 0.7.0
+          # @api private
+          MAPPING = {
+            Types::String.with(meta: {})            => Schema::String,
+            Types::Int.with(meta: {})               => Schema::Int,
+            Types::Float.with(meta: {})             => Schema::Float,
+            Types::Decimal.with(meta: {})           => Schema::Decimal,
+            Types::Bool.with(meta: {})              => Schema::Bool,
+            Types::Date.with(meta: {})              => Schema::Date,
+            Types::DateTime.with(meta: {})          => Schema::DateTime,
+            Types::Time.with(meta: {})              => Schema::Time,
+            Types::Array.with(meta: {})             => Schema::Array,
+            Types::Hash.with(meta: {})              => Schema::Hash,
+            Types::String.optional.with(meta: {})   => Schema::String,
+            Types::Int.optional.with(meta: {})      => Schema::Int,
+            Types::Float.optional.with(meta: {})    => Schema::Float,
+            Types::Decimal.optional.with(meta: {})  => Schema::Decimal,
+            Types::Bool.optional.with(meta: {})     => Schema::Bool,
+            Types::Date.optional.with(meta: {})     => Schema::Date,
+            Types::DateTime.optional.with(meta: {}) => Schema::DateTime,
+            Types::Time.optional.with(meta: {})     => Schema::Time,
+            Types::Array.optional.with(meta: {})    => Schema::Array,
+            Types::Hash.optional.with(meta: {})     => Schema::Hash
+          }.freeze
+
+          # Convert given type into coercible
+          #
+          # @since 0.7.0
+          # @api private
+          def self.coercible(type)
+            return type if type.constrained?
+            MAPPING.fetch(type.with(meta: {}), type)
+          end
+
+          # Coercer for SQL associations target
+          #
+          # @since 0.7.0
+          # @api private
+          class AssociationType < Hanami::Model::Types::Schema::CoercibleType
+            # Check if value can be coerced
+            #
+            # @param value [Object] the value
+            #
+            # @return [TrueClass,FalseClass] the result of the check
+            #
+            # @since 0.7.0
+            # @api private
+            def valid?(value)
+              value.inspect =~ /\[#{primitive}\]/ || super
+            end
+
+            # @since 0.7.0
+            # @api private
+            def success(*args)
+              result(Dry::Types::Result::Success, primitive.new(args.first.to_h))
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hanami/model/sql/types/schema/coercions.rb

@@ -0,0 +1,198 @@
+require 'hanami/utils/string'
+
+module Hanami
+  module Model
+    module Sql
+      module Types
+        module Schema
+          # Coercions for schema types
+          #
+          # @since 0.7.0
+          # @api private
+          #
+          # rubocop:disable Metrics/MethodLength
+          module Coercions
+            # Coerces given argument into Integer
+            #
+            # @param arg [#to_i,#to_int] the argument to coerce
+            #
+            # @return [Integer] the result of the coercion
+            #
+            # @raise [ArgumentError] if the coercion fails
+            #
+            # @since 0.7.0
+            # @api private
+            def self.int(arg)
+              case arg
+              when ::Integer
+                arg
+              when ::Float, ::BigDecimal, ::String, ::Hanami::Utils::String, ->(a) { a.respond_to?(:to_int) }
+                ::Kernel.Integer(arg)
+              else
+                raise ArgumentError.new("invalid value for Integer(): #{arg.inspect}")
+              end
+            end
+
+            # Coerces given argument into Float
+            #
+            # @param arg [#to_f] the argument to coerce
+            #
+            # @return [Float] the result of the coercion
+            #
+            # @raise [ArgumentError] if the coercion fails
+            #
+            # @since 0.7.0
+            # @api private
+            def self.float(arg)
+              case arg
+              when ::Float
+                arg
+              when ::Integer, ::BigDecimal, ::String, ::Hanami::Utils::String, ->(a) { a.respond_to?(:to_f) && !a.is_a?(::Time) }
+                ::Kernel.Float(arg)
+              else
+                raise ArgumentError.new("invalid value for Float(): #{arg.inspect}")
+              end
+            end
+
+            # Coerces given argument into BigDecimal
+            #
+            # @param arg [#to_d] the argument to coerce
+            #
+            # @return [BigDecimal] the result of the coercion
+            #
+            # @raise [ArgumentError] if the coercion fails
+            #
+            # @since 0.7.0
+            # @api private
+            def self.decimal(arg)
+              case arg
+              when ::BigDecimal
+                arg
+              when ::Integer, ::Float, ::String, ::Hanami::Utils::String
+                ::BigDecimal.new(arg, ::Float::DIG)
+              when ->(a) { a.respond_to?(:to_d) }
+                arg.to_d
+              else
+                raise ArgumentError.new("invalid value for BigDecimal(): #{arg.inspect}")
+              end
+            end
+
+            # Coerces given argument into Date
+            #
+            # @param arg [#to_date,String] the argument to coerce
+            #
+            # @return [Date] the result of the coercion
+            #
+            # @raise [ArgumentError] if the coercion fails
+            #
+            # @since 0.7.0
+            # @api private
+            def self.date(arg)
+              case arg
+              when ::Date
+                arg
+              when ::String, ::Hanami::Utils::String
+                ::Date.parse(arg)
+              when ::Time, ::DateTime, ->(a) { a.respond_to?(:to_date) }
+                arg.to_date
+              else
+                raise ArgumentError.new("invalid value for Date(): #{arg.inspect}")
+              end
+            end
+
+            # Coerces given argument into DateTime
+            #
+            # @param arg [#to_datetime,String] the argument to coerce
+            #
+            # @return [DateTime] the result of the coercion
+            #
+            # @raise [ArgumentError] if the coercion fails
+            #
+            # @since 0.7.0
+            # @api private
+            def self.datetime(arg)
+              case arg
+              when ::DateTime
+                arg
+              when ::String, ::Hanami::Utils::String
+                ::DateTime.parse(arg)
+              when ::Date, ::Time, ->(a) { a.respond_to?(:to_datetime) }
+                arg.to_datetime
+              else
+                raise ArgumentError.new("invalid value for DateTime(): #{arg.inspect}")
+              end
+            end
+
+            # Coerces given argument into Time
+            #
+            # @param arg [#to_time,String] the argument to coerce
+            #
+            # @return [Time] the result of the coercion
+            #
+            # @raise [ArgumentError] if the coercion fails
+            #
+            # @since 0.7.0
+            # @api private
+            def self.time(arg)
+              case arg
+              when ::Time
+                arg
+              when ::String, ::Hanami::Utils::String
+                ::Time.parse(arg)
+              when ::Date, ::DateTime, ->(a) { a.respond_to?(:to_time) }
+                arg.to_time
+              when ::Integer
+                ::Time.at(arg)
+              else
+                raise ArgumentError.new("invalid value for Time(): #{arg.inspect}")
+              end
+            end
+
+            # Coerces given argument into Array
+            #
+            # @param arg [#to_ary] the argument to coerce
+            #
+            # @return [Array] the result of the coercion
+            #
+            # @raise [ArgumentError] if the coercion fails
+            #
+            # @since 0.7.0
+            # @api private
+            def self.array(arg)
+              case arg
+              when ::Array
+                arg
+              when ->(a) { a.respond_to?(:to_ary) }
+                ::Kernel.Array(arg)
+              else
+                raise ArgumentError.new("invalid value for Array(): #{arg.inspect}")
+              end
+            end
+
+            # Coerces given argument into Hash
+            #
+            # @param arg [#to_hash] the argument to coerce
+            #
+            # @return [Hash] the result of the coercion
+            #
+            # @raise [ArgumentError] if the coercion fails
+            #
+            # @since 0.7.0
+            # @api private
+            def self.hash(arg)
+              case arg
+              when ::Hash
+                arg
+              when ->(a) { a.respond_to?(:to_hash) }
+                ::Kernel.Hash(arg)
+              else
+                raise ArgumentError.new("invalid value for Hash(): #{arg.inspect}")
+              end
+            end
+          end
+          # rubocop:enable Metrics/MethodLength
+        end
+      end
+    end
+  end
+end