lotus-model 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0e790b1ae96cb5efe8df6cc1cb73d9f2a552ff07
-  data.tar.gz: 05962ff67790a0184e371b47fa3146a18fd88343
+  metadata.gz: de9019e132ab36bb7b30223c52e247df84e3cf3e
+  data.tar.gz: d56eeb3a71e31193b1509527f24ac8f0822df5f0
 SHA512:
-  metadata.gz: 72200690f749ccf4f728554bb92de8ebc5215619afcda4672f87a8850ea6eca503a8f08ab5e2358fcae8fe7550dfaf3f51cd108857ce0e3567f93b0eb02c0514
-  data.tar.gz: 25b0f721e617e62ef9a705d2fcca14112d08bf2254b9936c13e4245c191b342acd2003306574393fb4810687afa19f634ab3c4b4456288ce58d9d81fa3f11199
+  metadata.gz: 8449498885c9eda612f978aed61dfbe362e213b8c392ce86cb37d9586f5d0865b010f9900246b3621d63627e0900f43a52a0dfe954e9b507306987ab1ef9755b
+  data.tar.gz: 478a4d4bf0323970ee7adf7733123418745aa135db6dc79142e9f203962793b039e2e017fca8a3d9f1bee01dd3f7511068220c465a44e29399a57c950eea9e61

data/CHANGELOG.md

@@ -1,8 +1,22 @@
 # Lotus::Model
 A persistence layer for Lotus
 
-## v0.4.1 - 2015-07-10
+## v0.5.0 - 2015-09-30
 ### Added
+- [Brenno Costa] Official support for JRuby 9k+
+- [Luca Guidi] Command/Query separation via `Repository.execute` and `Repository.fetch`
+- [Luca Guidi] Custom attribute coercers for data mapper
+- [Alfonso Uceda] Added `#join` and `#left_join` and `#group` to SQL adapter
+
+### Changed
+- [Luca Guidi] `Repository.execute` no longer returns a result from the database.
+
+### Fixed
+- [Manuel Corrales] Use `dropdb` to drop PostgreSQL database.
+- [Luca Guidi & Bohdan V.] Ignore dotfiles while running migrations.
+
+## v0.4.1 - 2015-07-10
+### Fixed
 - [Nick Coyne] Fixed database creation for PostgreSQL (now it uses `createdb`).
 
 ## v0.4.0 - 2015-06-23

data/README.md

@@ -35,7 +35,7 @@ Like all the other Lotus components, it can be used as a standalone framework or
 
 ## Rubies
 
-__Lotus::Model__ supports Ruby (MRI) 2+
+__Lotus::Model__ supports Ruby (MRI) 2+ and JRuby 9000+
 
 ## Installation
 
@@ -463,6 +463,8 @@ Here is common interface for existing class:
   * `.range` - Returns a range of values between the MAX and the MIN for the given column
   * `.exist?` - Checks if at least one record exists for the current conditions
   * `.count` - Returns a count of the records for the current conditions
+  * `.join` - Adds an inner join with a table (only SQL)
+  * `.left_join` - Adds a left join with a table (only SQL)
 
 If you need more information regarding those methods, you can use comments from [memory](https://github.com/lotus/model/blob/master/lib/lotus/model/adapters/memory/query.rb#L29) or [sql](https://github.com/lotus/model/blob/master/lib/lotus/model/adapters/sql/query.rb#L28) adapters interface.
 

data/lib/lotus/model.rb

@@ -28,8 +28,16 @@ module Lotus
     class InvalidMappingError < ::StandardError
     end
 
-    # Error for invalid query
-    # It's raised when a query is malformed
+    # Error for invalid raw command syntax
+    #
+    # @since 0.5.0
+    class InvalidCommandError < ::StandardError
+      def initialize(message = "Invalid command")
+        super
+      end
+    end
+
+    # Error for invalid raw query syntax
     #
     # @since 0.3.1
     class InvalidQueryError < ::StandardError

data/lib/lotus/model/adapters/abstract.rb

@@ -1,3 +1,5 @@
+require 'lotus/utils/basic_object'
+
 module Lotus
   module Model
     module Adapters
@@ -23,6 +25,45 @@ module Lotus
       class NotSupportedError < ::StandardError
       end
 
+      # It's raised when an operation is requested to an adapter after it was
+      # disconnected.
+      #
+      # @since 0.5.0
+      class DisconnectedAdapterError < ::StandardError
+        def initialize
+          super "You have tried to perform an operation on a disconnected adapter"
+        end
+      end
+
+      # Represents a disconnected resource.
+      #
+      # When we use <tt>#disconnect</tt> for <tt>MemoryAdapter</tt> and
+      # </tt>FileSystemAdapter</tt>, we want to free underlying resources such
+      # as a mutex or a file descriptor.
+      #
+      # These adapters use to use anonymous descriptors that are destroyed by
+      # Ruby VM after each operation. Sometimes we need to clean the state and
+      # start fresh (eg. during a test suite or a deploy).
+      #
+      # Instead of assign <tt>nil</tt> to these instance variables, we assign this
+      # special type: <tt>DisconnectedResource</tt>.
+      #
+      # In case an operation is still performed after the adapter was disconnected,
+      # instead of see a generic <tt>NoMethodError</tt> for <tt>nil</tt>, a developer
+      # will face a specific message relative to the state of the adapter.
+      #
+      # @api private
+      # @since 0.5.0
+      #
+      # @see Lotus::Model::Adapters::Abstract#disconnect
+      # @see Lotus::Model::Adapters::MemoryAdapter#disconnect
+      # @see Lotus::Model::Adapters::FileSystemAdapter#disconnect
+      class DisconnectedResource < Utils::BasicObject
+        def method_missing(method_name, *)
+          ::Kernel.raise DisconnectedAdapterError.new
+        end
+      end
+
       # Abstract adapter.
       #
       # An adapter is a concrete implementation that allows a repository to
@@ -202,15 +243,35 @@ module Lotus
           raise NotSupportedError
         end
 
-        # Executes a raw statement directly on the connection
+        # Executes a raw command
         #
         # @param raw [String] the raw statement to execute on the connection
-        # @return [Object]
+        #
+        # @return [NilClass]
         #
         # @since 0.3.1
         def execute(raw)
           raise NotImplementedError
         end
+
+        # Fetches raw records from
+        #
+        # @param raw [String] the raw query
+        # @param blk [Proc] an optional block that is yielded for each record
+        #
+        # @return [Enumerable<Hash>, Array<Hash>]
+        #
+        # @since 0.5.0
+        def fetch(raw, &blk)
+          raise NotImplementedError
+        end
+
+        # Disconnects the connection by freeing low level resources
+        #
+        # @since 0.5.0
+        def disconnect
+          raise NotImplementedError
+        end
       end
     end
   end

data/lib/lotus/model/adapters/file_system_adapter.rb

@@ -225,6 +225,17 @@ module Lotus
           end
         end
 
+        # @api private
+        # @since 0.5.0
+        #
+        # @see Lotus::Model::Adapters::Abstract#disconnect
+        def disconnect
+          super
+
+          @_mutex = DisconnectedResource.new
+          @root   = DisconnectedResource.new
+        end
+
         private
         # @api private
         # @since 0.2.0

data/lib/lotus/model/adapters/memory/query.rb

@@ -541,6 +541,19 @@ module Lotus
             raise NotImplementedError
           end
 
+          # This method is defined in order to make the interface of
+          # `Memory::Query` identical to `Sql::Query`, but this feature is NOT
+          # implemented
+          #
+          # @raise [NotImplementedError]
+          #
+          # @since 0.5.0
+          #
+          # @see Lotus::Model::Adapters::Sql::Query#group!
+          def group
+            raise NotImplementedError
+          end
+
           protected
           def method_missing(m, *args, &blk)
             if @context.respond_to?(m)

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

@@ -140,6 +140,15 @@ module Lotus
           yield
         end
 
+        # @api private
+        # @since 0.5.0
+        #
+        # @see Lotus::Model::Adapters::Abstract#disconnect
+        def disconnect
+          @collections = DisconnectedResource.new
+          @mutex       = DisconnectedResource.new
+        end
+
         private
 
         # Returns a collection from the given name.

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

@@ -56,7 +56,7 @@ module Lotus
           # @since 0.1.0
           def insert(entity)
             serialized_entity            = _serialize(entity)
-            serialized_entity[_identity] = super(serialized_entity)
+            serialized_entity[identity] = super(serialized_entity)
 
             _deserialize(serialized_entity)
           end
@@ -157,6 +157,22 @@ module Lotus
             end
           end
 
+
+          # Filters the current scope with a `group` directive.
+          #
+          # @param args [Array] the array of arguments
+          #
+          # @see Lotus::Model::Adapters::Sql::Query#group
+          #
+          # @return [Lotus::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
@@ -198,6 +214,52 @@ module Lotus
             @mapped_collection.deserialize(self)
           end
 
+          # Select all attributes for current scope
+          #
+          # @return [Lotus::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 [Lotus::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.
           #
@@ -218,16 +280,6 @@ module Lotus
           def _deserialize(entity)
             @mapped_collection.deserialize([entity]).first
           end
-
-          # Name of the identity column in database
-          #
-          # @return [Symbol] the identity name
-          #
-          # @api private
-          # @since 0.2.2
-          def _identity
-            @mapped_collection.identity
-          end
         end
       end
     end

data/lib/lotus/model/adapters/sql/query.rb

@@ -75,7 +75,7 @@ module Lotus
           #
           # @since 0.1.0
           def all
-            Lotus::Utils::Kernel.Array(run)
+            run.to_a
           rescue Sequel::DatabaseError => e
             raise Lotus::Model::InvalidQueryError.new(e.message)
           end
@@ -401,6 +401,30 @@ module Lotus
           #   query.desc(:name).desc(:year)
           alias_method :desc, :reverse_order
 
+          # Group by the specified columns.
+          #
+          # @param columns [Array<Symbol>]
+          #
+          # @return self
+          #
+          # @since 0.5.0
+          #
+          # @example Single column
+          #
+          #   query.group(:name)
+          #
+          #   # => SELECT * FROM `people` GROUP BY `name`
+          #
+          # @example Multiple columns
+          #
+          #   query.group(:name, :year)
+          #
+          #   # => SELECT * FROM `people` GROUP BY `name`, `year`
+          def group(*columns)
+            conditions.push([:group, *columns])
+            self
+          end
+
           # Returns the sum of the values for the given column.
           #
           # @param column [Symbol] the column name
@@ -592,6 +616,50 @@ module Lotus
 
           alias_method :run, :scoped
 
+          # Specify an `INNER JOIN` clause.
+          #
+          # @param collection [String]
+          # @param options [Hash]
+          # @option key [Symbol] the key
+          # @option foreign_key [Symbol] the foreign key
+          #
+          # @return self
+          #
+          # @since 0.5.0
+          #
+          # @example
+          #
+          #   query.join(:users)
+          #
+          #   # => SELECT * FROM `posts` INNER JOIN `users` ON `posts`.`user_id` = `users`.`id`
+          def join(collection, options = {})
+            _join(collection, options.merge(join: :inner))
+          end
+
+          alias_method :inner_join, :join
+
+          # Specify a `LEFT JOIN` clause.
+          #
+          # @param collection [String]
+          # @param options [Hash]
+          # @option key [Symbol] the key
+          # @option foreign_key [Symbol] the foreign key
+          #
+          # @return self
+          #
+          # @since 0.5.0
+          #
+          # @example
+          #
+          #   query.left_join(:users)
+          #
+          #   # => SELECT * FROM `posts` LEFT JOIN `users` ON `posts`.`user_id` = `users`.`id`
+          def left_join(collection, options = {})
+            _join(collection, options.merge(join: :left))
+          end
+
+          alias_method :left_outer_join, :left_join
+
           protected
           # Handles missing methods for query combinations
           #
@@ -609,6 +677,30 @@ module Lotus
 
           private
 
+          # Specify a JOIN clause. (inner or left)
+          #
+          # @param collection [String]
+          # @param options [Hash]
+          # @option key [Symbol] the key
+          # @option foreign_key [Symbol] the foreign key
+          # @option join [Symbol] the join type
+          #
+          # @return self
+          #
+          # @api private
+          # @since 0.5.0
+          def _join(collection, options = {})
+            collection_name = Utils::String.new(collection).singularize
+
+            foreign_key = options.fetch(:foreign_key) { "#{ @collection.table_name }__#{ collection_name }_id".to_sym }
+            key         = options.fetch(:key) { @collection.identity.to_sym }
+
+            conditions.push([:select_all])
+            conditions.push([:join_table, options.fetch(:join, :inner), collection, key => foreign_key])
+
+            self
+          end
+
           # Returns a new query that is the result of the merge of the current
           # conditions with the ones of the given query.
           #

data/lib/lotus/model/adapters/sql_adapter.rb

@@ -227,23 +227,53 @@ module Lotus
           Sql::Console.new(@uri).connection_string
         end
 
-        # Executes raw sql directly on the connection
+        # Executes a raw SQL command
         #
-        # @param raw [String] the raw sql statement to execute on the connection
+        # @param raw [String] the raw SQL statement to execute on the connection
         #
-        # @return [Object]
+        # @raise [Lotus::Model::InvalidCommandError] if the raw SQL statement is invalid
         #
-        # @raise [Lotus::Model::InvalidQueryError] if raw statement is invalid
+        # @return [NilClass]
         #
         # @since 0.3.1
         def execute(raw)
           begin
             @connection.execute(raw)
+            nil
           rescue Sequel::DatabaseError => e
-            raise Lotus::Model::InvalidQueryError.new(e.message)
+            raise Lotus::Model::InvalidCommandError.new(e.message)
           end
         end
 
+        # Fetches raw result sets for the given SQL query
+        #
+        # @param raw [String] the raw SQL query
+        # @param blk [Proc] optional block that is yielded for each record
+        #
+        # @return [Array]
+        #
+        # @raise [Lotus::Model::InvalidQueryError] if the raw SQL statement is invalid
+        #
+        # @since 0.5.0
+        def fetch(raw, &blk)
+          if block_given?
+            @connection.fetch(raw, &blk)
+          else
+            @connection.fetch(raw).to_a
+          end
+        rescue Sequel::DatabaseError => e
+          raise Lotus::Model::InvalidQueryError.new(e.message)
+        end
+
+        # @api private
+        # @since 0.5.0
+        #
+        # @see Lotus::Model::Adapters::Abstract#disconnect
+        def disconnect
+          @connection.disconnect
+          @connection = DisconnectedResource.new
+        end
+
         private
 
         # Returns a collection from the given name.