mongoid_rails4 4.0.0

data/lib/mongoid/sessions/factory.rb

@@ -0,0 +1,129 @@
+# encoding: utf-8
+require "mongoid/sessions/mongo_uri"
+
+module Mongoid
+  module Sessions
+    module Factory
+      extend self
+
+      # Create a new session given the named configuration. If no name is
+      # provided, return a new session with the default configuration. If a
+      # name is provided for which no configuration exists, an error will be
+      # raised.
+      #
+      # @example Create the session.
+      #   Factory.create(:secondary)
+      #
+      # @param [ String, Symbol ] name The named session configuration.
+      #
+      # @raise [ Errors::NoSessionConfig ] If no config could be found.
+      #
+      # @return [ Moped::Session ] The new session.
+      #
+      # @since 3.0.0
+      def create(name = nil)
+        return default unless name
+        config = Mongoid.sessions[name]
+        raise Errors::NoSessionConfig.new(name) unless config
+        create_session(config)
+      end
+
+      # Get the default session.
+      #
+      # @example Get the default session.
+      #   Factory.default
+      #
+      # @raise [ Errors::NoSessionConfig ] If no default configuration is
+      #   found.
+      #
+      # @return [ Moped::Session ] The default session.
+      #
+      # @since 3.0.0
+      def default
+        create_session(Mongoid.sessions[:default])
+      end
+
+      private
+
+      # Create the session for the provided config.
+      #
+      # @api private
+      #
+      # @example Create the session.
+      #   Factory.create_session(config)
+      #
+      # @param [ Hash ] configuration The session config.
+      #
+      # @return [ Moped::Session ] The session.
+      #
+      # @since 3.0.0
+      def create_session(configuration)
+        raise Errors::NoSessionsConfig.new unless configuration
+        config, options = parse(configuration)
+        configuration.merge!(config) if configuration.delete(:uri)
+        session = Moped::Session.new(config[:hosts], options)
+        session.use(config[:database])
+        if authenticated?(config)
+          session.login(config[:username], config[:password])
+        end
+        session
+      end
+
+      # Are we authenticated with this session config?
+      #
+      # @api private
+      #
+      # @example Is this session authenticated?
+      #   Factory.authenticated?(config)
+      #
+      # @param [ Hash ] config The session config.
+      #
+      # @return [ true, false ] If we are authenticated.
+      #
+      # @since 3.0.0
+      def authenticated?(config)
+        config.has_key?(:username) && config.has_key?(:password)
+      end
+
+      # Parse the configuration. If a uri is provided we need to extract the
+      # elements of it, otherwise the options are left alone.
+      #
+      # @api private
+      #
+      # @example Parse the config.
+      #   Factory.parse(config)
+      #
+      # @param [ Hash ] config The configuration.
+      #
+      # @return [ Array<Hash> ] The configuration, parsed.
+      #
+      # @since 3.0.0
+      def parse(config)
+        options = config[:options].try(:dup) || {}
+        parsed = if config.has_key?(:uri)
+          MongoUri.new(config[:uri]).to_hash
+        else
+          inject_ports(config)
+        end
+        [ parsed, options.symbolize_keys ]
+      end
+
+      # Will inject the default port of 27017 if not supplied.
+      #
+      # @example Inject default ports.
+      #   factory.inject_ports(config)
+      #
+      # @param [ Hash ] config The session configuration.
+      #
+      # @return [ Hash ] The altered configuration.
+      #
+      # @since 3.1.0
+      def inject_ports(config)
+        config["hosts"] = config["hosts"].map do |host|
+          host =~ /:/ ? host : "#{host}:27017"
+        end
+        config
+      end
+    end
+  end
+end

data/lib/mongoid/sessions/mongo_uri.rb

@@ -0,0 +1,93 @@
+# encoding: utf-8
+module Mongoid
+  module Sessions
+    class MongoUri
+
+      SCHEME = /(mongodb:\/\/)/
+      USER = /([-.\w:]+)/
+      PASS = /([^@,]+)/
+      NODES = /((([-.\w]+)(?::(\w+))?,?)+)/
+      DATABASE = /(?:\/([-\w]+))?/
+
+      URI = /#{SCHEME}(#{USER}:#{PASS}@)?#{NODES}#{DATABASE}/
+
+      attr_reader :match
+
+      # Get the database provided in the URI.
+      #
+      # @example Get the database.
+      #   uri.database
+      #
+      # @return [ String ] The database.
+      #
+      # @since 3.0.0
+      def database
+        @database ||= match[9]
+      end
+
+      # Get the hosts provided in the URI.
+      #
+      # @example Get the hosts.
+      #   uri.hosts
+      #
+      # @return [ Array<String> ] The hosts.
+      #
+      # @since 3.0.0
+      def hosts
+        @hosts ||= match[5].split(",")
+      end
+
+      # Create the new uri from the provided string.
+      #
+      # @example Create the new uri.
+      #   MongoUri.new(uri)
+      #
+      # @param [ String ] string The uri string.
+      #
+      # @since 3.0.0
+      def initialize(string)
+        @match = string.match(URI)
+      end
+
+      # Get the password provided in the URI.
+      #
+      # @example Get the password.
+      #   uri.password
+      #
+      # @return [ String ] The password.
+      #
+      # @since 3.0.0
+      def password
+        @password ||= match[4]
+      end
+
+      # Get the uri as a Mongoid friendly configuration hash.
+      #
+      # @example Get the uri as a hash.
+      #   uri.to_hash
+      #
+      # @return [ Hash ] The uri as options.
+      #
+      # @since 3.0.0
+      def to_hash
+        config = { database: database, hosts: hosts }
+        if username && password
+          config.merge!(username: username, password: password)
+        end
+        config
+      end
+
+      # Get the username provided in the URI.
+      #
+      # @example Get the username.
+      #   uri.username
+      #
+      # @return [ String ] The username.
+      #
+      # @since 3.0.0
+      def username
+        @username ||= match[3]
+      end
+    end
+  end
+end

data/lib/mongoid/sessions/options.rb

@@ -0,0 +1,141 @@
+module Mongoid
+  module Sessions
+    module Options
+      extend ActiveSupport::Concern
+
+      # Tell the next persistance operation to store in a specific collection,
+      # database or session.
+      #
+      # @example Save the current document to a different collection.
+      #   model.with(collection: "secondary").save
+      #
+      # @example Save the current document to a different database.
+      #   model.with(database: "secondary").save
+      #
+      # @example Save the current document to a different session.
+      #   model.with(session: "replica_set").save
+      #
+      # @example Save with a combination of options.
+      #   model.with(session: "sharded", database: "secondary").save
+      #
+      # @param [ Hash ] options The storage options.
+      #
+      # @option options [ String, Symbol ] :collection The collection name.
+      # @option options [ String, Symbol ] :database The database name.
+      # @option options [ String, Symbol ] :session The session name.
+      #
+      # @return [ Document ] The current document.
+      #
+      # @since 3.0.0
+      def with(options)
+        @persistence_options = options
+        self
+      end
+
+      def persistence_options
+        @persistence_options
+      end
+
+      module Threaded
+
+        # Get the persistence options for the current thread.
+        #
+        # @example Get the persistence options.
+        #   Threaded.persistence_options(Band)
+        #
+        # @param [ Class ] klass The model class.
+        #
+        # @return [ Hash ] The current persistence options.
+        #
+        # @since 4.0.0
+        def persistence_options(klass = self)
+          Thread.current["[mongoid][#{klass}]:persistence-options"]
+        end
+
+        private
+        # Set the persistence options on the current thread.
+        #
+        # @api private
+        #
+        # @example Set the persistence options.
+        #   Threaded.set_persistence_options(Band, { safe: { fsync: true }})
+        #
+        # @param [ Class ] klass The model class.
+        # @param [ Hash ] options The persistence options.
+        #
+        # @return [ Hash ] The persistence options.
+        #
+        # @since 4.0.0
+        def set_persistence_options(klass, options)
+          Thread.current["[mongoid][#{klass}]:persistence-options"] = options
+        end
+      end
+
+      module ClassMethods
+        include Threaded
+
+        # Tell the next persistance operation to store in a specific collection,
+        # database or session.
+        #
+        # @example Create a document in a different collection.
+        #   Model.with(collection: "secondary").create(name: "test")
+        #
+        # @example Create a document in a different database.
+        #   Model.with(database: "secondary").create(name: "test")
+        #
+        # @example Create a document in a different session.
+        #   Model.with(session: "secondary").create(name: "test")
+        #
+        # @example Create with a combination of options.
+        #   Model.with(session: "sharded", database: "secondary").create
+        #
+        # @param [ Hash ] options The storage options.
+        #
+        # @option options [ String, Symbol ] :collection The collection name.
+        # @option options [ String, Symbol ] :database The database name.
+        # @option options [ String, Symbol ] :session The session name.
+        #
+        # @return [ Class ] The model class.
+        #
+        # @since 3.0.0
+        def with(options)
+          Proxy.new(self, (persistence_options || {}).merge(options))
+        end
+      end
+
+      class Proxy < BasicObject
+        include Threaded
+
+        undef_method :==
+
+        def initialize(target, options)
+          @target = target
+          @options = options
+        end
+
+        def persistence_options
+          @options
+        end
+
+        def respond_to?(*args)
+          @target.respond_to?(*args)
+        end
+
+        def method_missing(name, *args, &block)
+          set_persistence_options(@target, @options)
+          @target.send(name, *args, &block)
+        ensure
+          set_persistence_options(@target, nil)
+         end
+
+        def send(symbol, *args)
+          __send__(symbol, *args)
+        end
+
+        def self.const_missing(name)
+          ::Object.const_get(name)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/sessions/validators.rb

@@ -0,0 +1,2 @@
+# encoding: utf-8
+require "mongoid/sessions/validators/storage"

data/lib/mongoid/sessions/validators/storage.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+module Mongoid
+  module Sessions
+    module Validators
+
+      # Validates the options passed to :store_in.
+      module Storage
+        extend self
+
+        VALID_OPTIONS = [ :collection, :database, :session ]
+
+        # Validate the options provided to :store_in.
+        #
+        # @example Validate the options.
+        #   Storage.validate(:collection_name)
+        #
+        # @param [ Class ] klass The model class.
+        # @param [ Hash, String, Symbol ] options The provided options.
+        #
+        # @since 3.0.0
+        def validate(klass, options)
+          if !options.is_a?(::Hash) || !valid_keys?(options)
+            raise Errors::InvalidStorageOptions.new(klass, options)
+          end
+        end
+
+        private
+
+        # Determine if all keys in the options hash are valid.
+        #
+        # @api private
+        #
+        # @example Are all keys valid?
+        #   validator.valid_keys?({ collection: "name" })
+        #
+        # @param [ Hash ] options The options hash.
+        #
+        # @return [ true, false ] If all keys are valid.
+        #
+        # @since 3.0.0
+        def valid_keys?(options)
+          options.keys.all? do |key|
+            VALID_OPTIONS.include?(key)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/shardable.rb

@@ -0,0 +1,65 @@
+# encoding: utf-8
+module Mongoid
+
+  # This module contains behaviour for adding shard key fields to updates.
+  #
+  # @since 4.0.0
+  module Shardable
+    extend ActiveSupport::Concern
+
+    included do
+      cattr_accessor :shard_key_fields
+      self.shard_key_fields = []
+    end
+
+    # Get the shard key fields.
+    #
+    # @note Refactored from using delegate for class load performance.
+    #
+    # @example Get the shard key fields.
+    #   model.shard_key_fields
+    #
+    # @return [ Array<String> ] The shard key field names.
+    #
+    # @since 1.0.0
+    def shard_key_fields
+      self.class.shard_key_fields
+    end
+
+    # Get the document selector with the defined shard keys.
+    #
+    # @example Get the selector for the shard keys.
+    #   person.shard_key_selector
+    #
+    # @return [ Hash ] The shard key selector.
+    #
+    # @since 2.0.0
+    def shard_key_selector
+      selector = {}
+      shard_key_fields.each do |field|
+        selector[field.to_s] = send(field)
+      end
+      selector
+    end
+
+    module ClassMethods
+
+      # Specifies a shard key with the field(s) specified.
+      #
+      # @example Specify the shard key.
+      #
+      #   class Person
+      #     include Mongoid::Document
+      #     field :first_name, :type => String
+      #     field :last_name, :type => String
+      #
+      #     shard_key :first_name, :last_name
+      #   end
+      #
+      # @since 2.0.0
+      def shard_key(*names)
+        self.shard_key_fields = names
+      end
+    end
+  end
+end