mongo_mapper 0.6.10 → 0.7.0

data/lib/mongo_mapper/dynamic_finder.rb

@@ -1,74 +0,0 @@
-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 = find(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/finder_options.rb

@@ -1,145 +0,0 @@
-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)
-      options = options.symbolize_keys
-
-      @model      = model
-      @options    = {}
-      @conditions = options.delete(:conditions) || {}
-
-      options.each_pair do |key, value|
-        if OptionKeys.include?(key)
-          @options[key] = value
-        else
-          @conditions[key] = value
-        end
-      end
-
-      add_sci_scope
-    end
-
-    def criteria
-      to_mongo_criteria(@conditions)
-    end
-
-    def options
-      fields = @options.delete(:fields) || @options.delete(:select)
-      skip   = @options.delete(:skip)   || @options.delete(:offset) || 0
-      limit  = @options.delete(:limit)  || 0
-      sort   = @options.delete(:sort)   || convert_order_to_sort(@options.delete(: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?(FinderOperator)
-            criteria.update(field.to_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_order) }
-          sort.map { |s| s.to_order }
-        elsif sort.respond_to?(:to_order)
-          [sort.to_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
-  
-  class FinderOperator
-    def initialize(field, operator)
-      @field, @operator = field, operator
-    end
-    
-    def to_criteria(value)
-      {FinderOptions.normalized_field(@field) => {@operator => value}}
-    end
-  end
-  
-  class OrderOperator
-    def initialize(field, direction)
-      @field, @direction = field, direction
-    end
-    
-    def to_order
-      [@field.to_s, FinderOptions.normalized_order_direction(@direction)]
-    end
-  end
-end

data/lib/mongo_mapper/key.rb

@@ -1,36 +0,0 @@
-module MongoMapper
-  class Key
-    attr_accessor :name, :type, :options, :default_value
-    
-    def initialize(*args)
-      options = args.extract_options!
-      @name, @type = args.shift.to_s, args.shift
-      self.options = (options || {}).symbolize_keys
-      self.default_value = self.options.delete(:default)
-    end
-
-    def ==(other)
-      @name == other.name && @type == other.type
-    end
-
-    def set(value)
-      type.to_mongo(value)
-    end
-
-    def embeddable?
-      type.respond_to?(:embeddable?) && type.embeddable? ? true : false
-    end
-    
-    def number?
-      [Integer, Float].include?(type)
-    end
-
-    def get(value)
-      if value.nil? && !default_value.nil?
-        return default_value
-      end
-      
-      type.from_mongo(value)
-    end
-  end
-end

data/lib/mongo_mapper/mongo_mapper.rb

@@ -1,125 +0,0 @@
-# if Gem is defined i'll assume you are using rubygems and lock specific versions
-# call me crazy but a plain old require will just get the latest version you have installed
-# so i want to make sure that if you are using gems you do in fact have the correct versions
-# if there is a better way to do this, please enlighten me!
-if self.class.const_defined?(:Gem)
-  gem 'activesupport', '>= 2.3'
-  gem 'mongo', '0.18.2'
-  gem 'jnunemaker-validatable', '1.8.1'
-end
-
-require 'active_support'
-require 'mongo'
-require 'validatable'
-
-module MongoMapper
-  # generic MM error
-  class MongoMapperError < StandardError; end
-  
-  # raised when key expected to exist but not found
-  class KeyNotFound < MongoMapperError; end
-  
-  # raised when document expected but not found
-  class DocumentNotFound < MongoMapperError; end
-  
-  # raised when document not valid and using !
-  class DocumentNotValid < MongoMapperError
-    def initialize(document)
-      super("Validation failed: #{document.errors.full_messages.join(", ")}")
-    end
-  end
-  
-  # @api public
-  def self.connection
-    @@connection ||= Mongo::Connection.new
-  end
-  
-  # @api public
-  def self.connection=(new_connection)
-    @@connection = new_connection
-  end
-  
-  # @api public
-  def self.logger
-    connection.logger
-  end
-  
-  # @api public
-  def self.database=(name)
-    @@database = nil
-    @@database_name = name
-  end
-  
-  # @api public
-  def self.database
-    if @@database_name.blank?
-      raise 'You forgot to set the default database name: MongoMapper.database = "foobar"'
-    end
-    
-    @@database ||= MongoMapper.connection.db(@@database_name)
-  end
-  
-  # @api private
-  def self.ensured_indexes
-    @@ensured_indexes ||= []
-  end
-  
-  # @api private
-  def self.ensured_indexes=(value)
-    @@ensured_indexes = value
-  end
-  
-  # @api private
-  def self.ensure_index(klass, keys, options={})
-    ensured_indexes << {:klass => klass, :keys => keys, :options => options}
-  end
-  
-  # @api public
-  def self.ensure_indexes!
-    ensured_indexes.each do |index|
-      unique = index[:options].delete(:unique)
-      index[:klass].collection.create_index(index[:keys], unique)
-    end
-  end
-  
-  # @api private
-  def self.use_time_zone?
-    Time.respond_to?(:zone) && Time.zone ? true : false
-  end
-  
-  # @api private
-  def self.time_class
-    use_time_zone? ? Time.zone : Time
-  end
-  
-  # @api private
-  def self.normalize_object_id(value)
-    value.is_a?(String) ? Mongo::ObjectID.from_string(value) : value
-  end
-end
-
-require 'mongo_mapper/support'
-require 'mongo_mapper/callbacks'
-require 'mongo_mapper/finder_options'
-require 'mongo_mapper/dirty'
-require 'mongo_mapper/dynamic_finder'
-require 'mongo_mapper/key'
-require 'mongo_mapper/pagination'
-require 'mongo_mapper/serialization'
-require 'mongo_mapper/validations'
-require 'mongo_mapper/rails_compatibility/document'
-require 'mongo_mapper/rails_compatibility/embedded_document'
-require 'mongo_mapper/embedded_document'
-require 'mongo_mapper/document'
-require 'mongo_mapper/associations'
-require 'mongo_mapper/associations/base'
-require 'mongo_mapper/associations/proxy'
-require 'mongo_mapper/associations/collection'
-require 'mongo_mapper/associations/many_documents_proxy'
-require 'mongo_mapper/associations/belongs_to_proxy'
-require 'mongo_mapper/associations/belongs_to_polymorphic_proxy'
-require 'mongo_mapper/associations/many_polymorphic_proxy'
-require 'mongo_mapper/associations/many_embedded_proxy'
-require 'mongo_mapper/associations/many_embedded_polymorphic_proxy'
-require 'mongo_mapper/associations/many_documents_as_proxy'
-require 'mongo_mapper/associations/one_proxy'

data/lib/mongo_mapper/pagination.rb

@@ -1,66 +0,0 @@
-module MongoMapper
-  module Pagination
-    class PaginationProxy
-      instance_methods.each { |m| undef_method m unless m =~ /(^__|^nil\?$|^send$|proxy_|^object_id$)/ }
-      
-      attr_accessor :subject
-      attr_reader :total_entries, :per_page, :current_page
-      alias limit per_page
-      
-      def initialize(total_entries, current_page, per_page=nil)
-        @total_entries    = total_entries.to_i
-        self.per_page     = per_page
-        self.current_page = current_page
-      end
-      
-      def total_pages
-        (total_entries / per_page.to_f).ceil
-      end
-      
-      def out_of_bounds?
-        current_page > total_pages
-      end
-      
-      def previous_page
-        current_page > 1 ? (current_page - 1) : nil
-      end
-      
-      def next_page
-        current_page < total_pages ? (current_page + 1) : nil
-      end
-      
-      def skip
-        (current_page - 1) * per_page
-      end
-      alias offset skip # for will paginate support
-
-      def send(method, *args, &block)
-        if respond_to?(method)
-          super
-        else
-          subject.send(method, *args, &block)
-        end
-      end
-      
-      def ===(other)
-        other === subject
-      end
-      
-      def method_missing(name, *args, &block)
-        @subject.send(name, *args, &block)
-      end
-      
-      private
-        def per_page=(value)
-          value = 25 if value.blank?
-          @per_page = value.to_i
-        end
-        
-        def current_page=(value)
-          value = value.to_i
-          value = 1 if value < 1
-          @current_page = value
-        end
-    end
-  end
-end