mongoid-ultra 9.0.0.0.alpha1

data/lib/mongoid/attributes/projector.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Attributes
+
+    # This module defines projection helpers.
+    #
+    # Projection rules are rather non-trivial. See
+    # https://www.mongodb.com/docs/manual/reference/method/db.collection.find/#find-projection
+    # for server documentation.
+    # 4.4 server (and presumably all older ones) requires that a projection
+    # for content fields is either exclusionary or inclusionary, i.e. one
+    # cannot mix exclusions and inclusions in the same query.
+    # However, _id can be excluded in a projection that includes content
+    # fields.
+    # Integer projection values other than 0 and 1 aren't officially
+    # documented as of this writing; see DOCSP-15266.
+    # 4.4 server also allows nested hash projection specification
+    # in addition to dot notation, which I assume Mongoid doesn't handle yet.
+    #
+    # @api private
+    class Projector
+      def initialize(projection)
+        if projection
+          @content_projection = projection.dup
+          @content_projection.delete('_id')
+          @id_projection_value = projection['_id']
+        else
+          @content_projection = nil
+          @id_projection_value = nil
+        end
+      end
+
+      attr_reader :id_projection_value
+      attr_reader :content_projection
+
+      # Determine if the specified attribute, or a dot notation path, is allowed
+      # by the configured projection, if any.
+      #
+      # If there is no configured projection, returns true.
+      #
+      # @param [ String ] name The name of the attribute or a dot notation path.
+      #
+      # @return [ true | false ] Whether the attribute is allowed by projection.
+      #
+      # @api private
+      def attribute_or_path_allowed?(name)
+        # Special handling for _id.
+        if name == '_id'
+          result = unless id_projection_value.nil?
+            value_inclusionary?(id_projection_value)
+          else
+            true
+          end
+          return result
+        end
+
+        if content_projection.nil?
+          # No projection (as opposed to an empty projection).
+          # All attributes are allowed.
+          return true
+        end
+
+        # Find an item which matches or is a parent of the requested name/path.
+        # This handles the case when, for example, the projection was
+        # {foo: true} and we want to know if foo.bar is allowed.
+        item, value = content_projection.detect do |path, value|
+          (name + '.').start_with?(path + '.')
+        end
+        if item
+          return value_inclusionary?(value)
+        end
+
+        if content_inclusionary?
+          # Find an item which would be a strict child of the requested name/path.
+          # This handles the case when, for example, the projection was
+          # {"foo.bar" => true} and we want to know if foo is allowed.
+          # (It is as a container of bars.)
+          item, value = content_projection.detect do |path, value|
+            (path + '.').start_with?(name + '.')
+          end
+          if item
+            return true
+          end
+        end
+
+        !content_inclusionary?
+      end
+
+      private
+
+      # Determines whether the projection for content fields is inclusionary.
+      #
+      # An empty projection is inclusionary.
+      def content_inclusionary?
+        if content_projection.empty?
+          return value_inclusionary?(id_projection_value)
+        end
+
+        value_inclusionary?(content_projection.values.first)
+      end
+
+      def value_inclusionary?(value)
+        case value
+        when Integer
+          value >= 1
+        when true
+          true
+        when false
+          false
+        else
+          # The various expressions that are permitted as projection arguments
+          # imply an inclusionary projection.
+          true
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/attributes/readonly.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Attributes
+
+    # This module defines behavior for readonly attributes.
+    module Readonly
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :readonly_attributes
+        self.readonly_attributes = ::Set.new
+      end
+
+      # Are we able to write the attribute with the provided name?
+      #
+      # @example Can we write the attribute?
+      #   model.attribute_writable?(:title)
+      #
+      # @param [ String | Symbol ] name The name of the field.
+      #
+      # @return [ true | false ] If the document is new, or if the field is not
+      #   readonly.
+      def attribute_writable?(name)
+        new_record? || (!readonly_attributes.include?(name) && _loaded?(name))
+      end
+
+      private
+
+      def as_writable_attribute!(name, value = :nil)
+        normalized_name = database_field_name(name)
+        if attribute_writable?(normalized_name)
+          yield(normalized_name)
+        else
+          raise Errors::ReadonlyAttribute.new(name, value)
+        end
+      end
+
+      def _loaded?(name)
+        __selected_fields.nil? || projected_field?(name)
+      end
+
+      def projected_field?(name)
+        projected = (__selected_fields || {}).keys.select { |f| __selected_fields[f] == 1 }
+        projected.empty? || projected.include?(name)
+      end
+
+      module ClassMethods
+
+        # Defines an attribute as readonly. This will ensure that the value for
+        # the attribute is only set when the document is new or we are
+        # creating. In other cases, the field write will be ignored with the
+        # exception of #remove_attribute and #update_attribute, where an error
+        # will get raised.
+        #
+        # @example Flag fields as readonly.
+        #   class Band
+        #     include Mongoid::Document
+        #     field :name, type: String
+        #     field :genre, type: String
+        #     attr_readonly :name, :genre
+        #   end
+        #
+        # @param [ Symbol... ] *names The names of the fields.
+        def attr_readonly(*names)
+          names.each do |name|
+            readonly_attributes << database_field_name(name)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/attributes.rb

@@ -0,0 +1,368 @@
+# frozen_string_literal: true
+
+require "active_model/attribute_methods"
+require "mongoid/attributes/dynamic"
+require "mongoid/attributes/nested"
+require "mongoid/attributes/processing"
+require "mongoid/attributes/projector"
+require "mongoid/attributes/readonly"
+
+module Mongoid
+
+  # This module contains the logic for handling the internal attributes hash,
+  # and how to get and set values.
+  module Attributes
+    extend ActiveSupport::Concern
+    include Nested
+    include Processing
+    include Readonly
+
+    attr_reader :attributes
+    alias :raw_attributes :attributes
+
+    # Determine if an attribute is present.
+    #
+    # @example Is the attribute present?
+    #   person.attribute_present?("title")
+    #
+    # @param [ String | Symbol ] name The name of the attribute.
+    #
+    # @return [ true | false ] True if present, false if not.
+    def attribute_present?(name)
+      attribute = read_raw_attribute(name)
+      !attribute.blank? || attribute == false
+    rescue Mongoid::Errors::AttributeNotLoaded
+      false
+    end
+
+    # Get the attributes that have not been cast.
+    #
+    # @example Get the attributes before type cast.
+    #   document.attributes_before_type_cast
+    #
+    # @return [ Hash ] The uncast attributes.
+    def attributes_before_type_cast
+      @attributes_before_type_cast ||= {}
+    end
+
+    # Does the document have the provided attribute?
+    #
+    # @example Does the document have the attribute?
+    #   model.has_attribute?(:name)
+    #
+    # @param [ String | Symbol ] name The name of the attribute.
+    #
+    # @return [ true | false ] If the key is present in the attributes.
+    def has_attribute?(name)
+      attributes.key?(name.to_s)
+    end
+
+    # Does the document have the provided attribute before it was assigned
+    # and type cast?
+    #
+    # @example Does the document have the attribute before it was assigned?
+    #   model.has_attribute_before_type_cast?(:name)
+    #
+    # @param [ String | Symbol ] name The name of the attribute.
+    #
+    # @return [ true | false ] If the key is present in the
+    #   attributes_before_type_cast.
+    def has_attribute_before_type_cast?(name)
+      attributes_before_type_cast.key?(name.to_s)
+    end
+
+    # Read a value from the document attributes. If the value does not exist
+    # it will return nil.
+    #
+    # @example Read an attribute.
+    #   person.read_attribute(:title)
+    #
+    # @example Read an attribute (alternate syntax.)
+    #   person[:title]
+    #
+    # @param [ String | Symbol ] name The name of the attribute to get.
+    #
+    # @return [ Object ] The value of the attribute.
+    def read_attribute(name)
+      field = fields[name.to_s]
+      raw = read_raw_attribute(name)
+      process_raw_attribute(name.to_s, raw, field)
+    end
+    alias :[] :read_attribute
+
+
+    # Process the raw attribute values just read from the documents attributes.
+    #
+    # @param [ String ] name The name of the attribute to get.
+    # @param [ Object ] raw The raw attribute value.
+    # @param [ Field | nil ] field The field to use for demongoization or nil.
+    #
+    # @return [ Object ] The value of the attribute.
+    #
+    # @api private
+    def process_raw_attribute(name, raw, field)
+      value = field ? field.demongoize(raw) : raw
+      attribute_will_change!(name) if value.resizable?
+      value
+    end
+
+    # Read a value from the attributes before type cast. If the value has not
+    # yet been assigned then this will return the attribute's existing value
+    # using read_raw_attribute.
+    #
+    # @example Read an attribute before type cast.
+    #   person.read_attribute_before_type_cast(:price)
+    #
+    # @param [ String | Symbol ] name The name of the attribute to get.
+    #
+    # @return [ Object ] The value of the attribute before type cast, if
+    #   available. Otherwise, the value of the attribute.
+    def read_attribute_before_type_cast(name)
+      attr = name.to_s
+      if attributes_before_type_cast.key?(attr)
+        attributes_before_type_cast[attr]
+      else
+        read_raw_attribute(attr)
+      end
+    end
+
+    # Remove a value from the +Document+ attributes. If the value does not exist
+    # it will fail gracefully.
+    #
+    # @example Remove the attribute.
+    #   person.remove_attribute(:title)
+    #
+    # @param [ String | Symbol ] name The name of the attribute to remove.
+    #
+    # @raise [ Errors::ReadonlyAttribute ] If the field cannot be removed due
+    #   to being flagged as reaodnly.
+    def remove_attribute(name)
+      validate_writable_field_name!(name.to_s)
+      as_writable_attribute!(name) do |access|
+        _assigning do
+          attribute_will_change!(access)
+          delayed_atomic_unsets[atomic_attribute_name(access)] = [] unless new_record?
+          attributes.delete(access)
+        end
+      end
+    end
+
+    # Write a single attribute to the document attribute hash. This will
+    # also fire the before and after update callbacks, and perform any
+    # necessary typecasting.
+    #
+    # @example Write the attribute.
+    #   person.write_attribute(:title, "Mr.")
+    #
+    # @example Write the attribute (alternate syntax.)
+    #   person[:title] = "Mr."
+    #
+    # @param [ String | Symbol ] name The name of the attribute to update.
+    # @param [ Object ] value The value to set for the attribute.
+    def write_attribute(name, value)
+      validate_writable_field_name!(name.to_s)
+
+      field_name = database_field_name(name)
+
+      if attribute_missing?(field_name)
+        raise Mongoid::Errors::AttributeNotLoaded.new(self.class, field_name)
+      end
+
+      if attribute_writable?(field_name)
+        _assigning do
+          localized = fields[field_name].try(:localized?)
+          attributes_before_type_cast[name.to_s] = value
+          typed_value = typed_value_for(field_name, value)
+          unless attributes[field_name] == typed_value || attribute_changed?(field_name)
+            attribute_will_change!(field_name)
+          end
+          if localized
+            present = fields[field_name].try(:localize_present?)
+            loc_key, loc_val = typed_value.first
+            if present && loc_val.blank?
+              attributes[field_name]&.delete(loc_key)
+            else
+              attributes[field_name] ||= {}
+              attributes[field_name].merge!(typed_value)
+            end
+          else
+            attributes[field_name] = typed_value
+          end
+
+          # when writing an attribute, also remove it from the unsets,
+          # so that removing then writing doesn't result in a removal.
+          delayed_atomic_unsets.delete(field_name)
+
+          typed_value
+        end
+      else
+        # TODO: MONGOID-5072
+      end
+    end
+    alias :[]= :write_attribute
+
+    # Allows you to set all the attributes for a particular mass-assignment security role
+    # by passing in a hash of attributes with keys matching the attribute names
+    # (which again matches the column names)  and the role name using the :as option.
+    # To bypass mass-assignment security you can use the :without_protection => true option.
+    #
+    # @example Assign the attributes.
+    #   person.assign_attributes(:title => "Mr.")
+    #
+    # @example Assign the attributes (with a role).
+    #   person.assign_attributes({ :title => "Mr." }, :as => :admin)
+    #
+    # @param [ Hash ] attrs The new attributes to set.
+    def assign_attributes(attrs = nil)
+      _assigning do
+        process_attributes(attrs)
+      end
+    end
+
+    # Writes the supplied attributes hash to the document. This will only
+    # overwrite existing attributes if they are present in the new +Hash+, all
+    # others will be preserved.
+    #
+    # @example Write the attributes.
+    #   person.write_attributes(:title => "Mr.")
+    #
+    # @example Write the attributes (alternate syntax.)
+    #   person.attributes = { :title => "Mr." }
+    #
+    # @param [ Hash ] attrs The new attributes to set.
+    def write_attributes(attrs = nil)
+      assign_attributes(attrs)
+    end
+    alias :attributes= :write_attributes
+
+    # Determine if the attribute is missing from the document, due to loading
+    # it from the database with missing fields.
+    #
+    # @example Is the attribute missing?
+    #   document.attribute_missing?("test")
+    #
+    # @param [ String ] name The name of the attribute.
+    #
+    # @return [ true | false ] If the attribute is missing.
+    def attribute_missing?(name)
+      !Projector.new(__selected_fields).attribute_or_path_allowed?(name)
+    end
+
+    # Return type-casted attributes.
+    #
+    # @example Type-casted attributes.
+    #   document.typed_attributes
+    #
+    # @return [ Object ] The hash with keys and values of the type-casted attributes.
+    def typed_attributes
+      attribute_names.map { |name| [name, send(name)] }.to_h
+    end
+
+    private
+
+    # Does the string contain dot syntax for accessing hashes?
+    #
+    # @api private
+    #
+    # @example Is the string in dot syntax.
+    #   model.hash_dot_syntax?
+    #
+    # @return [ true | false ] If the string contains a "."
+    def hash_dot_syntax?(string)
+      string.include?(".")
+    end
+
+    # Return the typecasted value for a field.
+    #
+    # @example Get the value typecasted.
+    #   person.typed_value_for(:title, :sir)
+    #
+    # @param [ String | Symbol ] key The field name.
+    # @param [ Object ] value The uncast value.
+    #
+    # @return [ Object ] The cast value.
+    def typed_value_for(key, value)
+      fields.key?(key) ? fields[key].mongoize(value) : value.mongoize
+    end
+
+    private
+
+    def read_raw_attribute(name)
+      normalized = database_field_name(name.to_s)
+
+      if attribute_missing?(normalized)
+        raise Mongoid::Errors::AttributeNotLoaded.new(self.class, name)
+      end
+
+      if hash_dot_syntax?(normalized)
+        if fields.key?(normalized)
+          attributes[normalized]
+        else
+          attributes.__nested__(normalized)
+        end
+      else
+        attributes[normalized]
+      end
+    end
+
+    module ClassMethods
+
+      # Alias the provided name to the original field. This will provide an
+      # aliased getter, setter, existence check, and all dirty attribute
+      # methods.
+      #
+      # @example Alias the attribute.
+      #   class Product
+      #     include Mongoid::Document
+      #     field :price, :type => Float
+      #     alias_attribute :cost, :price
+      #   end
+      #
+      # @param [ Symbol ] name The new name.
+      # @param [ Symbol ] original The original name.
+      def alias_attribute(name, original)
+        aliased_fields[name.to_s] = original.to_s
+
+        alias_method name, original
+        alias_method "#{name}=", "#{original}="
+        alias_method "#{name}?", "#{original}?"
+        alias_method "#{name}_change", "#{original}_change"
+        alias_method "#{name}_changed?", "#{original}_changed?"
+        alias_method "reset_#{name}!", "reset_#{original}!"
+        alias_method "reset_#{name}_to_default!", "reset_#{original}_to_default!"
+        alias_method "#{name}_was", "#{original}_was"
+        alias_method "#{name}_will_change!", "#{original}_will_change!"
+        alias_method "#{name}_before_type_cast", "#{original}_before_type_cast"
+      end
+
+      # Removes a field alias.
+      #
+      # @param [ Symbol ] name The aliased field name to remove.
+      def unalias_attribute(name)
+        unless aliased_fields.delete(name.to_s)
+          raise AttributeError, "Field #{name} is not an aliased field"
+        end
+
+        remove_method name
+        remove_method "#{name}="
+        remove_method "#{name}?"
+        remove_method "#{name}_change"
+        remove_method "#{name}_changed?"
+        remove_method "reset_#{name}!"
+        remove_method "reset_#{name}_to_default!"
+        remove_method "#{name}_was"
+        remove_method "#{name}_will_change!"
+        remove_method "#{name}_before_type_cast"
+      end
+    end
+
+    private
+
+    def lookup_attribute_presence(name, value)
+      if localized_fields.has_key?(name) && value
+        value = localized_fields[name].send(:lookup, value)
+      end
+      value.present?
+    end
+  end
+end

data/lib/mongoid/cacheable.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Mongoid
+
+  # Encapsulates behavior around caching.
+  module Cacheable
+    extend ActiveSupport::Concern
+
+    included do
+      cattr_accessor :cache_timestamp_format, instance_writer: false
+      self.cache_timestamp_format = :nsec
+    end
+
+    # Print out the cache key. This will append different values on the
+    # plural model name.
+    #
+    # If new_record?     - will append /new
+    # If not             - will append /id-updated_at.to_formatted_s(cache_timestamp_format)
+    # Without updated_at - will append /id
+    #
+    # This is usually called inside a cache() block
+    #
+    # @example Returns the cache key
+    #   document.cache_key
+    #
+    # @return [ String ] the string with or without updated_at
+    def cache_key
+      return "#{model_key}/new" if new_record?
+      return "#{model_key}/#{_id}-#{updated_at.utc.to_formatted_s(cache_timestamp_format)}" if do_or_do_not(:updated_at)
+      "#{model_key}/#{_id}"
+    end
+  end
+end