hanami-model 0.0.0 → 0.6.0

data/lib/hanami/model/adapters/memory_adapter.rb

@@ -0,0 +1,179 @@
+require 'hanami/model/adapters/abstract'
+require 'hanami/model/adapters/implementation'
+require 'hanami/model/adapters/memory/collection'
+require 'hanami/model/adapters/memory/command'
+require 'hanami/model/adapters/memory/query'
+
+module Hanami
+  module Model
+    module Adapters
+      # In memory adapter that behaves like a SQL database.
+      # Not all the features of the SQL adapter are supported.
+      #
+      # This adapter SHOULD be used only for development or testing purposes,
+      # because its computations are inefficient and the data is volatile.
+      #
+      # @see Hanami::Model::Adapters::Implementation
+      #
+      # @api private
+      # @since 0.1.0
+      class MemoryAdapter < Abstract
+        include Implementation
+
+        # Initialize the adapter.
+        #
+        # @param mapper [Object] the database mapper
+        # @param uri [String] the connection uri (ignored)
+        # @param options [Hash] a hash of non mandatory adapter options
+        #
+        # @return [Hanami::Model::Adapters::MemoryAdapter]
+        #
+        # @see Hanami::Model::Mapper
+        #
+        # @api private
+        # @since 0.1.0
+        def initialize(mapper, uri = nil, options = {})
+          super
+
+          @mutex       = Mutex.new
+          @collections = {}
+        end
+
+        # Creates a record in the database for the given entity.
+        # It assigns the `id` attribute, in case of success.
+        #
+        # @param collection [Symbol] the target collection (it must be mapped).
+        # @param entity [#id=] the entity to create
+        #
+        # @return [Object] the entity
+        #
+        # @api private
+        # @since 0.1.0
+        def create(collection, entity)
+          synchronize do
+            command(collection).create(entity)
+          end
+        end
+
+        # Updates a record in the database corresponding to the given entity.
+        #
+        # @param collection [Symbol] the target collection (it must be mapped).
+        # @param entity [#id] the entity to update
+        #
+        # @return [Object] the entity
+        #
+        # @api private
+        # @since 0.1.0
+        def update(collection, entity)
+          synchronize do
+            command(collection).update(entity)
+          end
+        end
+
+        # Deletes a record in the database corresponding to the given entity.
+        #
+        # @param collection [Symbol] the target collection (it must be mapped).
+        # @param entity [#id] the entity to delete
+        #
+        # @api private
+        # @since 0.1.0
+        def delete(collection, entity)
+          synchronize do
+            command(collection).delete(entity)
+          end
+        end
+
+        # Deletes all the records from the given collection and resets the
+        # identity counter.
+        #
+        # @param collection [Symbol] the target collection (it must be mapped).
+        #
+        # @api private
+        # @since 0.1.0
+        def clear(collection)
+          synchronize do
+            command(collection).clear
+          end
+        end
+
+        # Fabricates a command for the given query.
+        #
+        # @param collection [Symbol] the collection name (it must be mapped)
+        #
+        # @return [Hanami::Model::Adapters::Memory::Command]
+        #
+        # @see Hanami::Model::Adapters::Memory::Command
+        #
+        # @api private
+        # @since 0.1.0
+        def command(collection)
+          Memory::Command.new(_collection(collection), _mapped_collection(collection))
+        end
+
+        # Fabricates a query
+        #
+        # @param collection [Symbol] the target collection (it must be mapped).
+        # @param blk [Proc] a block of code to be executed in the context of
+        #   the query.
+        #
+        # @return [Hanami::Model::Adapters::Memory::Query]
+        #
+        # @see Hanami::Model::Adapters::Memory::Query
+        #
+        # @api private
+        # @since 0.1.0
+        def query(collection, context = nil, &blk)
+          synchronize do
+            Memory::Query.new(_collection(collection), _mapped_collection(collection), &blk)
+          end
+        end
+
+        # WARNING: this is a no-op. For "real" transactions please use
+        # `SqlAdapter` or another adapter that supports them
+        #
+        # @param options [Hash] options for transaction
+        #
+        # @see Hanami::Model::Adapters::SqlAdapter#transaction
+        # @see Hanami::Model::Adapters::Abstract#transaction
+        #
+        # @since 0.2.3
+        def transaction(options = {})
+          yield
+        end
+
+        # @api private
+        # @since 0.5.0
+        #
+        # @see Hanami::Model::Adapters::Abstract#disconnect
+        def disconnect
+          @collections = DisconnectedResource.new
+          @mutex       = DisconnectedResource.new
+        end
+
+        private
+
+        # Returns a collection from the given name.
+        #
+        # @param name [Symbol] a name of the collection (it must be mapped).
+        #
+        # @return [Hanami::Model::Adapters::Memory::Collection]
+        #
+        # @see Hanami::Model::Adapters::Memory::Collection
+        #
+        # @api private
+        # @since 0.1.0
+        def _collection(name)
+          @collections[name] ||= Memory::Collection.new(name, _identity(name))
+        end
+
+        # Executes the given block within a critical section.
+        #
+        # @api private
+        # @since 0.2.0
+        def synchronize
+          @mutex.synchronize { yield }
+        end
+      end
+    end
+  end
+end

data/lib/hanami/model/adapters/null_adapter.rb

@@ -0,0 +1,24 @@
+require 'hanami/model/error'
+
+module Hanami
+  module Model
+    module Adapters
+      # @since 0.2.0
+      class NoAdapterError < Hanami::Model::Error
+        def initialize(method_name)
+          super("Cannot invoke `#{ method_name }' on repository. "\
+                "Please check if `adapter' and `mapping' are set, "\
+                "and that you call `.load!' on the configuration.")
+        end
+      end
+
+      # @since 0.2.0
+      # @api private
+      class NullAdapter
+        def method_missing(m, *args)
+          raise NoAdapterError.new(m)
+        end
+      end
+    end
+  end
+end

data/lib/hanami/model/adapters/sql/collection.rb

@@ -0,0 +1,287 @@
+require 'delegate'
+require 'hanami/utils/kernel' unless RUBY_VERSION >= '2.1'
+
+module Hanami
+  module Model
+    module Adapters
+      module Sql
+        # Maps a SQL database table and perfoms manipulations on it.
+        #
+        # @api private
+        # @since 0.1.0
+        #
+        # @see http://sequel.jeremyevans.net/rdoc/files/doc/dataset_basics_rdoc.html
+        # @see http://sequel.jeremyevans.net/rdoc/files/doc/dataset_filtering_rdoc.html
+        class Collection < SimpleDelegator
+          # Initialize a collection
+          #
+          # @param dataset [Sequel::Dataset] the dataset that maps a table or a
+          #   subset of it.
+          # @param mapped_collection [Hanami::Model::Mapping::Collection] a
+          #   mapped collection
+          #
+          # @return [Hanami::Model::Adapters::Sql::Collection]
+          #
+          # @api private
+          # @since 0.1.0
+          def initialize(dataset, mapped_collection)
+            super(dataset)
+            @mapped_collection = mapped_collection
+          end
+
+          # Filters the current scope with an `exclude` directive.
+          #
+          # @param args [Array] the array of arguments
+          #
+          # @see Hanami::Model::Adapters::Sql::Query#exclude
+          #
+          # @return [Hanami::Model::Adapters::Sql::Collection] the filtered
+          #   collection
+          #
+          # @api private
+          # @since 0.1.0
+          def exclude(*args)
+            Collection.new(super, @mapped_collection)
+          end
+
+          # Creates a record for the given entity and assigns an id.
+          #
+          # @param entity [Object] the entity to persist
+          #
+          # @see Hanami::Model::Adapters::Sql::Command#create
+          #
+          # @return the primary key of the created record
+          #
+          # @api private
+          # @since 0.1.0
+          def insert(entity)
+            serialized_entity            = _serialize(entity)
+            serialized_entity[identity] = super(serialized_entity)
+
+            _deserialize(serialized_entity)
+          end
+
+          # Filters the current scope with a `limit` directive.
+          #
+          # @param args [Array] the array of arguments
+          #
+          # @see Hanami::Model::Adapters::Sql::Query#limit
+          #
+          # @return [Hanami::Model::Adapters::Sql::Collection] the filtered
+          #   collection
+          #
+          # @api private
+          # @since 0.1.0
+          def limit(*args)
+            Collection.new(super, @mapped_collection)
+          end
+
+          # Filters the current scope with an `offset` directive.
+          #
+          # @param args [Array] the array of arguments
+          #
+          # @see Hanami::Model::Adapters::Sql::Query#offset
+          #
+          # @return [Hanami::Model::Adapters::Sql::Collection] the filtered
+          #   collection
+          #
+          # @api private
+          # @since 0.1.0
+          def offset(*args)
+            Collection.new(super, @mapped_collection)
+          end
+
+          # Filters the current scope with an `or` directive.
+          #
+          # @param args [Array] the array of arguments
+          #
+          # @see Hanami::Model::Adapters::Sql::Query#or
+          #
+          # @return [Hanami::Model::Adapters::Sql::Collection] the filtered
+          #   collection
+          #
+          # @api private
+          # @since 0.1.0
+          def or(*args)
+            Collection.new(super, @mapped_collection)
+          end
+
+          # Filters the current scope with an `order` directive.
+          #
+          # @param args [Array] the array of arguments
+          #
+          # @see Hanami::Model::Adapters::Sql::Query#order
+          #
+          # @return [Hanami::Model::Adapters::Sql::Collection] the filtered
+          #   collection
+          #
+          # @api private
+          # @since 0.1.0
+          def order(*args)
+            Collection.new(super, @mapped_collection)
+          end
+
+          # Filters the current scope with an `order` directive.
+          #
+          # @param args [Array] the array of arguments
+          #
+          # @see Hanami::Model::Adapters::Sql::Query#order
+          #
+          # @return [Hanami::Model::Adapters::Sql::Collection] the filtered
+          #   collection
+          #
+          # @api private
+          # @since 0.1.0
+          def order_more(*args)
+            Collection.new(super, @mapped_collection)
+          end
+
+          # Filters the current scope with a `select` directive.
+          #
+          # @param args [Array] the array of arguments
+          #
+          # @see Hanami::Model::Adapters::Sql::Query#select
+          #
+          # @return [Hanami::Model::Adapters::Sql::Collection] the filtered
+          #   collection
+          #
+          # @api private
+          # @since 0.1.0
+          if RUBY_VERSION >= '2.1'
+            def select(*args)
+              Collection.new(super, @mapped_collection)
+            end
+          else
+            def select(*args)
+              Collection.new(__getobj__.select(*Hanami::Utils::Kernel.Array(args)), @mapped_collection)
+            end
+          end
+
+
+          # Filters the current scope with a `group` directive.
+          #
+          # @param args [Array] the array of arguments
+          #
+          # @see Hanami::Model::Adapters::Sql::Query#group
+          #
+          # @return [Hanami::Model::Adapters::Sql::Collection] the filtered
+          #   collection
+          #
+          # @api private
+          # @since 0.5.0
+          def group(*args)
+            Collection.new(super, @mapped_collection)
+          end
+
+          # Filters the current scope with a `where` directive.
+          #
+          # @param args [Array] the array of arguments
+          #
+          # @see Hanami::Model::Adapters::Sql::Query#where
+          #
+          # @return [Hanami::Model::Adapters::Sql::Collection] the filtered
+          #   collection
+          #
+          # @api private
+          # @since 0.1.0
+          def where(*args)
+            Collection.new(super, @mapped_collection)
+          end
+
+          # Updates the record corresponding to the given entity.
+          #
+          # @param entity [Object] the entity to persist
+          #
+          # @see Hanami::Model::Adapters::Sql::Command#update
+          #
+          # @api private
+          # @since 0.1.0
+          def update(entity)
+            serialized_entity = _serialize(entity)
+            super(serialized_entity)
+
+            _deserialize(serialized_entity)
+          end
+
+          # Resolves self by fetching the records from the database and
+          # translating them into entities.
+          #
+          # @return [Array] the result of the query
+          #
+          # @api private
+          # @since 0.1.0
+          def to_a
+            @mapped_collection.deserialize(self)
+          end
+
+          # Select all attributes for current scope
+          #
+          # @return [Hanami::Model::Adapters::Sql::Collection] the filtered
+          #   collection
+          #
+          # @api private
+          # @since 0.5.0
+          #
+          # @see http://www.rubydoc.info/github/jeremyevans/sequel/Sequel%2FDataset%3Aselect_all
+          def select_all
+            Collection.new(super(table_name), @mapped_collection)
+          end
+
+          # Use join table for current scope
+          #
+          # @return [Hanami::Model::Adapters::Sql::Collection] the filtered
+          #   collection
+          #
+          # @api private
+          # @since 0.5.0
+          #
+          # @see http://www.rubydoc.info/github/jeremyevans/sequel/Sequel%2FDataset%3Ajoin_table
+          def join_table(*args)
+            Collection.new(super, @mapped_collection)
+          end
+
+          # Return table name mapped collection
+          #
+          # @return [String] table name
+          #
+          # @api private
+          # @since 0.5.0
+          def table_name
+            @mapped_collection.name
+          end
+
+          # Name of the identity column in database
+          #
+          # @return [Symbol] the identity name
+          #
+          # @api private
+          # @since 0.5.0
+          def identity
+            @mapped_collection.identity
+          end
+
+          private
+          # Serialize the given entity before to persist in the database.
+          #
+          # @return [Hash] the serialized entity
+          #
+          # @api private
+          # @since 0.1.0
+          def _serialize(entity)
+            @mapped_collection.serialize(entity)
+          end
+
+          # Deserialize the given entity after it was persisted in the database.
+          #
+          # @return [Hanami::Entity] the deserialized entity
+          #
+          # @api private
+          # @since 0.2.2
+          def _deserialize(entity)
+            @mapped_collection.deserialize([entity]).first
+          end
+        end
+      end
+    end
+  end
+end