mongoid-with-auth 1.9.4

data/lib/mongoid/identity.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  class Identity #:nodoc:
+    class << self
+      # Create the identity for the +Document+.
+      #
+      # The id will be set in either in the form of a Mongo
+      # +ObjectId+ or a composite key set up by defining a key on the document.
+      #
+      # The _type will be set to the document's class name.
+      def create(doc)
+        identify(doc); type(doc); doc
+      end
+
+      protected
+      # Return the proper id for the document.
+      def generate_id
+        id = BSON::ObjectId.new
+        Mongoid.use_object_ids ? id : id.to_s
+      end
+
+      # Set the id for the document.
+      def identify(doc)
+        doc.id = compose(doc).join(" ").identify if doc.primary_key
+        doc.id = generate_id if doc.id.blank?
+      end
+
+      # Set the _type field on the document.
+      def type(doc)
+        doc._type = doc.class.name if doc.hereditary?
+      end
+
+      # Generates the composite key for a document.
+      def compose(doc)
+        doc.primary_key.collect { |key| doc.attributes[key] }.reject { |val| val.nil? }
+      end
+    end
+  end
+end

data/lib/mongoid/indexes.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+module Mongoid #:nodoc
+  module Indexes #:nodoc
+    def self.included(base)
+      base.class_eval do
+        extend ClassMethods
+
+        cattr_accessor :indexed
+        self.indexed = false
+      end
+    end
+
+    module ClassMethods #:nodoc
+      # Add the default indexes to the root document if they do not already
+      # exist. Currently this is only _type.
+      def add_indexes
+        if hereditary && !indexed
+          self._collection.create_index(:_type, :unique => false, :background => true)
+          self.indexed = true
+        end
+      end
+
+      # Adds an index on the field specified. Options can be :unique => true or
+      # :unique => false. It will default to the latter.
+      def index(name, options = { :unique => false })
+        collection.create_index(name, options)
+      end
+    end
+  end
+end

data/lib/mongoid/javascript.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  class Javascript
+    # Constant for the file that defines all the js functions.
+    FUNCTIONS = File.join(File.dirname(__FILE__), "javascript", "functions.yml")
+
+    # Load the javascript functions and define a class method for each one,
+    # that memoizes the value.
+    #
+    # Example:
+    #
+    # <tt>Mongoid::Javascript.aggregate</tt>
+    YAML.load(File.read(FUNCTIONS)).each_pair do |key, function|
+      (class << self; self; end).class_eval <<-EOT
+        def #{key}
+          @#{key} ||= "#{function}"
+        end
+      EOT
+    end
+  end
+end

data/lib/mongoid/javascript/functions.yml

@@ -0,0 +1,37 @@
+aggregate:
+  "function(obj, prev) {
+     prev.count++;
+   }"
+
+group:
+  "function(obj, prev) {
+     prev.group.push(obj);
+   }"
+
+max:
+  "function(obj, prev) {
+     if (prev.max == 'start') {
+       prev.max = obj.[field];
+     }
+     if (prev.max < obj.[field]) {
+       prev.max = obj.[field];
+     }
+   }"
+
+min:
+  "function(obj, prev) {
+     if (prev.min == 'start') {
+       prev.min = obj.[field];
+     }
+     if (prev.min > obj.[field]) {
+       prev.min = obj.[field];
+     }
+   }"
+
+sum:
+  "function(obj, prev) {
+     if (prev.sum == 'start') {
+       prev.sum = 0;
+     }
+     prev.sum += obj.[field];
+  }"

data/lib/mongoid/matchers.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+require "mongoid/matchers/default"
+require "mongoid/matchers/all"
+require "mongoid/matchers/exists"
+require "mongoid/matchers/gt"
+require "mongoid/matchers/gte"
+require "mongoid/matchers/in"
+require "mongoid/matchers/lt"
+require "mongoid/matchers/lte"
+require "mongoid/matchers/ne"
+require "mongoid/matchers/nin"
+require "mongoid/matchers/size"
+
+module Mongoid #:nodoc:
+  module Matchers
+    # Determines if this document has the attributes to match the supplied
+    # MongoDB selector. Used for matching on embedded associations.
+    def matches?(selector)
+      selector.each_pair do |key, value|
+        return false unless matcher(key, value).matches?(value)
+      end
+      true
+    end
+
+    protected
+    # Get the matcher for the supplied key and value. Will determine the class
+    # name from the key.
+    def matcher(key, value)
+      if value.is_a?(Hash)
+        name = "Mongoid::Matchers::#{value.keys.first.gsub("$", "").camelize}"
+        return name.constantize.new(attributes[key])
+      end
+      Default.new(attributes[key])
+    end
+  end
+end

data/lib/mongoid/matchers/all.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+    class All < Default
+      # Return true if the attribute and first value in the hash are equal.
+      def matches?(value)
+        @attribute == value.values.first
+      end
+    end
+  end
+end

data/lib/mongoid/matchers/default.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+    class Default
+      # Creating a new matcher only requires the value.
+      def initialize(attribute)
+        @attribute = attribute
+      end
+      # Return true if the attribute and value are equal.
+      def matches?(value)
+        @attribute == value
+      end
+
+      protected
+      # Return the first value in the hash.
+      def first(value)
+        value.values.first
+      end
+
+      # If object exists then compare, else return false
+      def determine(value, operator)
+        @attribute ? @attribute.send(operator, first(value)) : false
+      end
+    end
+  end
+end

data/lib/mongoid/matchers/exists.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+    class Exists < Default
+      # Return true if the attribute exists and checking for existence or
+      # return true if the attribute does not exist and checking for
+      # non-existence.
+      def matches?(value)
+        @attribute.nil? != value.values.first
+      end
+    end
+  end
+end

data/lib/mongoid/matchers/gt.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+    class Gt < Default
+      # Return true if the attribute is greater than the value.
+      def matches?(value)
+        determine(value, :>)
+      end
+    end
+  end
+end

data/lib/mongoid/matchers/gte.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+    class Gte < Default
+      # Return true if the attribute is greater than or equal to the value.
+      def matches?(value)
+        determine(value, :>=)
+      end
+    end
+  end
+end

data/lib/mongoid/matchers/in.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+    class In < Default
+      # Return true if the attribute is in the values.
+      def matches?(value)
+        value.values.first.include?(@attribute)
+      end
+    end
+  end
+end

data/lib/mongoid/matchers/lt.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+    class Lt < Default
+      # Return true if the attribute is less than the value.
+      def matches?(value)
+        determine(value, :<)
+      end
+    end
+  end
+end

data/lib/mongoid/matchers/lte.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+    class Lte < Default
+      # Return true if the attribute is less than or equal to the value.
+      def matches?(value)
+        determine(value, :<=)
+      end
+    end
+  end
+end

data/lib/mongoid/matchers/ne.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+    class Ne < Default
+      # Return true if the attribute and first value are not equal.
+      def matches?(value)
+        @attribute != value.values.first
+      end
+    end
+  end
+end

data/lib/mongoid/matchers/nin.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+    class Nin < Default
+      # Return true if the attribute is not in the value list.
+      def matches?(value)
+        !value.values.first.include?(@attribute)
+      end
+    end
+  end
+end

data/lib/mongoid/matchers/size.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+    class Size < Default
+      # Return true if the attribute size is equal to the first value.
+      def matches?(value)
+        @attribute.size == value.values.first
+      end
+    end
+  end
+end

data/lib/mongoid/memoization.rb

@@ -0,0 +1,33 @@
+module Mongoid #:nodoc
+  module Memoization
+
+    # Handles cases when accessing an association that should be memoized in
+    # the Mongoid specific manner. Does not memoize nil values though
+    def memoized(name, &block)
+      var = "@#{name}"
+      if instance_variable_defined?(var)
+        return instance_variable_get(var)
+      end
+      value = yield
+      instance_variable_set(var, value) if value
+    end
+
+    # Removes an memozied association if it exists
+    def unmemoize(name)
+      var = "@#{name}"
+      remove_instance_variable(var) if instance_variable_defined?(var)
+    end
+
+    # Mongoid specific behavior is to remove the memoized object when setting
+    # the association, or if it wasn't previously memoized it will get set.
+    def reset(name, &block)
+      var = "@#{name}"
+      value = yield
+      if instance_variable_defined?(var)
+        remove_instance_variable(var)
+      else
+        instance_variable_set(var, value)
+      end
+    end
+  end
+end

data/lib/mongoid/named_scope.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module NamedScope
+    # Creates a named_scope for the +Document+, similar to ActiveRecord's
+    # named_scopes. +NamedScopes+ are proxied +Criteria+ objects that can be
+    # chained.
+    #
+    # Example:
+    #
+    #   class Person
+    #     include Mongoid::Document
+    #     field :active, :type => Boolean
+    #     field :count, :type => Integer
+    #
+    #     named_scope :active, :where => { :active => true }
+    #     named_scope :count_gt_one, :where => { :count.gt => 1 }
+    #     named_scope :at_least_count, lambda { |count| { :where => { :count.gt => count } } }
+    #   end
+    def named_scope(name, options = {}, &block)
+      name = name.to_sym
+      scopes[name] = lambda do |parent, *args|
+        Scope.new(parent, options.scoped(*args), &block)
+      end
+      (class << self; self; end).class_eval <<-EOT
+        def #{name}(*args)
+          scopes[:#{name}].call(self, *args)
+        end
+      EOT
+    end
+    alias :scope :named_scope
+
+    # Return the scopes or default to an empty +Hash+.
+    def scopes
+      read_inheritable_attribute(:scopes) || write_inheritable_attribute(:scopes, {})
+    end
+  end
+end

data/lib/mongoid/observable.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Observable #:nodoc:
+    extend ActiveSupport::Concern
+    included do
+      attr_reader :observers
+    end
+
+    # Add an observer to this object. This mimics the standard Ruby observable
+    # library.
+    #
+    # Example:
+    #
+    # <tt>address.add_observer(person)</tt>
+    def add_observer(object)
+      @observers ||= []
+      @observers.push(object)
+    end
+
+    # Notify all the objects observing this object of an update. All observers
+    # need to respond to the update method in order to handle this.
+    #
+    # Example:
+    #
+    # <tt>document.notify_observers(self)</tt>
+    def notify_observers(*args)
+      @observers.dup.each { |observer| observer.observe(*args) } if @observers
+    end
+  end
+end

data/lib/mongoid/paths.rb

@@ -0,0 +1,62 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Paths #:nodoc:
+    extend ActiveSupport::Concern
+    included do
+      attr_accessor :__path
+      attr_accessor :_index
+    end
+    module InstanceMethods
+      # Get the insertion modifier for the document. Will be nil on root
+      # documents, $set on embeds_one, $push on embeds_many.
+      #
+      # Example:
+      #
+      # <tt>name.inserter</tt>
+      def _inserter
+        embedded? ? (embedded_many? ? "$push" : "$set") : nil
+      end
+
+      # Return the path to this +Document+ in JSON notation, used for atomic
+      # updates via $set in MongoDB.
+      #
+      # Example:
+      #
+      # <tt>address.path # returns "addresses"</tt>
+      def _path
+        _position.sub!(/\.\d+$/, '') || _position
+      end
+      alias :_pull :_path
+
+      # Returns the positional operator of this document for modification.
+      #
+      # Example:
+      #
+      # <tt>address.position</tt>
+      def _position
+        locator = _index ? (new_record? ? "" : ".#{_index}") : ""
+        embedded? ? "#{_parent._position}#{"." unless _parent._position.blank?}#{@association_name}#{locator}" : ""
+      end
+
+      # Get the removal modifier for the document. Will be nil on root
+      # documents, $unset on embeds_one, $set on embeds_many.
+      #
+      # Example:
+      #
+      # <tt>name.remover</tt>
+      def _remover
+        embedded? ? (_index ? "$pull" : "$unset") : nil
+      end
+
+      # Return the selector for this document to be matched exactly for use
+      # with MongoDB's $ operator.
+      #
+      # Example:
+      #
+      # <tt>address.selector</tt>
+      def _selector
+        embedded? ? _parent._selector.merge("#{_path}._id" => id) : { "_id" => id }
+      end
+    end
+  end
+end