mrkurt-mongo_mapper 0.6.8

data/lib/mongo_mapper/finder_options.rb

@@ -0,0 +1,145 @@
+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

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1,125 @@
+# 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

@@ -0,0 +1,66 @@
+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

data/lib/mongo_mapper/rails_compatibility/document.rb

@@ -0,0 +1,15 @@
+module MongoMapper
+  module RailsCompatibility
+    module Document
+      def self.included(model)
+        model.class_eval do
+          alias_method :new_record?, :new?
+          
+          def human_name
+            self.name.demodulize.titleize
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/rails_compatibility/embedded_document.rb

@@ -0,0 +1,28 @@
+module MongoMapper
+  module RailsCompatibility
+    module EmbeddedDocument
+      def self.included(model)
+        model.class_eval do
+          extend ClassMethods
+          
+          alias_method :new_record?, :new?
+        end
+
+        class << model
+          alias has_many many
+          alias has_one one
+        end
+      end
+
+      module ClassMethods
+        def column_names
+          keys.keys
+        end
+        
+        def human_name
+          self.name.demodulize.titleize
+        end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/serialization.rb

@@ -0,0 +1,54 @@
+require 'active_support/json'
+
+module MongoMapper
+  module Serialization
+    class Serializer
+      attr_reader :options
+
+      def initialize(record, options={})
+        @record, @options = record, options.dup
+      end
+
+      def serializable_key_names
+        key_names = @record.attributes.keys
+
+        if options[:only]
+          options.delete(:except)
+          key_names = key_names & Array(options[:only]).collect { |n| n.to_s }
+        else
+          options[:except] = Array(options[:except])
+          key_names = key_names - options[:except].collect { |n| n.to_s }
+        end
+
+        key_names
+      end
+
+      def serializable_method_names
+        Array(options[:methods]).inject([]) do |method_attributes, name|
+          method_attributes << name if @record.respond_to?(name.to_s)
+          method_attributes
+        end
+      end
+
+      def serializable_names
+        serializable_key_names + serializable_method_names
+      end
+
+      def serializable_record
+        returning(serializable_record = {}) do
+          serializable_names.each { |name| serializable_record[name] = @record.send(name) }
+        end
+      end
+
+      def serialize
+        # overwrite to implement
+      end
+
+      def to_s(&block)
+        serialize(&block)
+      end
+    end
+  end
+end
+
+require 'mongo_mapper/serializers/json_serializer'