hanami-model 0.6.1 → 0.7.0

data/hanami-model.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |spec|
   spec.version       = Hanami::Model::VERSION
   spec.authors       = ['Luca Guidi', 'Trung Lê', 'Alfonso Uceda']
   spec.email         = ['me@lucaguidi.com', 'trung.le@ruby-journal.com', 'uceda73@gmail.com']
-  spec.summary       = %q{A persistence layer for Hanami}
-  spec.description   = %q{A persistence framework with entities, repositories, data mapper and query objects}
+  spec.summary       = 'A persistence layer for Hanami'
+  spec.description   = 'A persistence framework with entities and repositories'
   spec.homepage      = 'http://hanamirb.org'
   spec.license       = 'MIT'
 
@@ -17,12 +17,15 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
-  spec.required_ruby_version = '>= 2.0.0'
+  spec.required_ruby_version = '>= 2.3.0'
 
-  spec.add_runtime_dependency 'hanami-utils', '~> 0.7'
-  spec.add_runtime_dependency 'sequel',       '~> 4.9'
+  spec.add_runtime_dependency 'hanami-utils',    '~> 0.8'
+  spec.add_runtime_dependency 'rom-sql',         '~> 0.9'
+  spec.add_runtime_dependency 'rom-repository',  '~> 0.3'
+  spec.add_runtime_dependency 'dry-types',       '~> 0.9'
+  spec.add_runtime_dependency 'concurrent-ruby', '~> 1.0'
 
   spec.add_development_dependency 'bundler',  '~> 1.6'
   spec.add_development_dependency 'minitest', '~> 5'
-  spec.add_development_dependency 'rake',     '~> 10'
+  spec.add_development_dependency 'rake',     '~> 11'
 end

data/lib/hanami/entity.rb

@@ -1,5 +1,4 @@
-require 'hanami/utils/kernel'
-require 'hanami/utils/attributes'
+require 'hanami/model/types'
 
 module Hanami
   # An object that is defined by its identity.
@@ -22,17 +21,8 @@ module Hanami
   #
   #   class Person
   #     include Hanami::Entity
-  #     attributes :name, :age
   #   end
   #
-  # When a class includes `Hanami::Entity` it receives the following interface:
-  #
-  #   * #id
-  #   * #id=
-  #   * #initialize(attributes = {})
-  #
-  # `Hanami::Entity` also provides the `.attributes=` for defining attribute accessors for the given names.
-  #
   # If we expand the code above in **pure Ruby**, it would be:
   #
   # @example Pure Ruby
@@ -60,239 +50,165 @@ module Hanami
   # @since 0.1.0
   #
   # @see Hanami::Repository
-  module Entity
-    # Inject the public API into the hosting class.
-    #
-    # @since 0.1.0
-    #
-    # @example With Object
-    #   require 'hanami/model'
-    #
-    #   class User
-    #     include Hanami::Entity
-    #   end
-    #
-    # @example With Struct
-    #   require 'hanami/model'
+  class Entity
+    require 'hanami/entity/schema'
+
+    # Syntactic shortcut to reference types in custom schema DSL
     #
-    #   User = Struct.new(:id, :name) do
-    #     include Hanami::Entity
-    #   end
-    def self.included(base)
-      base.class_eval do
-        extend ClassMethods
-        attributes :id
-      end
+    # @since 0.7.0
+    module Types
+      include Hanami::Model::Types
     end
 
+    # Class level interface
+    #
+    # @since 0.7.0
+    # @api private
     module ClassMethods
-      # (Re)defines getters, setters and initialization for the given attributes.
-      #
-      # These attributes can match the database columns, but this isn't a
-      # requirement. The mapper used by the relative repository will translate
-      # these names automatically.
-      #
-      # An entity can work with attributes not configured in the mapper, but
-      # of course they will be ignored when the entity will be persisted.
-      #
-      # Please notice that the required `id` attribute is automatically defined
-      # and can be omitted in the arguments.
+      # Define manual entity schema
       #
-      # @param attrs [Array<Symbol>] a set of arbitrary attribute names
+      # With a SQL database this setup happens automatically and you SHOULD NOT
+      # use this DSL. You should use only when you want to customize the automatic
+      # setup.
       #
-      # @since 0.2.0
+      # If you're working with an entity that isn't "backed" by a SQL table or
+      # with a schema-less database, you may want to manually setup a set of
+      # attributes via this DSL. If you don't do any setup, the entity accepts all
+      # the given attributes.
       #
-      # @see Hanami::Repository
-      # @see Hanami::Model::Mapper
+      # @param blk [Proc] the block that defines the attributes
       #
-      # @example
-      #   require 'hanami/model'
+      # @since 0.7.0
       #
-      #   class User
-      #     include Hanami::Entity
-      #     attributes :name, :age
-      #   end
-      #   User.attributes => #<Set: {:id, :name, :age}>
-      #
-      # @example Given params is array of attributes
-      #   require 'hanami/model'
-      #
-      #   class User
-      #     include Hanami::Entity
-      #     attributes [:name, :age]
-      #   end
-      #   User.attributes => #<Set: {:id, :name, :age}>
-      #
-      # @example Extend entity
-      #   require 'hanami/model'
-      #
-      #   class User
-      #     include Hanami::Entity
-      #     attributes :name
-      #   end
-      #
-      #   class DeletedUser < User
-      #     include Hanami::Entity
-      #     attributes :deleted_at
-      #   end
-      #
-      #   User.attributes => #<Set: {:id, :name}>
-      #   DeletedUser.attributes => #<Set: {:id, :name, :deleted_at}>
-      #
-      def attributes(*attrs)
-        return @attributes ||= Set.new unless attrs.any?
-
-        Hanami::Utils::Kernel.Array(attrs).each do |attr|
-          if allowed_attribute_name?(attr)
-            define_attr_accessor(attr)
-            self.attributes << attr
-          end
-        end
+      # @see Hanami::Entity
+      def attributes(&blk)
+        self.schema = Schema.new(&blk)
+        @attributes = true
       end
 
-      # Define setter/getter methods for attributes.
+      # Assign a schema
       #
-      # @param attr [Symbol] an attribute name
+      # @param value [Hanami::Entity::Schema] the schema
       #
-      # @since 0.3.1
+      # @since 0.7.0
       # @api private
-      def define_attr_accessor(attr)
-        attr_accessor(attr)
+      def schema=(value)
+        return if defined?(@attributes)
+        @schema = value
       end
 
-      # Check if attr_reader define the given attribute
-      #
-      # @since 0.5.1
+      # @since 0.7.0
       # @api private
-      def allowed_attribute_name?(name)
-        !instance_methods.include?(name)
-      end
-
-      protected
+      attr_reader :schema
+    end
 
-      # @see Class#inherited
-      def inherited(subclass)
-        subclass.attributes(*attributes)
-        super
+    # @since 0.7.0
+    # @api private
+    def self.inherited(klass)
+      klass.class_eval do
+        @schema = Schema.new
+        extend  ClassMethods
       end
     end
 
-    # Defines a generic, inefficient initializer, in case that the attributes
-    # weren't explicitly defined with `.attributes=`.
+    # Instantiate a new entity
     #
-    # @param attributes [Hash] a set of attribute names and values
+    # @param attributes [Hash,#to_h,NilClass] data to initialize the entity
     #
-    # @raise NoMethodError in case the given attributes are trying to set unknown
-    #   or private methods.
+    # @return [Hanami::Entity] the new entity instance
     #
-    # @since 0.1.0
+    # @raise [TypeError] if the given attributes are invalid
     #
-    # @see .attributes
-    def initialize(attributes = {})
-      attributes.each do |k, v|
-        setter = "#{ k }="
-        public_send(setter, v) if respond_to?(setter)
-      end
+    # @since 0.1.0
+    def initialize(attributes = nil)
+      @attributes = self.class.schema[attributes]
+      freeze
     end
 
-    # Overrides the equality Ruby operator
+    # Entity ID
     #
-    # Two entities are considered equal if they are instances of the same class
-    # and if they have the same #id.
+    # @return [Object,NilClass] the ID, if present
     #
-    # @since 0.1.0
-    def ==(other)
-      self.class == other.class &&
-         self.id == other.id
+    # @since 0.7.0
+    def id
+      attributes.fetch(:id, nil)
     end
 
-    # Return the hash of attributes
-    #
-    # @since 0.2.0
+    # Handle dynamic accessors
     #
-    # @example
-    #   require 'hanami/model'
-    #   class User
-    #     include Hanami::Entity
-    #     attributes :name
-    #   end
+    # If internal attributes set has the requested key, it returns the linked
+    # value, otherwise it raises a <tt>NoMethodError</tt>
     #
-    #   user = User.new(id: 23, name: 'Luca')
-    #   user.to_h # => { :id => 23, :name => "Luca" }
-    def to_h
-      Hash[attribute_names.map { |a| [a, read_attribute(a)] }]
+    # @since 0.7.0
+    def method_missing(m, *)
+      attribute?(m) or super # rubocop:disable Style/AndOr
+      attributes.fetch(m, nil)
     end
 
-    # Return the set of attribute names
+    # Implement generic equality for entities
     #
-    # @since 0.5.1
+    # Two entities are equal if they are instances of the same class and they
+    # have the same id.
     #
-    # @example
-    #   require 'hanami/model'
-    #   class User
-    #     include Hanami::Entity
-    #     attributes :name
-    #   end
+    # @param other [Object] the object of comparison
     #
-    #   user = User.new(id: 23, name: 'Luca')
-    #   user.attribute_names # #<Set: {:id, :name}>
-    def attribute_names
-      self.class.attributes
+    # @return [FalseClass,TrueClass] the result of the check
+    #
+    # @since 0.1.0
+    def ==(other)
+      self.class == other.class &&
+        id == other.id
     end
 
-    # Return the contents of the entity as a nicely formatted string.
+    # Implement predictable hashing for hash equality
     #
-    # Display all attributes of the entity for inspection (even if they are nil)
+    # @return [Integer] the object hash
     #
-    # @since 0.5.1
-    #
-    # @example
-    #   require 'hanami/model'
-    #   class User
-    #     include Hanami::Entity
-    #     attributes :name, :email
-    #   end
-    #
-    #   user = User.new(id: 23, name: 'Luca')
-    #   user.inspect # #<User:0x007fa7eefe0b58 @id=nil @name="Luca" @email=nil>
-    def inspect
-      attr_list = attribute_names.inject([]) do |res, name|
-        res << "@#{name}=#{read_attribute(name).inspect}"
-      end.join(' ')
-
-      "#<#{self.class.name}:0x00#{(__id__ << 1).to_s(16)} #{attr_list}>"
+    # @since 0.7.0
+    def hash
+      [self.class, id].hash
     end
 
-    alias_method :to_s, :inspect
+    # Freeze the entity
+    #
+    # @since 0.7.0
+    def freeze
+      attributes.freeze
+      super
+    end
 
-    # Set attributes for entity
+    # Serialize entity to a Hash
     #
-    # @since 0.2.0
+    # @return [Hash] the result of serialization
     #
-    # @example
-    #   require 'hanami/model'
-    #   class User
-    #     include Hanami::Entity
-    #     attributes :name
-    #   end
+    # @since 0.1.0
+    def to_h
+      attributes.deep_dup.to_h
+    end
+
+    # @since 0.7.0
+    alias to_hash to_h
+
+    protected
+
+    # Check if the attribute is allowed to be read
     #
-    #   user = User.new(name: 'Lucca')
-    #   user.update(name: 'Luca')
-    #   user.name # => 'Luca'
-    def update(attributes={})
-      attributes.each do |attribute, value|
-        public_send("#{attribute}=", value)
-      end
+    # @since 0.7.0
+    # @api private
+    def attribute?(name)
+      self.class.schema.attribute?(name)
     end
 
     private
 
-    # Return the value by attribute name
-    #
-    # @since 0.5.1
+    # @since 0.1.0
+    # @api private
+    attr_reader :attributes
+
+    # @since 0.7.0
     # @api private
-    def read_attribute(attr_name)
-      public_send(attr_name)
+    def respond_to_missing?(name, _include_all)
+      attribute?(name)
     end
   end
 end

data/lib/hanami/entity/schema.rb

@@ -0,0 +1,236 @@
+require 'hanami/model/types'
+require 'hanami/utils/hash'
+
+module Hanami
+  class Entity
+    # Entity schema is a definition of a set of typed attributes.
+    #
+    # @since 0.7.0
+    # @api private
+    #
+    # @example SQL Automatic Setup
+    #  require 'hanami/model'
+    #
+    #   class Account
+    #     include Hanami::Entity
+    #   end
+    #
+    #   account = Account.new(name: "Acme Inc.")
+    #   account.name # => "Hanami"
+    #
+    #   account = Account.new(foo: "bar")
+    #   account.foo # => NoMethodError
+    #
+    # @example Non-SQL Manual Setup
+    #   require 'hanami/model'
+    #
+    #   class Account
+    #     include Hanami::Entity
+    #
+    #     attributes do
+    #       attribute :id,         Types::Int
+    #       attribute :name,       Types::String
+    #       attribute :codes,      Types::Array(Types::Int)
+    #       attribute :users,      Types::Array(User)
+    #       attribute :email,      Types::String.constrained(format: /@/)
+    #       attribute :created_at, Types::DateTime
+    #     end
+    #   end
+    #
+    #   account = Account.new(name: "Acme Inc.")
+    #   account.name # => "Acme Inc."
+    #
+    #   account = Account.new(foo: "bar")
+    #   account.foo # => NoMethodError
+    #
+    # @example Schemaless Entity
+    #   require 'hanami/model'
+    #
+    #   class Account
+    #     include Hanami::Entity
+    #   end
+    #
+    #   account = Account.new(name: "Acme Inc.")
+    #   account.name # => "Acme Inc."
+    #
+    #   account = Account.new(foo: "bar")
+    #   account.foo # => "bar"
+    class Schema
+      # Schemaless entities logic
+      #
+      # @since 0.7.0
+      # @api private
+      class Schemaless
+        # @since 0.7.0
+        # @api private
+        def initialize
+          freeze
+        end
+
+        # @param attributes [#to_hash] the attributes hash
+        #
+        # @return [Hash]
+        #
+        # @since 0.7.0
+        # @api private
+        def call(attributes)
+          if attributes.nil?
+            {}
+          else
+            attributes.dup
+          end
+        end
+
+        # @since 0.7.0
+        # @api private
+        def attribute?(_name)
+          true
+        end
+      end
+
+      # Schema definition
+      #
+      # @since 0.7.0
+      # @api private
+      class Definition
+        # Schema DSL
+        #
+        # @since 0.7.0
+        class Dsl
+          # @since 0.7.0
+          # @api private
+          def self.build(&blk)
+            attributes = new(&blk).to_h
+            [attributes, Hanami::Model::Types::Coercible::Hash.schema(attributes)]
+          end
+
+          # @since 0.7.0
+          # @api private
+          def initialize(&blk)
+            @attributes = {}
+            instance_eval(&blk)
+          end
+
+          # Define an attribute
+          #
+          # @param name [Symbol] the attribute name
+          # @param type [Dry::Types::Definition] the attribute type
+          #
+          # @since 0.7.0
+          def attribute(name, type)
+            @attributes[name] = type
+          end
+
+          # @since 0.7.0
+          # @api private
+          def to_h
+            @attributes
+          end
+        end
+
+        # Instantiate a new DSL instance for an entity
+        #
+        # @param blk [Proc] the block that defines the attributes
+        #
+        # @return [Hanami::Entity::Schema::Dsl] the DSL
+        #
+        # @since 0.7.0
+        # @api private
+        def initialize(&blk)
+          raise LocalJumpError unless block_given?
+          @attributes, @schema = Dsl.build(&blk)
+          @attributes = Hash[@attributes.map { |k, _| [k, true] }]
+          freeze
+        end
+
+        # Process attributes
+        #
+        # @param attributes [#to_hash] the attributes hash
+        #
+        # @raise [TypeError] if the process fails
+        #
+        # @since 0.7.0
+        # @api private
+        def call(attributes)
+          schema.call(attributes)
+        rescue Dry::Types::SchemaError => e
+          raise TypeError.new(e.message)
+        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 :schema
+
+        # @since 0.7.0
+        # @api private
+        attr_reader :attributes
+      end
+
+      # Build a new instance of Schema with the attributes defined by the given block
+      #
+      # @param blk [Proc] the optional block that defines the attributes
+      #
+      # @return [Hanami::Entity::Schema] the schema
+      #
+      # @since 0.7.0
+      # @api private
+      def initialize(&blk)
+        @schema = if block_given?
+                    Definition.new(&blk)
+                  else
+                    Schemaless.new
+                  end
+      end
+
+      # Process attributes
+      #
+      # @param attributes [#to_hash] the attributes hash
+      #
+      # @raise [TypeError] if the process fails
+      #
+      # @since 0.7.0
+      # @api private
+      def call(attributes)
+        Utils::Hash.new(
+          schema.call(attributes)
+        ).symbolize!
+      end
+
+      # @since 0.7.0
+      # @api private
+      alias [] call
+
+      # 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)
+        schema.attribute?(name)
+      end
+
+      protected
+
+      # @since 0.7.0
+      # @api private
+      attr_reader :schema
+    end
+  end
+end