mongo_mapper 0.5.0

data/lib/mongo_mapper/finder_options.rb

@@ -0,0 +1,94 @@
+module MongoMapper
+  class FinderOptions
+    attr_reader :options
+    
+    def self.to_mongo_criteria(conditions, parent_key=nil)
+      criteria = {}
+      conditions.each_pair do |field, value|
+        field = field_normalized(field)
+        case value
+          when Array
+            operator_present = field.to_s =~ /^\$/            
+            criteria[field] = if operator_present
+                                value
+                              else
+                                {'$in' => value}
+                              end
+          when Hash
+            criteria[field] = to_mongo_criteria(value, field)
+          else            
+            criteria[field] = value
+        end
+      end
+      
+      criteria
+    end
+        
+    def self.to_mongo_options(options)
+      options = options.dup
+      {
+        :fields => to_mongo_fields(options.delete(:fields) || options.delete(:select)),
+        :skip   => (options.delete(:skip) || options.delete(:offset) || 0).to_i,
+        :limit  => (options.delete(:limit) || 0).to_i,
+        :sort   => options.delete(:sort) || to_mongo_sort(options.delete(:order))
+      }
+    end
+    
+    def self.field_normalized(field)
+      if field.to_s == 'id'
+        :_id
+      else
+        field
+      end
+    end
+    
+    def initialize(options)
+      raise ArgumentError, "FinderOptions must be a hash" unless options.is_a?(Hash)
+      @options = options.symbolize_keys
+      @conditions = @options.delete(:conditions) || {}
+    end
+    
+    def criteria
+      self.class.to_mongo_criteria(@conditions)
+    end
+    
+    def options
+      self.class.to_mongo_options(@options)
+    end
+    
+    def to_a
+      [criteria, options]
+    end
+    
+    private
+      def self.to_mongo_fields(fields)
+        return if fields.blank?
+      
+        if fields.is_a?(String)
+          fields.split(',').map { |field| field.strip }
+        else
+          fields.flatten.compact
+        end
+      end
+    
+      def self.to_mongo_sort(sort)
+        return if sort.blank?
+        pieces = sort.split(',')
+        pairs  = pieces.map { |s| to_mongo_sort_piece(s) }
+      
+        hash = OrderedHash.new
+        pairs.each do |pair|
+          field, sort_direction = pair
+          hash[field] = sort_direction
+        end
+        hash.symbolize_keys
+      end
+    
+      def self.to_mongo_sort_piece(str)
+        field, direction = str.strip.split(' ')
+        direction ||= 'ASC'
+        direction = direction.upcase == 'ASC' ? 1 : -1
+        [field, direction]
+      end
+  end
+end

data/lib/mongo_mapper/key.rb

@@ -0,0 +1,32 @@
+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 get(value)
+      if value.nil? && !default_value.nil?
+        return default_value
+      end
+      
+      type.from_mongo(value)
+    end
+  end
+end

data/lib/mongo_mapper/observing.rb

@@ -0,0 +1,50 @@
+require 'observer'
+require 'singleton'
+require 'set'
+
+module MongoMapper
+  module Observing #:nodoc:
+    def self.included(model)
+      model.class_eval do
+        extend Observable
+      end      
+    end
+  end
+
+  class Observer
+    include Singleton
+
+    class << self
+      def observe(*models)
+        models.flatten!
+        models.collect! { |model| model.is_a?(Symbol) ? model.to_s.camelize.constantize : model }
+        define_method(:observed_classes) { Set.new(models) }
+      end
+
+      def observed_class
+        if observed_class_name = name[/(.*)Observer/, 1]
+          observed_class_name.constantize
+        else
+          nil
+        end
+      end
+    end
+
+    def initialize
+      Set.new(observed_classes).each { |klass| add_observer! klass }
+    end
+
+    def update(observed_method, object) #:nodoc:
+      send(observed_method, object) if respond_to?(observed_method)
+    end
+
+    protected
+      def observed_classes
+        Set.new([self.class.observed_class].compact.flatten)
+      end
+      
+      def add_observer!(klass)
+        klass.add_observer(self)
+      end
+  end
+end

data/lib/mongo_mapper/pagination.rb

@@ -0,0 +1,51 @@
+module MongoMapper
+  module Pagination
+    class PaginationProxy < BasicObject
+      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
+      
+      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?
+        end
+      end
+            
+      def to_param
+        id
+      end
+    end
+  end
+end

data/lib/mongo_mapper/rails_compatibility/embedded_document.rb

@@ -0,0 +1,27 @@
+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
+        end
+      end
+
+      module ClassMethods
+        def column_names
+          keys.keys
+        end
+      end
+
+      def to_param
+        raise "Missing to_param method in #{self.class}. You should implement it to return the unique identifier of this embedded document within a document."
+      end
+    end
+  end
+end

data/lib/mongo_mapper/save_with_validation.rb

@@ -0,0 +1,19 @@
+module MongoMapper
+  module SaveWithValidation
+    def self.included(base)
+      base.class_eval do
+        alias_method_chain :save, :validation
+        alias_method_chain :save!, :validation
+      end
+    end
+    
+    private
+      def save_with_validation
+        valid? ? save_without_validation : false
+      end
+      
+      def save_with_validation!
+        valid? ? save_without_validation! : raise(DocumentNotValid.new(self))
+      end
+  end  
+end

data/lib/mongo_mapper/serialization.rb

@@ -0,0 +1,55 @@
+require 'active_support/json'
+
+module MongoMapper #:nodoc:
+  module Serialization
+    class Serializer #:nodoc:
+      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
+
+dir = Pathname(__FILE__).dirname.expand_path + 'serializers'
+require dir + 'json_serializer'

data/lib/mongo_mapper/serializers/json_serializer.rb

@@ -0,0 +1,92 @@
+module MongoMapper #:nodoc:
+  module Serialization
+    def self.included(base)
+      base.cattr_accessor :include_root_in_json, :instance_writer => false
+      base.extend ClassMethods
+    end
+
+    # Returns a JSON string representing the model. Some configuration is
+    # available through +options+.
+    #
+    # The option <tt>include_root_in_json</tt> controls the top-level behavior of
+    # to_json. When it is <tt>true</tt>, to_json will emit a single root node named
+    # after the object's type. For example:
+    #
+    #   konata = User.find(1)
+    #   User.include_root_in_json = true
+    #   konata.to_json
+    #   # => { "user": {"id": 1, "name": "Konata Izumi", "age": 16,
+    #                   "created_at": "2006/08/01", "awesome": true} }
+    #
+    #   User.include_root_in_json = false
+    #   konata.to_json
+    #   # => {"id": 1, "name": "Konata Izumi", "age": 16,
+    #         "created_at": "2006/08/01", "awesome": true}
+    #
+    # The remainder of the examples in this section assume include_root_in_json is set to
+    # <tt>false</tt>.
+    #
+    # Without any +options+, the returned JSON string will include all
+    # the model's attributes. For example:
+    #
+    #   konata = User.find(1)
+    #   konata.to_json
+    #   # => {"id": 1, "name": "Konata Izumi", "age": 16,
+    #         "created_at": "2006/08/01", "awesome": true}
+    #
+    # The <tt>:only</tt> and <tt>:except</tt> options can be used to limit the attributes
+    # included, and work similar to the +attributes+ method. For example:
+    #
+    #   konata.to_json(:only => [ :id, :name ])
+    #   # => {"id": 1, "name": "Konata Izumi"}
+    #
+    #   konata.to_json(:except => [ :id, :created_at, :age ])
+    #   # => {"name": "Konata Izumi", "awesome": true}
+    #
+    # To include any methods on the model, use <tt>:methods</tt>.
+    #
+    #   konata.to_json(:methods => :permalink)
+    #   # => {"id": 1, "name": "Konata Izumi", "age": 16,
+    #         "created_at": "2006/08/01", "awesome": true,
+    #         "permalink": "1-konata-izumi"}
+    def to_json(options = {})
+      apply_to_json_defaults(options)
+      
+      if include_root_in_json
+        "{#{self.class.json_class_name}: #{JsonSerializer.new(self, options).to_s}}"
+      else
+        JsonSerializer.new(self, options).to_s
+      end
+    end
+
+    def from_json(json)
+      self.attributes = ActiveSupport::JSON.decode(json)
+      self
+    end
+
+    class JsonSerializer < MongoMapper::Serialization::Serializer #:nodoc:
+      def serialize
+        serializable_record.to_json
+      end
+    end
+
+    module ClassMethods
+      def json_class_name
+        @json_class_name ||= name.demodulize.underscore.inspect
+      end
+    end
+    
+    private
+      def apply_to_json_defaults(options)
+        unless options[:only]
+          methods = [options.delete(:methods)].flatten.compact
+          methods << :id
+          options[:methods] = methods.uniq
+        end
+
+        except = [options.delete(:except)].flatten.compact
+        except << :_id
+        options[:except] = except
+      end
+  end
+end

data/lib/mongo_mapper/support.rb

@@ -0,0 +1,157 @@
+class BasicObject #:nodoc:
+  instance_methods.each { |m| undef_method m unless m =~ /(^__|^nil\?$|^send$|^methods$|instance_eval|proxy_|^object_id$)/ }
+end unless defined?(BasicObject)
+
+class Array
+  def self.to_mongo(value)
+    value.to_a
+  end
+  
+  def self.from_mongo(value)
+    value || []
+  end
+end
+
+class Binary
+  def self.to_mongo(value)
+    if value.is_a?(ByteBuffer)
+      value
+    else
+      value.nil? ? nil : ByteBuffer.new(value)
+    end
+  end
+  
+  def self.from_mongo(value)
+    value
+  end
+end
+
+class Boolean
+  def self.to_mongo(value)
+    if value.is_a?(Boolean)
+      value
+    else
+      ['true', 't', '1'].include?(value.to_s.downcase)
+    end
+  end
+  
+  def self.from_mongo(value)
+    !!value
+  end
+end
+
+class Date
+  def self.to_mongo(value)
+    date = Date.parse(value.to_s)
+    Time.utc(date.year, date.month, date.day)
+  rescue
+    nil
+  end
+  
+  def self.from_mongo(value)
+    value.to_date if value.present?
+  end
+end
+
+class Float
+  def self.to_mongo(value)
+    value.to_f
+  end
+end
+
+class Hash
+  def self.from_mongo(value)
+    HashWithIndifferentAccess.new(value || {})
+  end
+  
+  def to_mongo
+    self
+  end
+end
+
+class Integer
+  def self.to_mongo(value)
+    value_to_i = value.to_i
+    if value_to_i == 0
+      value.to_s =~ /^(0x|0b)?0+/ ? 0 : nil
+    else
+      value_to_i
+    end
+  end
+end
+
+class NilClass
+  def to_mongo(value)
+    value
+  end
+  
+  def from_mongo(value)
+    value
+  end
+end
+
+class Object
+  # The hidden singleton lurks behind everyone
+  def metaclass
+    class << self; self end
+  end
+
+  def meta_eval(&blk)
+    metaclass.instance_eval(&blk)
+  end
+
+  # Adds methods to a metaclass
+  def meta_def(name, &blk)
+    meta_eval { define_method(name, &blk) }
+  end
+
+  # Defines an instance method within a class
+  def class_def(name, &blk)
+    class_eval { define_method(name, &blk) }
+  end
+  
+  def self.to_mongo(value)
+    value
+  end
+  
+  def self.from_mongo(value)
+    value
+  end
+end
+
+class String
+  def self.to_mongo(value)
+    value.nil? ? nil : value.to_s
+  end
+  
+  def self.from_mongo(value)
+    value.nil? ? nil : value.to_s
+  end
+end
+
+class Time
+  def self.to_mongo(value)
+    to_utc_time(value)
+  end
+  
+  def self.from_mongo(value)
+    if Time.respond_to?(:zone) && Time.zone && value.present?
+      value.in_time_zone(Time.zone)
+    else
+      value
+    end
+  end
+  
+  def self.to_utc_time(value)
+    to_local_time(value).try(:utc)
+  end
+  
+  # make sure we have a time and that it is local
+  def self.to_local_time(value)
+    if Time.respond_to?(:zone) && Time.zone
+      Time.zone.parse(value.to_s)
+    else
+      Time.parse(value.to_s)
+    end
+  end
+end