mongoid-with-auth 1.9.4

data/lib/mongoid/extensions/objectid/conversions.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Extensions #:nodoc:
+    module ObjectId #:nodoc:
+      module Conversions #:nodoc:
+        def set(value)
+          value
+        end
+        def get(value)
+          value
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/extensions/proc/scoping.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Extensions #:nodoc:
+    module Proc #:nodoc:
+      module Scoping #:nodoc:
+        def scoped(*args)
+          call(*args).scoped
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/extensions/string/conversions.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Extensions #:nodoc:
+    module String #:nodoc:
+      module Conversions #:nodoc:
+        def set(value)
+          value.to_s unless value.nil?
+        end
+        def get(value)
+          value
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/extensions/string/inflections.rb

@@ -0,0 +1,97 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Extensions #:nodoc:
+    module String #:nodoc:
+      module Inflections #:nodoc:
+
+        ActiveSupport::Inflector.inflections do |inflect|
+          inflect.singular("address", "address")
+          inflect.singular("addresses", "address")
+          inflect.irregular("canvas", "canvases")
+        end
+
+        # Represents how special characters will get converted when creating a
+        # composite key that should be unique and part of a url.
+        CHAR_CONV = {
+          " " => "-",
+          "!" => "-excl-",
+          "\"" => "-bckslsh-",
+          "#" => "-hash-",
+          "$" => "-dol-",
+          "%" => "-perc-",
+          "&" => "-and-",
+          "'" => "-quo-",
+          "(" => "-oparen-",
+          ")" => "-cparen-",
+          "*" => "-astx-",
+          "+" => "-plus-",
+          "," => "-comma-",
+          "-" => "-dash-",
+          "." => "-period-",
+          "/" => "-fwdslsh-",
+          ":" => "-colon-",
+          ";" => "-semicol-",
+          "<" => "-lt-",
+          "=" => "-eq-",
+          ">" => "-gt-",
+          "?" => "-ques-",
+          "@" => "-at-",
+          "[" => "-obrck-",
+          "\\" => "-bckslsh-",
+          "]" => "-clbrck-",
+          "^" => "-carat-",
+          "_" => "-undscr-",
+          "`" => "-bcktick-",
+          "{" => "-ocurly-",
+          "|" => "-pipe-",
+          "}" => "-clcurly-",
+          "~" => "-tilda-"
+        }
+
+        REVERSALS = {
+          "asc" => "desc",
+          "ascending" => "descending",
+          "desc" => "asc",
+          "descending" => "ascending"
+        }
+
+        def collectionize
+          tableize.gsub("/", "_")
+        end
+
+        def identify
+          if Mongoid.parameterize_keys
+            key = ""
+            each_char { |c| key += (CHAR_CONV[c] || c.downcase) }; key
+          else
+            self
+          end
+        end
+
+        def labelize
+          underscore.humanize
+        end
+
+        def invert
+          REVERSALS[self]
+        end
+
+        def singular?
+          singularize == self
+        end
+
+        def plural?
+          pluralize == self
+        end
+
+        def reader
+          writer? ? gsub("=", "") : self
+        end
+
+        def writer?
+          include?("=")
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/extensions/symbol/inflections.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Extensions #:nodoc:
+    module Symbol #:nodoc:
+      module Inflections #:nodoc:
+
+        REVERSALS = {
+          :asc => :desc,
+          :ascending => :descending,
+          :desc => :asc,
+          :descending => :ascending
+        }
+
+        def invert
+          REVERSALS[self]
+        end
+
+        def singular?
+          to_s.singular?
+        end
+
+        def plural?
+          to_s.plural?
+        end
+
+        ["gt", "lt", "gte", "lte", "ne", "near", "in", "nin", "mod", "all", "size", "exists", "within"].each do |oper|
+          class_eval <<-OPERATORS
+            def #{oper}
+              Criterion::Complex.new(:key => self, :operator => "#{oper}")
+            end
+          OPERATORS
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/extensions/time_conversions.rb

@@ -0,0 +1,35 @@
+module Mongoid #:nodoc:
+  module Extensions #:nodoc:
+    module TimeConversions #:nodoc:
+      def set(value)
+        return nil if value.blank?
+        time = convert_to_time(value)
+        strip_milliseconds(time).utc
+      end
+
+      def get(value)
+        return nil if value.blank?
+        if Mongoid::Config.instance.use_utc?
+          value
+        else
+          value.getlocal
+        end
+      end
+
+      protected
+
+      def strip_milliseconds(time)
+        ::Time.at(time.to_i)
+      end
+
+      def convert_to_time(value)
+        case value
+          when ::String then ::Time.parse(value)
+          when ::DateTime then ::Time.utc(value.year, value.month, value.day, value.hour, value.min, value.sec)
+          when ::Date then ::Time.utc(value.year, value.month, value.day)
+          else value
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/extras.rb

@@ -0,0 +1,61 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Extras #:nodoc:
+    extend ActiveSupport::Concern
+    included do
+      class_inheritable_accessor :cached, :enslaved
+      self.cached = false
+      self.enslaved = false
+      delegate :cached?, :enslaved?, :to => "self.class"
+    end
+
+    module ClassMethods #:nodoc
+      # Sets caching on for this class. This class level configuration will
+      # default all queries to cache the results of the first iteration over
+      # the cursor into an internal array. This should only be used for queries
+      # that return a small number of results or have small documents, as after
+      # the first iteration the entire results will be stored in memory.
+      #
+      # Example:
+      #
+      #   class Person
+      #     include Mongoid::Document
+      #     cache
+      #   end
+      def cache
+        self.cached = true
+      end
+
+      # Determines if the class is cached or not.
+      #
+      # Returns:
+      #
+      # True if cached, false if not.
+      def cached?
+        !!self.cached
+      end
+
+      # Set whether or not this documents read operations should delegate to
+      # the slave database by default.
+      #
+      # Example:
+      #
+      #   class Person
+      #     include Mongoid::Document
+      #     enslave
+      #   end
+      def enslave
+        self.enslaved = true
+      end
+
+      # Determines if the class is enslaved or not.
+      #
+      # Returns:
+      #
+      # True if enslaved, false if not.
+      def enslaved?
+        !!self.enslaved
+      end
+    end
+  end
+end

data/lib/mongoid/factory.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  class Factory #:nodoc:
+    # Builds a new +Document+ from the supplied attributes.
+    #
+    # Example:
+    #
+    # <tt>Mongoid::Factory.build(Person, {})</tt>
+    #
+    # Options:
+    #
+    # klass: The class to instantiate from if _type is not present.
+    # attributes: The +Document+ attributes.
+    def self.build(klass, attributes)
+      attrs = {}.merge(attributes)
+      type = attrs["_type"]
+      type ? type.constantize.instantiate(attrs) : klass.instantiate(attrs)
+    end
+  end
+end

data/lib/mongoid/field.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  class Field
+    attr_reader :name, :type
+
+    # Determine if the field is able to be accessible via a mass update.
+    #
+    # Returns:
+    #
+    # true if accessible, false if not.
+    def accessible?
+      !!@accessible
+    end
+
+    # Get the default value for the field.
+    #
+    # Returns:
+    #
+    # The primitive value or a copy of the default.
+    def default
+      copy
+    end
+
+    # Create the new field with a name and optional additional options. Valid
+    # options are :default
+    #
+    # Options:
+    #
+    # name: The name of the field as a +Symbol+.
+    # options: A +Hash+ of options for the field.
+    #
+    # Example:
+    #
+    # <tt>Field.new(:score, :default => 0)</tt>
+    def initialize(name, options = {})
+      @name, @default = name, options[:default]
+      @copyable = (@default.is_a?(Array) || @default.is_a?(Hash))
+      @type = options[:type] || String
+      @accessible = options.has_key?(:accessible) ? options[:accessible] : true
+    end
+
+    # Used for setting an object in the attributes hash. If nil is provided the
+    # default will get returned if it exists.
+    def set(object)
+      type.set(object)
+    end
+
+    # Used for retrieving the object out of the attributes hash.
+    def get(object)
+      type.get(object)
+    end
+
+    protected
+    # Slightly faster default check.
+    def copy
+      @copyable ? @default.dup : @default
+    end
+  end
+end

data/lib/mongoid/fields.rb

@@ -0,0 +1,65 @@
+# encoding: utf-8
+module Mongoid #:nodoc
+  module Fields #:nodoc
+    def self.included(base)
+      base.class_eval do
+        extend ClassMethods
+        # Set up the class attributes that must be available to all subclasses.
+        # These include defaults, fields
+        class_inheritable_accessor :fields
+
+        self.fields = {}
+
+        delegate :defaults, :fields, :to => "self.class"
+      end
+    end
+
+    module ClassMethods #:nodoc
+      # Defines all the fields that are accessable on the Document
+      # For each field that is defined, a getter and setter will be
+      # added as an instance method to the Document.
+      #
+      # Options:
+      #
+      # name: The name of the field, as a +Symbol+.
+      # options: A +Hash+ of options to supply to the +Field+.
+      #
+      # Example:
+      #
+      # <tt>field :score, :default => 0</tt>
+      def field(name, options = {})
+        access = name.to_s
+        set_field(access, options)
+      end
+
+      # Returns the default values for the fields on the document
+      def defaults
+        fields.inject({}) do |defs,(field_name,field)|
+          next(defs) if field.default.nil?
+          defs[field_name.to_s] = field.default
+          defs
+        end
+      end
+
+      protected
+      # Define a field attribute for the +Document+.
+      def set_field(name, options = {})
+        meth = options.delete(:as) || name
+        fields[name] = Field.new(name, options)
+        create_accessors(name, meth, options)
+        add_dirty_methods(name)
+      end
+
+      # Create the field accessors.
+      def create_accessors(name, meth, options = {})
+        define_method(meth) { read_attribute(name) }
+        define_method("#{meth}=") { |value| write_attribute(name, value) }
+        define_method("#{meth}?") do
+          attr = read_attribute(name)
+          (options[:type] == Boolean) ? attr == true : attr.present?
+        end
+      end
+
+    end
+  end
+end

data/lib/mongoid/finders.rb

@@ -0,0 +1,136 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Finders #:nodoc:
+
+    # Delegate to the criteria methods that are natural for creating a new
+    # criteria.
+    [ :all_in, :any_in, :avg, :excludes, :limit, :max, :min,
+      :not_in, :only, :order_by, :skip, :sum, :where ].each do |name|
+      define_method(name) do |*args|
+        criteria.send(name, *args)
+      end
+    end
+
+    # Find +Documents+ given the conditions.
+    #
+    # Options:
+    #
+    # args: A +Hash+ with a conditions key and other options
+    #
+    # <tt>Person.all(:conditions => { :attribute => "value" })</tt>
+    def all(*args)
+      find(:all, *args)
+    end
+
+    # Returns a count of matching records in the database based on the
+    # provided arguments.
+    #
+    # <tt>Person.count(:first, :conditions => { :attribute => "value" })</tt>
+    def count(*args)
+      Criteria.translate(self, *args).count
+    end
+
+    # Helper to initialize a new +Criteria+ object for this class.
+    #
+    # Example:
+    #
+    # <tt>Person.criteria</tt>
+    def criteria
+      Criteria.new(self)
+    end
+
+    # Find a +Document+ in several different ways.
+    #
+    # If a +String+ is provided, it will be assumed that it is a
+    # representation of a Mongo::ObjectId and will attempt to find a single
+    # +Document+ based on that id. If a +Symbol+ and +Hash+ is provided then
+    # it will attempt to find either a single +Document+ or multiples based
+    # on the conditions provided and the first parameter.
+    #
+    # <tt>Person.find(:first, :conditions => { :attribute => "value" })</tt>
+    #
+    # <tt>Person.find(:all, :conditions => { :attribute => "value" })</tt>
+    #
+    # <tt>Person.find(Mongo::ObjectId.new.to_s)</tt>
+    def find(*args)
+      raise Errors::InvalidOptions.new("Calling Document#find with nil is invalid") if args[0].nil?
+      type = args.delete_at(0) if args[0].is_a?(Symbol)
+      criteria = Criteria.translate(self, *args)
+      case type
+      when :first then return criteria.one
+      when :last then return criteria.last
+      else
+        return criteria
+      end
+    end
+
+    # Find the first +Document+ given the conditions, or creates a new document
+    # with the conditions that were supplied
+    #
+    # Options:
+    #
+    # args: A +Hash+ of attributes
+    #
+    # <tt>Person.find_or_create_by(:attribute => "value")</tt>
+    def find_or_create_by(attrs = {})
+      find_or(:create, attrs)
+    end
+
+    # Find the first +Document+ given the conditions, or instantiates a new document
+    # with the conditions that were supplied
+    #
+    # Options:
+    #
+    # args: A +Hash+ of attributes
+    #
+    # <tt>Person.find_or_initialize_by(:attribute => "value")</tt>
+    def find_or_initialize_by(attrs = {})
+      find_or(:new, attrs)
+    end
+
+    # Find the first +Document+ given the conditions.
+    #
+    # Options:
+    #
+    # args: A +Hash+ with a conditions key and other options
+    #
+    # <tt>Person.first(:conditions => { :attribute => "value" })</tt>
+    def first(*args)
+      find(:first, *args)
+    end
+
+    # Find the last +Document+ given the conditions.
+    #
+    # Options:
+    #
+    # args: A +Hash+ with a conditions key and other options
+    #
+    # <tt>Person.last(:conditions => { :attribute => "value" })</tt>
+    def last(*args)
+      find(:last, *args)
+    end
+
+    # Find all documents in paginated fashion given the supplied arguments.
+    # If no parameters are passed just default to offset 0 and limit 20.
+    #
+    # Options:
+    #
+    # params: A +Hash+ of params to pass to the Criteria API.
+    #
+    # Example:
+    #
+    # <tt>Person.paginate(:conditions => { :field => "Test" }, :page => 1,
+    # :per_page => 20)</tt>
+    #
+    # Returns paginated array of docs.
+    def paginate(params = {})
+      Criteria.translate(self, params).paginate
+    end
+
+    protected
+    # Find the first object or create/initialize it.
+    def find_or(method, attrs = {})
+      first(:conditions => attrs) || send(method, attrs)
+    end
+  end
+end