hanami-model 0.6.1 → 0.7.0

data/lib/hanami/model.rb

@@ -1,172 +1,86 @@
-require 'hanami/model/version'
+require 'rom'
+require 'concurrent'
 require 'hanami/entity'
-require 'hanami/entity/dirty_tracking'
 require 'hanami/repository'
-require 'hanami/model/mapper'
-require 'hanami/model/configuration'
-require 'hanami/model/error'
 
 module Hanami
-  # Model
+  # Hanami persistence
   #
   # @since 0.1.0
   module Model
-    include Utils::ClassAttribute
+    require 'hanami/model/version'
+    require 'hanami/model/error'
+    require 'hanami/model/configuration'
+    require 'hanami/model/configurator'
+    require 'hanami/model/mapping'
+    require 'hanami/model/plugins'
 
-    # Framework configuration
-    #
-    # @since 0.2.0
     # @api private
-    class_attribute :configuration
-    self.configuration = Configuration.new
+    # @since 0.7.0
+    @__repositories__ = Concurrent::Array.new # rubocop:disable Style/VariableNumber
 
-    # Configure the framework.
-    # It yields the given block in the context of the configuration
-    #
-    # @param blk [Proc] the configuration block
-    #
-    # @since 0.2.0
+    class << self
+      # @since 0.7.0
+      # @api private
+      attr_reader :config
+
+      # @since 0.7.0
+      # @api private
+      attr_reader :loaded
+
+      # @since 0.7.0
+      # @api private
+      alias loaded? loaded
+    end
+
+    # Configure the framework
     #
-    # @see Hanami::Model
+    # @since 0.1.0
     #
     # @example
     #   require 'hanami/model'
     #
     #   Hanami::Model.configure do
-    #     adapter type: :sql, uri: 'postgres://localhost/database'
-    #
-    #     mapping do
-    #       collection :users do
-    #         entity User
+    #     adapter :sql, ENV['DATABASE_URL']
     #
-    #         attribute :id,   Integer
-    #         attribute :name, String
-    #       end
-    #     end
+    #     migrations 'db/migrations'
+    #     schema     'db/schema.sql'
     #   end
-    #
-    # Adapter MUST follow the convention in which adapter class is inflection of adapter name
-    # The above example has name :sql, thus derived class will be `Hanami::Model::Adapters::SqlAdapter`
-    def self.configure(&blk)
-      configuration.instance_eval(&blk)
+    def self.configure(&block)
+      @config = Configurator.build(&block)
       self
     end
 
-    # Load the framework
+    # Current configuration
     #
-    # @since 0.2.0
-    # @api private
-    def self.load!
-      configuration.load!
+    # @since 0.1.0
+    def self.configuration
+      @configuration ||= Configuration.new(config)
     end
 
-    # Unload the framework
-    #
-    # @since 0.2.0
+    # @since 0.7.0
     # @api private
-    def self.unload!
-      configuration.unload!
+    def self.repositories
+      @__repositories__
     end
 
-    # Duplicate Hanami::Model in order to create a new separated instance
-    # of the framework.
-    #
-    # The new instance of the framework will be completely decoupled from the
-    # original. It will inherit the configuration, but all the changes that
-    # happen after the duplication, won't be reflected on the other copies.
-    #
-    # @return [Module] a copy of Hanami::Model
-    #
-    # @since 0.2.0
+    # @since 0.7.0
     # @api private
-    #
-    # @example Basic usage
-    #   require 'hanami/model'
-    #
-    #   module MyApp
-    #     Model = Hanami::Model.dupe
-    #   end
-    #
-    #   MyApp::Model == Hanami::Model # => false
-    #
-    #   MyApp::Model.configuration ==
-    #     Hanami::Model.configuration # => false
-    #
-    # @example Inheriting configuration
-    #   require 'hanami/model'
-    #
-    #   Hanami::Model.configure do
-    #     adapter type: :sql, uri: 'sqlite3://uri'
-    #   end
-    #
-    #   module MyApp
-    #     Model = Hanami::Model.dupe
-    #   end
-    #
-    #   module MyApi
-    #     Model = Hanami::Model.dupe
-    #     Model.configure do
-    #       adapter type: :sql, uri: 'postgresql://uri'
-    #     end
-    #   end
-    #
-    #   Hanami::Model.configuration.adapter_config.uri # => 'sqlite3://uri'
-    #   MyApp::Model.configuration.adapter_config.uri # => 'sqlite3://uri'
-    #   MyApi::Model.configuration.adapter_config.uri # => 'postgresql://uri'
-    def self.dupe
-      dup.tap do |duplicated|
-        duplicated.configuration = Configuration.new
-      end
+    def self.container
+      raise 'Not loaded' unless loaded?
+      @container
     end
 
-    # Duplicate the framework and generate modules for the target application
-    #
-    # @param mod [Module] the Ruby namespace of the application
-    # @param blk [Proc] an optional block to configure the framework
-    #
-    # @return [Module] a copy of Hanami::Model
-    #
-    # @since 0.2.0
-    #
-    # @see Hanami::Model#dupe
-    # @see Hanami::Model::Configuration
-    #
-    # @example Basic usage
-    #   require 'hanami/model'
-    #
-    #   module MyApp
-    #     Model = Hanami::Model.dupe
-    #   end
-    #
-    #   # It will:
-    #   #
-    #   # 1. Generate MyApp::Model
-    #   # 2. Generate MyApp::Entity
-    #   # 3. Generate MyApp::Repository
-    #
-    #   MyApp::Model      == Hanami::Model # => false
-    #   MyApp::Repository == Hanami::Repository # => false
-    #
-    # @example Block usage
-    #   require 'hanami/model'
-    #
-    #   module MyApp
-    #     Model = Hanami::Model.duplicate(self) do
-    #       adapter type: :memory, uri: 'memory://localhost'
-    #     end
-    #   end
-    #
-    #   Hanami::Model.configuration.adapter_config # => nil
-    #   MyApp::Model.configuration.adapter_config # => #<Hanami::Model::Config::Adapter:0x007ff0ff0244f8 @type=:memory, @uri="memory://localhost", @class_name="MemoryAdapter">
-    def self.duplicate(mod, &blk)
-      dupe.tap do |duplicated|
-        mod.module_eval %{
-          Entity = Hanami::Entity.dup
-          Repository = Hanami::Repository.dup
-        }
+    # @since 0.1.0
+    def self.load!(&blk) # rubocop:disable Metrics/AbcSize
+      configuration.setup.auto_registration(config.directory.to_s) unless config.directory.nil?
+      configuration.instance_eval(&blk)                            if     block_given?
+      repositories.each(&:load!)
+
+      @container = ROM.container(configuration)
+      configuration.define_entities_mappings(@container, repositories)
 
-        duplicated.configure(&blk) if block_given?
-      end
+      @loaded = true
     end
   end
 end

data/lib/hanami/model/association.rb

@@ -0,0 +1,37 @@
+require 'rom-sql'
+require 'hanami/model/associations/has_many'
+require 'hanami/model/associations/belongs_to'
+
+module Hanami
+  module Model
+    # Association factory
+    #
+    # @since 0.7.0
+    # @api private
+    class Association
+      # Instantiate an association
+      #
+      # @since 0.7.0
+      # @api private
+      def self.build(repository, target, subject)
+        lookup(repository.root.associations[target])
+          .new(repository, repository.root.name.to_sym, target, subject)
+      end
+
+      # Translate ROM SQL associations into Hanami::Model associations
+      #
+      # @since 0.7.0
+      # @api private
+      def self.lookup(association)
+        case association
+        when ROM::SQL::Association::OneToMany
+          Associations::HasMany
+        when ROM::SQL::Association::ManyToOne
+          Associations::BelongsTo
+        else
+          raise "Unsupported association: #{association}"
+        end
+      end
+    end
+  end
+end

data/lib/hanami/model/associations/belongs_to.rb

@@ -0,0 +1,19 @@
+require 'hanami/model/types'
+
+module Hanami
+  module Model
+    module Associations
+      # Many-To-One association
+      #
+      # @since 0.7.0
+      # @api private
+      class BelongsTo
+        # @since 0.7.0
+        # @api private
+        def self.schema_type(entity)
+          Sql::Types::Schema::AssociationType.new(entity)
+        end
+      end
+    end
+  end
+end

data/lib/hanami/model/associations/dsl.rb

@@ -0,0 +1,29 @@
+module Hanami
+  module Model
+    module Associations
+      # Auto-infer relations linked to repository's associations
+      #
+      # @since 0.7.0
+      # @api private
+      class Dsl
+        # @since 0.7.0
+        # @api private
+        def initialize(repository, &blk)
+          @repository = repository
+          instance_eval(&blk)
+        end
+
+        # @since 0.7.0
+        # @api private
+        def has_many(relation, *)
+          @repository.__send__(:relations, relation)
+        end
+
+        # @since 0.7.0
+        # @api private
+        def belongs_to(*)
+        end
+      end
+    end
+  end
+end

data/lib/hanami/model/associations/has_many.rb

@@ -0,0 +1,200 @@
+require 'hanami/model/types'
+
+module Hanami
+  module Model
+    module Associations
+      # One-To-Many association
+      #
+      # @since 0.7.0
+      # @api private
+      class HasMany
+        # @since 0.7.0
+        # @api private
+        def self.schema_type(entity)
+          type = Sql::Types::Schema::AssociationType.new(entity)
+          Types::Strict::Array.member(type)
+        end
+
+        # @since 0.7.0
+        # @api private
+        attr_reader :repository
+
+        # @since 0.7.0
+        # @api private
+        attr_reader :source
+
+        # @since 0.7.0
+        # @api private
+        attr_reader :target
+
+        # @since 0.7.0
+        # @api private
+        attr_reader :subject
+
+        # @since 0.7.0
+        # @api private
+        attr_reader :scope
+
+        # @since 0.7.0
+        # @api private
+        def initialize(repository, source, target, subject, scope = nil)
+          @repository = repository
+          @source     = source
+          @target     = target
+          @subject    = subject.to_hash unless subject.nil?
+          @scope      = scope || _build_scope
+          freeze
+        end
+
+        # @since 0.7.0
+        # @api private
+        def create(data)
+          entity.new(
+            command(:create, aggregate(target), use: [:timestamps])
+              .call(data)
+          )
+        end
+
+        # @since 0.7.0
+        # @api private
+        def add(data)
+          command(:create, relation(target), use: [:timestamps])
+            .call(associate(data))
+        end
+
+        # @since 0.7.0
+        # @api private
+        def remove(id)
+          target_relation = relation(target)
+
+          command(:update, target_relation.where(target_relation.primary_key => id), use: [:timestamps])
+            .call(unassociate)
+        end
+
+        # @since 0.7.0
+        # @api private
+        def delete
+          scope.delete
+        end
+
+        # @since 0.7.0
+        # @api private
+        def each(&blk)
+          scope.each(&blk)
+        end
+
+        # @since 0.7.0
+        # @api private
+        def map(&blk)
+          to_a.map(&blk)
+        end
+
+        # @since 0.7.0
+        # @api private
+        def to_a
+          scope.to_a
+        end
+
+        # @since 0.7.0
+        # @api private
+        def where(condition)
+          __new__(scope.where(condition))
+        end
+
+        # @since 0.7.0
+        # @api private
+        def count
+          scope.count
+        end
+
+        private
+
+        # @since 0.7.0
+        # @api private
+        def command(target, relation, options = {})
+          repository.command(target, relation, options)
+        end
+
+        # @since 0.7.0
+        # @api private
+        def entity
+          repository.class.entity
+        end
+
+        # @since 0.7.0
+        # @api private
+        def relation(name)
+          repository.relations[name]
+        end
+
+        # @since 0.7.0
+        # @api private
+        def aggregate(name)
+          repository.aggregate(name)
+        end
+
+        # @since 0.7.0
+        # @api private
+        def association(name)
+          relation(target).associations[name]
+        end
+
+        # @since 0.7.0
+        # @api private
+        def associate(data)
+          relation(source)
+            .associations[target]
+            .associate(container.relations, data, subject)
+        end
+
+        # @since 0.7.0
+        # @api private
+        def unassociate
+          { foreign_key => nil }
+        end
+
+        # @since 0.7.0
+        # @api private
+        def container
+          repository.container
+        end
+
+        # @since 0.7.0
+        # @api private
+        def primary_key
+          association_keys.first
+        end
+
+        # @since 0.7.0
+        # @api private
+        def foreign_key
+          association_keys.last
+        end
+
+        # Returns primary key and foreign key
+        #
+        # @since 0.7.0
+        # @api private
+        def association_keys
+          relation(source)
+            .associations[target]
+            .__send__(:join_key_map, container.relations)
+        end
+
+        # @since 0.7.0
+        # @api private
+        def _build_scope
+          result = relation(target)
+          result = result.where(foreign_key => subject.fetch(primary_key)) unless subject.nil?
+          result.as(Repository::MAPPER_NAME)
+        end
+
+        # @since 0.7.0
+        # @api private
+        def __new__(new_scope)
+          self.class.new(repository, source, target, subject, new_scope)
+        end
+      end
+    end
+  end
+end