mongoid-ultra 9.0.0.0.alpha1

data/lib/mongoid/serializable.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+module Mongoid
+
+  # This module provides the extra behavior for including associations in JSON
+  # and XML serialization.
+  module Serializable
+    extend ActiveSupport::Concern
+
+    # We need to redefine where the JSON configuration is getting defined,
+    # similar to +ActiveRecord+.
+    included do
+
+      class << self
+        # Note that this intentionally only delegates :include_root_in_json
+        # and not :include_root_in_json? - delegating the latter produces
+        # wrong behavior.
+        # Also note that this intentionally uses the ActiveSupport delegation
+        # functionality and not the Ruby standard library one.
+        # See https://jira.mongodb.org/browse/MONGOID-4849.
+        delegate :include_root_in_json, to: ::Mongoid
+      end
+    end
+
+    # Gets the document as a serializable hash, used by ActiveModel's JSON
+    # serializer.
+    #
+    # @example Get the serializable hash.
+    #   document.serializable_hash
+    #
+    # @example Get the serializable hash with options.
+    #   document.serializable_hash(:include => :addresses)
+    #
+    # @param [ Hash ] options The options to pass.
+    #
+    # @option options [ Symbol | String | Array<Symbol | String> ] :except
+    #   Do not include these field(s).
+    # @option options [ Symbol | String | Array<Symbol | String> ] :include
+    #   Which association(s) to include.
+    # @option options [ Symbol | String | Array<Symbol | String> ] :only
+    #   Limit the field(s) to only these.
+    # @option options [ Symbol | String | Array<Symbol | String> ] :methods
+    #   What methods to include.
+    #
+    # @return [ Hash ] The document, ready to be serialized.
+    def serializable_hash(options = nil)
+      options ||= {}
+      attrs = {}
+
+      names = field_names(options)
+
+      method_names = Array.wrap(options[:methods]).map do |name|
+        name.to_s if respond_to?(name)
+      end.compact
+
+      (names + method_names).each do |name|
+        without_autobuild do
+          serialize_attribute(attrs, name, names, options)
+        end
+      end
+      serialize_relations(attrs, options) if options[:include]
+      attrs
+    end
+
+    private
+
+    # Get the names of all fields that will be serialized.
+    #
+    # @api private
+    #
+    # @example Get all the field names.
+    #   document.send(:field_names)
+    #
+    # @return [ Array<String> ] The names of the fields.
+    def field_names(options)
+      names = (as_attributes.keys + attribute_names).uniq.sort
+
+      only = Array.wrap(options[:only]).map(&:to_s)
+      except = Array.wrap(options[:except]).map(&:to_s)
+      except |= [self.class.discriminator_key] unless Mongoid.include_type_for_serialization
+
+      if !only.empty?
+        names &= only
+      elsif !except.empty?
+        names -= except
+      end
+      names
+    end
+
+    # Serialize a single attribute. Handles associations, fields, and dynamic
+    # attributes.
+    #
+    # @api private
+    #
+    # @example Serialize the attribute.
+    #   document.serialize_attribute({}, "id" , [ "id" ])
+    #
+    # @param [ Hash ] attrs The attributes.
+    # @param [ String ] name The attribute name.
+    # @param [ Array<String> ] names The names of all attributes.
+    # @param [ Hash ] options The options.
+    #
+    # @return [ Object ] The attribute.
+    def serialize_attribute(attrs, name, names, options)
+      if relations.key?(name)
+        value = send(name)
+        attrs[name] = value ? value.serializable_hash(options) : nil
+      elsif names.include?(name) && !fields.key?(name)
+        attrs[name] = read_raw_attribute(name)
+      elsif !attribute_missing?(name)
+        attrs[name] = send(name)
+      end
+    end
+
+    # For each of the provided include options, get the association needed and
+    # provide it in the hash.
+    #
+    # @example Serialize the included associations.
+    #   document.serialize_relations({}, :include => :addresses)
+    #
+    # @param [ Hash ] attributes The attributes to serialize.
+    # @param [ Hash ] options The serialization options.
+    #
+    # @option options [ Symbol ] :include What associations to include
+    # @option options [ Symbol ] :only Limit the fields to only these.
+    # @option options [ Symbol ] :except Dont include these fields.
+    def serialize_relations(attributes = {}, options = {})
+      inclusions = options[:include]
+      relation_names(inclusions).each do |name|
+        association = relations[name.to_s]
+        if association && relation = send(association.name)
+          attributes[association.name.to_s] =
+            relation.serializable_hash(relation_options(inclusions, options, name))
+        end
+      end
+    end
+
+    # Since the inclusions can be a hash, symbol, or array of symbols, this is
+    # provided as a convenience to parse out the names.
+    #
+    # @example Get the association names.
+    #   document.relation_names(:include => [ :addresses ])
+    #
+    # @param [ Hash | Symbol | Array<Symbol> ] inclusions The inclusions.
+    #
+    # @return [ Array<Symbol> ] The names of the included associations.
+    def relation_names(inclusions)
+      inclusions.is_a?(Hash) ? inclusions.keys : Array.wrap(inclusions)
+    end
+
+    # Since the inclusions can be a hash, symbol, or array of symbols, this is
+    # provided as a convenience to parse out the options.
+    #
+    # @example Get the association options.
+    #   document.relation_names(:include => [ :addresses ])
+    #
+    # @param [ Hash | Symbol | Array<Symbol> ] inclusions The inclusions.
+    # @param [ Hash ] options The options.
+    # @param [ Symbol ] name The name of the association.
+    #
+    # @return [ Hash ] The options for the association.
+    def relation_options(inclusions, options, name)
+      if inclusions.is_a?(Hash)
+        inclusions[name]
+      else
+        { except: options[:except], only: options[:only] }
+      end
+    end
+  end
+end

data/lib/mongoid/shardable.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+module Mongoid
+
+  # This module contains behavior for adding shard key fields to updates.
+  module Shardable
+    extend ActiveSupport::Concern
+
+    included do
+      # Returns the list of shard key fields, if shard key was declared on
+      # this model. If no shard key was declared, returns an empty array.
+      #
+      # @return [ Array<Symbol> ] List of shard key fields.
+      # @api public
+      cattr_accessor :shard_key_fields
+      self.shard_key_fields = []
+
+      # Returns the shard configuration, which is a hash with the following
+      # (symbol) keys:
+      #
+      # - keys: A hash mapping (symbol) field names to values, defining the
+      #   shard key. Values can be either the integer 1 for ranged sharding
+      #   or the string "hashed" for hashed sharding.
+      # - options: A hash containing options for shardCollections command.
+      #
+      # If shard key was not declared via the +shard_key+ macro, +shard_config+
+      # attribute is nil.
+      #
+      # @example Get the shard configuration.
+      #   Model.shard_config
+      #   # => {key: {foo: 1, bar: 1}, options: {unique: true}}
+      #
+      # @return [ Hash | nil ] Shard configuration.
+      # @api public
+      cattr_accessor :shard_config
+    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.
+    def shard_key_fields
+      self.class.shard_key_fields
+    end
+
+    # Returns the selector that would match the defined shard keys. If
+    # `prefer_persisted` is false (the default), it uses the current values
+    # of the specified shard keys, otherwise, it will try to use whatever value
+    # was most recently persisted.
+    #
+    # @param [ true | false ] prefer_persisted Whether to use the current
+    #   value of the shard key fields, or to use their most recently persisted
+    #   values.
+    #
+    # @return [ Hash ] The shard key selector.
+    #
+    # @api private
+    def shard_key_selector(prefer_persisted: false)
+      shard_key_fields.each_with_object({}) do |field, selector|
+        selector[field.to_s] = shard_key_field_value(field.to_s, prefer_persisted: prefer_persisted)
+      end
+    end
+
+    # Returns the selector that would match the existing version of this
+    # document in the database.
+    #
+    # If the document is not persisted, this method uses the current values
+    # of the shard key fields. If the document is persisted, this method
+    # uses the values retrieved from the database.
+    #
+    # @return [ Hash ] The shard key selector.
+    #
+    # @api private
+    def shard_key_selector_in_db
+      shard_key_selector(prefer_persisted: true)
+    end
+
+    # Returns the value for the named shard key. If the field identifies
+    # an embedded document, the key will be parsed and recursively evaluated.
+    # If `prefer_persisted` is true, the value last persisted to the database
+    # will be returned, regardless of what the current value of the attribute
+    # may be.
+    #
+    # @param [String] field The name of the field to evaluate
+    # @param [ true|false ] prefer_persisted Whether or not to prefer the
+    #   persisted value over the current value.
+    #
+    # @return [ Object ] The value of the named field.
+    #
+    # @api private
+    def shard_key_field_value(field, prefer_persisted:)
+      if field.include?(".")
+        relation, remaining = field.split(".", 2)
+        send(relation)&.shard_key_field_value(remaining, prefer_persisted: prefer_persisted)
+      elsif prefer_persisted && !new_record?
+        attribute_was(field)
+      else
+        send(field)
+      end
+    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: 1, last_name: 1
+      #   end
+      def shard_key(*args)
+        unless args.first.is_a?(Hash)
+          # Shorthand syntax
+          if args.last.is_a?(Hash)
+            raise ArgumentError, 'Shorthand shard_key syntax does not permit options'
+          end
+
+          spec = Hash[args.map do |name|
+            [name, 1]
+          end]
+
+          return shard_key(spec)
+        end
+
+        if args.length > 2
+          raise ArgumentError, 'Full shard_key syntax requires 1 or 2 arguments'
+        end
+
+        spec, options = args
+
+        spec = Hash[spec.map do |name, value|
+          if value.is_a?(Symbol)
+            value = value.to_s
+          end
+          [database_field_name(name).to_sym, value]
+        end]
+
+        self.shard_key_fields = spec.keys
+        self.shard_config = {
+          key: spec.freeze,
+          options: (options || {}).dup.freeze,
+        }.freeze
+      end
+    end
+  end
+end

data/lib/mongoid/stateful.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+module Mongoid
+
+  # This module contains the behavior for getting the various states a
+  # document can transition through.
+  module Stateful
+
+    attr_writer :destroyed, :flagged_for_destroy, :previously_new_record
+
+    def new_record=(new_value)
+      @new_record ||= false
+      if @new_record && !new_value
+        @previously_new_record = true
+      end
+      @new_record = new_value
+    end
+
+    # Returns true if the +Document+ has not been persisted to the database,
+    # false if it has. This is determined by the variable @new_record
+    # and NOT if the object has an id.
+    #
+    # @example Is the document new?
+    #   person.new_record?
+    #
+    # @return [ true | false ] True if new, false if not.
+    def new_record?
+      @new_record ||= false
+    end
+
+    # Returns true if this document was just created -- that is, prior to the last
+    # save, the object didn't exist in the database and new_record? would have
+    # returned true.
+    #
+    # @return [ true | false ] True if was just created, false if not.
+    def previously_new_record?
+      @previously_new_record ||= false
+    end
+
+    # Checks if the document has been saved to the database. Returns false
+    # if the document has been destroyed.
+    #
+    # @example Is the document persisted?
+    #   person.persisted?
+    #
+    # @return [ true | false ] True if persisted, false if not.
+    def persisted?
+      !new_record? && !destroyed?
+    end
+
+    # Checks if the document was previously saved to the database
+    # but now it has been deleted.
+    #
+    # @return [ true | false ] True if was persisted but now destroyed,
+    #   otherwise false.
+    def previously_persisted?
+      !new_record? && destroyed?
+    end
+
+    # Returns whether or not the document has been flagged for deletion, but
+    # not destroyed yet. Used for atomic pulls of child documents.
+    #
+    # @example Is the document flagged?
+    #   document.flagged_for_destroy?
+    #
+    # @return [ true | false ] If the document is flagged.
+    def flagged_for_destroy?
+      @flagged_for_destroy ||= false
+    end
+    alias :marked_for_destruction? :flagged_for_destroy?
+    alias :_destroy :flagged_for_destroy?
+
+    # Returns true if the +Document+ has been succesfully destroyed, and false
+    # if it hasn't. This is determined by the variable @destroyed and NOT
+    # by checking the database.
+    #
+    # @example Is the document destroyed?
+    #   person.destroyed?
+    #
+    # @return [ true | false ] True if destroyed, false if not.
+    def destroyed?
+      @destroyed ||= false
+    end
+
+    # Determine if the document can be pushed.
+    #
+    # @example Is this pushable?
+    #   person.pushable?
+    #
+    # @return [ true | false ] Is the document new and embedded?
+    def pushable?
+      new_record? &&
+        embedded_many? &&
+        _parent.persisted? &&
+        !_parent.delayed_atomic_sets[atomic_path]
+    end
+
+    # Flags the document as readonly. Will cause a ReadonlyDocument error to be
+    # raised if the document is attempted to be saved, updated or destroyed.
+    #
+    # @example Flag the document as readonly.
+    #   document.readonly!
+    #
+    # @return [ true | false ] true if the document was successfully marked
+    #   readonly, false otherwise.
+    def readonly!
+      if Mongoid.legacy_readonly
+        Mongoid::Warnings.warn_legacy_readonly
+        false
+      else
+        @readonly = true
+      end
+    end
+
+    # Is the document readonly?
+    #
+    # @example Is the document readonly?
+    #   document.readonly?
+    #
+    # @return [ true | false ] If the document is readonly.
+    def readonly?
+      if Mongoid.legacy_readonly
+        __selected_fields != nil
+      else
+        @readonly ||= false
+      end
+    end
+
+    # Determine if the document can be set.
+    #
+    # @example Is this settable?
+    #   person.settable?
+    #
+    # @return [ true | false ] Is this document a new embeds one?
+    def settable?
+      new_record? && embedded_one? && _parent.persisted?
+    end
+
+    # Is the document updateable?
+    #
+    # @example Is the document updateable?
+    #   person.updateable?
+    #
+    # @return [ true | false ] If the document is changed and persisted.
+    def updateable?
+      persisted? && changed?
+    end
+
+    private
+
+    def reset_readonly
+      self.__selected_fields = nil
+    end
+  end
+end

data/lib/mongoid/stringified_symbol.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+# A class which sends values to the database as Strings but returns them to the user as Symbols.
+module Mongoid
+  class StringifiedSymbol
+
+    class << self
+
+      # Convert the object from its mongo friendly ruby type to this type.
+      #
+      # @example Demongoize the object.
+      #   Mongoid::StringifiedSymbol.demongoize(object)
+      #
+      # @param [ Object ] object The object to demongoize.
+      #
+      # @return [ Symbol ] The object.
+      #
+      # @api private
+      def demongoize(object)
+        if object.nil?
+          object
+        else
+          object.to_s.to_sym
+        end
+      end
+
+      # Turn the object from the ruby type we deal with to a Mongo friendly
+      # type.
+      #
+      # @example Mongoize the object.
+      #   Mongoid::StringifiedSymbol.mongoize("123.11")
+      #
+      # @param [ Object ] object The object to mongoize.
+      #
+      # @return [ Symbol ] The object mongoized.
+      #
+      # @api private
+      def mongoize(object)
+         if object.nil?
+           object
+         else
+           object.to_s
+         end
+      end
+
+      # @api private
+      def evolve(object)
+        mongoize(object)
+      end
+    end
+  end
+end

data/lib/mongoid/tasks/database.rake

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+namespace :db do
+  namespace :mongoid do
+    task :load_models do
+      ::Mongoid.load_models
+    end
+
+    desc "Create collections for Mongoid models"
+    task :create_collections => [:environment, :load_models] do
+      ::Mongoid::Tasks::Database.create_collections
+    end
+
+    desc "Create indexes specified in Mongoid models"
+    task :create_indexes => [:environment, :load_models] do
+      ::Mongoid::Tasks::Database.create_indexes
+    end
+
+    desc "Remove indexes that exist in the database but are not specified in Mongoid models"
+    task :remove_undefined_indexes => [:environment, :load_models] do
+      ::Mongoid::Tasks::Database.remove_undefined_indexes
+    end
+
+    desc "Remove indexes specified in Mongoid models"
+    task :remove_indexes => [:environment, :load_models] do
+      ::Mongoid::Tasks::Database.remove_indexes
+    end
+
+    desc "Shard collections with shard keys specified in Mongoid models"
+    task :shard_collections => [:environment, :load_models] do
+      ::Mongoid::Tasks::Database.shard_collections
+    end
+
+    desc "Drop the database of the default Mongoid client"
+    task :drop => :environment do
+      ::Mongoid::Clients.default.database.drop
+    end
+
+    desc "Drop all non-system collections"
+    task :purge => :environment do
+      ::Mongoid.purge!
+    end
+
+    namespace :create_collections do
+      desc "Drop and create collections for Mongoid models"
+      task :force => [:environment, :load_models] do
+        ::Mongoid::Tasks::Database.create_collections(force: true)
+      end
+    end
+  end
+end