novelys_mongo_mapper 0.6.10

data/lib/mongo_mapper/dynamic_finder.rb

@@ -0,0 +1,74 @@
+module MongoMapper
+  # @api private
+  module Finders
+    def dynamic_find(finder, args)
+      attributes = {}
+      finder.attributes.each_with_index do |attr, index|
+        attributes[attr] = args[index]
+      end
+      
+      options = args.extract_options!.merge(attributes)
+      
+      if result = send(finder.finder, options)
+        result
+      else
+        if finder.raise?
+          raise DocumentNotFound, "Couldn't find Document with #{attributes.inspect} in collection named #{collection.name}"
+        end
+        
+        if finder.instantiator
+          self.send(finder.instantiator, attributes)
+        end
+      end
+    end
+    
+    protected
+      def method_missing(method, *args, &block)
+        finder = DynamicFinder.new(method)
+
+        if finder.found?
+          dynamic_find(finder, args)
+        else
+          super
+        end
+      end
+  end
+  
+  class DynamicFinder
+    attr_reader :method, :attributes, :finder, :bang, :instantiator
+
+    def initialize(method)
+      @method = method
+      @finder = :first
+      @bang   = false
+      match
+    end
+
+    def found?
+      @finder.present?
+    end
+    
+    def raise?
+      bang == true
+    end
+
+    protected
+      def match
+        case method.to_s
+          when /^find_(all_by|by)_([_a-zA-Z]\w*)$/
+            @finder = :all if $1 == 'all_by'
+            names = $2
+          when /^find_by_([_a-zA-Z]\w*)\!$/
+            @bang = true
+            names = $1
+          when /^find_or_(initialize|create)_by_([_a-zA-Z]\w*)$/
+            @instantiator = $1 == 'initialize' ? :new : :create
+            names = $2
+          else
+            @finder = nil
+        end
+        
+        @attributes = names && names.split('_and_')
+      end
+  end
+end

data/lib/mongo_mapper/embedded_document.rb

@@ -0,0 +1,67 @@
+module MongoMapper
+  module EmbeddedDocument
+    extend DescendantAppends
+
+    def self.included(model)
+      model.class_eval do
+        include InstanceMethods
+        extend  ClassMethods
+        extend Plugins
+
+        plugin Plugins::Associations
+        plugin Plugins::Clone
+        plugin Plugins::Descendants
+        plugin Plugins::Equality
+        plugin Plugins::Inspect
+        plugin Plugins::Keys
+        plugin Plugins::Logger
+        plugin Plugins::Protected
+        plugin Plugins::Rails
+        plugin Plugins::Serialization
+        plugin Plugins::Validations
+
+        attr_accessor :_root_document, :_parent_document
+      end
+
+      super
+    end
+
+    module ClassMethods
+      def embeddable?
+        true
+      end
+
+      def embedded_in(owner_name)
+        define_method(owner_name) do
+          self._parent_document
+        end
+      end
+    end
+
+    module InstanceMethods
+      def save(options={})
+        if result = _root_document.try(:save, options)
+          @new = false
+        end
+        result
+      end
+
+      def save!(options={})
+        if result = _root_document.try(:save!, options)
+          @new = false
+        end
+        result
+      end
+
+      def update_attributes(attrs={})
+        self.attributes = attrs
+        self.save
+      end
+
+      def update_attributes!(attrs={})
+        self.attributes = attrs
+        self.save!
+      end
+    end # InstanceMethods
+  end # EmbeddedDocument
+end # MongoMapper

data/lib/mongo_mapper/finder_options.rb

@@ -0,0 +1,127 @@
+module MongoMapper
+  # = Important Note
+  # This class is private to MongoMapper and should not be considered part of 
+  # MongoMapper's public API.
+  #
+  class FinderOptions
+    OptionKeys = [:fields, :select, :skip, :offset, :limit, :sort, :order]
+
+    def self.normalized_field(field)
+      field.to_s == 'id' ? :_id : field
+    end
+
+    def self.normalized_order_direction(direction)
+      direction ||= 'ASC'
+      direction.upcase == 'ASC' ? 1 : -1
+    end
+
+    def initialize(model, options)
+      raise ArgumentError, "Options must be a hash" unless options.is_a?(Hash)
+
+      @model      = model
+      @options    = {}
+      @conditions = {}
+
+      options.each_pair do |key, value|
+        key = key.respond_to?(:to_sym) ? key.to_sym : key
+        if OptionKeys.include?(key)
+          @options[key] = value
+        elsif key == :conditions
+          @conditions.merge!(value)
+        else
+          @conditions[key] = value
+        end
+      end
+
+      add_sci_scope
+    end
+
+    def criteria
+      to_mongo_criteria(@conditions)
+    end
+
+    def options
+      fields = @options[:fields] || @options[:select]
+      skip   = @options[:skip]   || @options[:offset] || 0
+      limit  = @options[:limit]  || 0
+      sort   = @options[:sort]   || convert_order_to_sort(@options[:order])
+
+      {:fields => to_mongo_fields(fields), :skip => skip.to_i, :limit => limit.to_i, :sort => sort}
+    end
+
+    def to_a
+      [criteria, options]
+    end
+
+    private
+      def to_mongo_criteria(conditions, parent_key=nil)
+        criteria = {}
+
+        conditions.each_pair do |field, value|
+          field = self.class.normalized_field(field)
+          
+          if @model.object_id_key?(field) && value.is_a?(String)
+            value = Mongo::ObjectID.from_string(value)
+          end
+          
+          if field.is_a?(SymbolOperator)
+            criteria.update(field.to_mm_criteria(value))
+            next
+          end
+          
+          case value
+            when Array
+              criteria[field] = operator?(field) ? value : {'$in' => value}
+            when Hash
+              criteria[field] = to_mongo_criteria(value, field)
+            when Time
+              criteria[field] = value.utc
+            else            
+              criteria[field] = value
+          end
+        end
+
+        criteria
+      end
+
+      def operator?(field)
+        field.to_s =~ /^\$/
+      end
+
+      # adds _type single collection inheritance scope for models that need it
+      def add_sci_scope
+        if @model.single_collection_inherited?
+          @conditions[:_type] = @model.to_s
+        end
+      end
+
+      def to_mongo_fields(fields)
+        return if fields.blank?
+
+        if fields.respond_to?(:flatten, :compact)
+          fields.flatten.compact
+        else
+          fields.split(',').map { |field| field.strip }
+        end
+      end
+
+      def convert_order_to_sort(sort)
+        return if sort.blank?
+        
+        if sort.respond_to?(:all?) && sort.all? { |s| s.respond_to?(:to_mm_order) }
+          sort.map { |s| s.to_mm_order }
+        elsif sort.respond_to?(:to_mm_order)
+          [sort.to_mm_order]
+        else
+          pieces = sort.split(',')
+          pieces.map { |s| to_mongo_sort_piece(s) }
+        end
+      end
+
+      def to_mongo_sort_piece(str)
+        field, direction = str.strip.split(' ')
+        direction = FinderOptions.normalized_order_direction(direction)
+        [field, direction]
+      end
+  end
+end

data/lib/mongo_mapper/plugins.rb

@@ -0,0 +1,14 @@
+module MongoMapper
+  module Plugins
+    def plugins
+      @plugins ||= []
+    end
+    
+    def plugin(mod)
+      extend mod::ClassMethods     if mod.const_defined?(:ClassMethods)
+      include mod::InstanceMethods if mod.const_defined?(:InstanceMethods)
+      mod.configure(self)          if mod.respond_to?(:configure)
+      plugins << mod
+    end
+  end
+end

data/lib/mongo_mapper/plugins/associations.rb

@@ -0,0 +1,104 @@
+module MongoMapper
+  module Plugins
+    module Associations
+      module ClassMethods
+        def belongs_to(association_id, options={}, &extension)
+          create_association(:belongs_to, association_id, options, &extension)
+        end
+
+        def many(association_id, options={}, &extension)
+          create_association(:many, association_id, options, &extension)
+        end
+
+        def one(association_id, options={}, &extension)
+          create_association(:one, association_id, options, &extension)
+        end
+
+        def associations
+          @associations ||= HashWithIndifferentAccess.new
+        end
+
+        def associations=(hash)
+          @associations = hash
+        end
+
+        def inherited(subclass)
+          subclass.associations = associations.dup
+          super
+        end
+
+        private
+          def create_association(type, name, options, &extension)
+            association = Associations::Base.new(type, name, options, &extension)
+            associations[association.name] = association
+
+            define_method(association.name) do
+              get_proxy(association)
+            end
+
+            define_method("#{association.name}=") do |value|
+              get_proxy(association).replace(value)
+              value
+            end
+
+            if association.one? || association.belongs_to?
+              define_method("#{association.name}?") do
+                get_proxy(association).present?
+              end
+            end
+
+            if association.options[:dependent] && association.many? && !association.embeddable?
+              after_destroy do |doc|
+                case association.options[:dependent]
+                  when :destroy
+                    doc.get_proxy(association).destroy_all
+                  when :delete_all
+                    doc.get_proxy(association).delete_all
+                  when :nullify
+                    doc.get_proxy(association).nullify
+                end
+              end
+            end
+          end
+      end
+
+      module InstanceMethods
+        def associations
+          self.class.associations
+        end
+        
+        # @api private?
+        def embedded_associations
+          associations.select do |name, association|
+            association.embeddable?
+          end.map do |name, association|
+            association
+          end
+        end
+
+        def get_proxy(association)
+          unless proxy = self.instance_variable_get(association.ivar)
+            proxy = association.proxy_class.new(self, association)
+            self.instance_variable_set(association.ivar, proxy)
+          end
+          
+          proxy
+        end
+      end
+    end
+  end
+end
+
+require 'mongo_mapper/plugins/associations/base'
+require 'mongo_mapper/plugins/associations/proxy'
+require 'mongo_mapper/plugins/associations/collection'
+require 'mongo_mapper/plugins/associations/embedded_collection'
+require 'mongo_mapper/plugins/associations/many_documents_proxy'
+require 'mongo_mapper/plugins/associations/belongs_to_proxy'
+require 'mongo_mapper/plugins/associations/belongs_to_polymorphic_proxy'
+require 'mongo_mapper/plugins/associations/many_polymorphic_proxy'
+require 'mongo_mapper/plugins/associations/many_embedded_proxy'
+require 'mongo_mapper/plugins/associations/many_embedded_polymorphic_proxy'
+require 'mongo_mapper/plugins/associations/many_documents_as_proxy'
+require 'mongo_mapper/plugins/associations/one_proxy'
+require 'mongo_mapper/plugins/associations/in_array_proxy'

data/lib/mongo_mapper/plugins/associations/base.rb

@@ -0,0 +1,121 @@
+module MongoMapper
+  module Plugins
+    module Associations
+      class Base
+        attr_reader :type, :name, :options, :finder_options
+
+        # Options that should not be considered MongoDB query options/criteria
+        AssociationOptions = [:as, :class, :class_name, :dependent, :extend, :foreign_key, :in, :polymorphic]
+
+        def initialize(type, name, options={}, &extension)
+          @type, @name, @options, @finder_options = type, name, {}, {}
+          options.symbolize_keys!
+
+          options[:extend] = modulized_extensions(extension, options[:extend])
+
+          options.each_pair do |key, value|
+            if AssociationOptions.include?(key)
+              @options[key] = value
+            else
+              @finder_options[key] = value
+            end
+          end
+        end
+
+        def class_name
+          @class_name ||= begin
+            if cn = options[:class_name]
+              cn
+            elsif many?
+              name.to_s.singularize.camelize
+            else
+              name.to_s.camelize
+            end
+          end
+        end
+
+        def klass
+          @klass ||= options[:class] || class_name.constantize
+        end
+
+        def many?
+          @many_type ||= @type == :many
+        end
+
+        def belongs_to?
+          @belongs_to_type ||= @type == :belongs_to
+        end
+
+        def one?
+          @one_type ||= @type == :one
+        end
+
+        def polymorphic?
+          !!@options[:polymorphic]
+        end
+
+        def as?
+          !!@options[:as]
+        end
+
+        def in_array?
+          !!@options[:in]
+        end
+
+        def embeddable?
+          many? && klass.embeddable?
+        end
+
+        def type_key_name
+          @type_key_name ||= many? ? '_type' : "#{as}_type"
+        end
+
+        def as
+          @options[:as] || self.name
+        end
+
+        def foreign_key
+          @options[:foreign_key] || "#{name}_id"
+        end
+
+        def ivar
+          @ivar ||= "@_#{name}"
+        end
+
+        def proxy_class
+          @proxy_class ||= begin
+            if many?
+              if self.klass.embeddable?
+                polymorphic? ? ManyEmbeddedPolymorphicProxy : ManyEmbeddedProxy
+              else
+                if polymorphic?
+                  ManyPolymorphicProxy
+                elsif as?
+                  ManyDocumentsAsProxy
+                elsif in_array?
+                  InArrayProxy
+                else
+                  ManyDocumentsProxy
+                end
+              end
+            elsif one?
+              OneProxy
+            else
+              polymorphic? ? BelongsToPolymorphicProxy : BelongsToProxy
+            end
+          end
+        end
+
+        private
+
+          # @param [Array<Module, Proc>] extensions a collection of Modules or 
+          #   Procs that extend the behaviour of this association.
+          def modulized_extensions(*extensions)
+            extensions.flatten.compact.map do |extension|
+              Proc === extension ? Module.new(&extension) : extension
+            end
+          end
+      end
+    end
+  end
+end