djsun-mongo_mapper 0.5.0.1

data/lib/mongo_mapper/embedded_document.rb

@@ -0,0 +1,354 @@
+require 'observer'
+
+module MongoMapper
+  module EmbeddedDocument
+    def self.included(model)
+      model.class_eval do
+        extend ClassMethods
+        include InstanceMethods
+
+        extend Associations::ClassMethods
+        include Associations::InstanceMethods
+
+        include RailsCompatibility::EmbeddedDocument
+        include Validatable
+        include Serialization
+
+        extend Validations::Macros
+
+        key :_id, String
+        attr_accessor :_root_document
+      end
+    end
+
+    module ClassMethods
+      def inherited(subclass)
+        unless subclass.embeddable?
+          subclass.set_collection_name(collection_name)
+        end
+
+        (@subclasses ||= []) << subclass
+      end
+
+      def subclasses
+        @subclasses
+      end
+
+      def keys
+        @keys ||= if parent = parent_model
+          parent.keys.dup
+        else
+          HashWithIndifferentAccess.new
+        end
+      end
+
+      def key(*args)
+        key = Key.new(*args)
+
+        if keys[key.name].blank?
+          keys[key.name] = key
+
+          create_accessors_for(key)
+          add_to_subclasses(*args)
+          apply_validations_for(key)
+          create_indexes_for(key)
+
+          key
+        end
+      end
+
+      def add_to_subclasses(*args)
+        return if subclasses.blank?
+
+        subclasses.each do |subclass|
+          subclass.key(*args)
+        end
+      end
+
+      def ensure_index(name_or_array, options={})
+        keys_to_index = if name_or_array.is_a?(Array)
+          name_or_array.map { |pair| [pair[0], pair[1]] }
+        else
+          name_or_array
+        end
+
+        collection.create_index(keys_to_index, options.delete(:unique))
+      end
+
+      def embeddable?
+        !self.ancestors.include?(Document)
+      end
+
+      def parent_model
+        (ancestors - [self,EmbeddedDocument]).find do |parent_class|
+          parent_class.ancestors.include?(EmbeddedDocument)
+        end
+      end
+      
+      def to_mongo(instance)
+        return nil if instance.nil?
+        instance.to_mongo
+      end
+      
+      def from_mongo(instance_or_hash)
+        return nil if instance_or_hash.nil?
+        
+        if instance_or_hash.is_a?(self)
+          instance_or_hash
+        else
+          new(instance_or_hash)
+        end
+      end
+      
+    private
+      def accessors_module
+        if const_defined?('MongoMapperKeys')
+          const_get 'MongoMapperKeys'
+        else
+          const_set 'MongoMapperKeys', Module.new
+        end
+      end
+
+      def create_accessors_for(key)
+        accessors_module.module_eval <<-end_eval
+          def #{key.name}
+            read_attribute(:'#{key.name}')
+          end
+
+          def #{key.name}_before_typecast
+            read_attribute_before_typecast(:'#{key.name}')
+          end
+
+          def #{key.name}=(value)
+            write_attribute(:'#{key.name}', value)
+          end
+
+          def #{key.name}?
+            read_attribute(:#{key.name}).present?
+          end
+        end_eval
+        include accessors_module
+      end
+
+      def create_indexes_for(key)
+        ensure_index key.name if key.options[:index]
+      end
+
+      def apply_validations_for(key)
+        attribute = key.name.to_sym
+
+        if key.options[:required]
+          validates_presence_of(attribute)
+        end
+
+        if key.options[:unique]
+          validates_uniqueness_of(attribute)
+        end
+
+        if key.options[:numeric]
+          number_options = key.type == Integer ? {:only_integer => true} : {}
+          validates_numericality_of(attribute, number_options)
+        end
+
+        if key.options[:format]
+          validates_format_of(attribute, :with => key.options[:format])
+        end
+
+        if key.options[:length]
+          length_options = case key.options[:length]
+          when Integer
+            {:minimum => 0, :maximum => key.options[:length]}
+          when Range
+            {:within => key.options[:length]}
+          when Hash
+            key.options[:length]
+          end
+          validates_length_of(attribute, length_options)
+        end
+      end
+    end
+
+    module InstanceMethods
+      def initialize(attrs={})
+        unless attrs.nil?
+          self.class.associations.each_pair do |name, association|
+            if collection = attrs.delete(name)
+              if association.many? && association.klass.embeddable?
+                root_document = attrs[:_root_document] || self
+                collection.each do |doc|
+                  doc[:_root_document] = root_document
+                end
+              end
+              send("#{association.name}=", collection)
+            end
+          end
+
+          self.attributes = attrs
+          
+          if respond_to?(:_type=) && self['_type'].blank?
+            self._type = self.class.name
+          end
+        end
+
+        if self.class.embeddable? 
+          if read_attribute(:_id).blank?
+            write_attribute :_id, Mongo::ObjectID.new.to_s
+            @new_document = true
+          else
+            @new_document = false
+          end
+        end
+      end
+      
+      def new?
+        !!@new_document
+      end
+
+      def attributes=(attrs)
+        return if attrs.blank?
+        attrs.each_pair do |name, value|
+          writer_method = "#{name}="
+
+          if respond_to?(writer_method)
+            self.send(writer_method, value)
+          else
+            self[name.to_s] = value
+          end
+        end
+      end
+
+      def attributes
+        attrs = HashWithIndifferentAccess.new
+        
+        embedded_keys.each do |key|
+          puts key.inspect
+          attrs[key.name] = read_attribute(key.name).try(:attributes)
+        end
+        
+        non_embedded_keys.each do |key|
+          attrs[key.name] = read_attribute(key.name)
+        end
+        
+        embedded_associations.each do |association|
+          documents = instance_variable_get(association.ivar)
+          next if documents.nil?
+          attrs[association.name] = documents.collect { |doc| doc.attributes }
+        end
+        
+        attrs
+      end
+      
+      def to_mongo
+        attrs = HashWithIndifferentAccess.new
+        
+        _keys.each_pair do |name, key|
+          value = key.set(read_attribute(key.name))
+          attrs[name] = value
+        end
+        
+        embedded_associations.each do |association|
+          if documents = instance_variable_get(association.ivar)
+            attrs[association.name] = documents.map { |document| document.to_mongo }
+          end
+        end
+        
+        attrs
+      end
+
+      def clone
+        clone_attributes = self.attributes
+        clone_attributes.delete("_id")
+        self.class.new(clone_attributes)
+      end
+
+      def [](name)
+        read_attribute(name)
+      end
+
+      def []=(name, value)
+        ensure_key_exists(name)
+        write_attribute(name, value)
+      end
+
+      def ==(other)
+        other.is_a?(self.class) && id == other.id
+      end
+
+      def id
+        read_attribute(:_id)
+      end
+
+      def id=(value)
+        @using_custom_id = true
+        write_attribute :_id, value
+      end
+
+      def using_custom_id?
+        !!@using_custom_id
+      end
+
+      def inspect
+        attributes_as_nice_string = key_names.collect do |name|
+          "#{name}: #{read_attribute(name).inspect}"
+        end.join(", ")
+        "#<#{self.class} #{attributes_as_nice_string}>"
+      end
+
+      def save
+        if _root_document
+          _root_document.save
+        end
+      end
+
+      def update_attributes(attrs={})
+        self.attributes = attrs
+        save
+      end
+
+      private
+        def _keys
+          self.class.keys
+        end
+        
+        def key_names
+          _keys.keys
+        end
+        
+        def non_embedded_keys
+          _keys.values.select { |key| !key.embeddable? }
+        end
+        
+        def embedded_keys
+          _keys.values.select { |key| key.embeddable? }
+        end
+        
+        def ensure_key_exists(name)
+          self.class.key(name) unless respond_to?("#{name}=")
+        end
+
+        def read_attribute(name)
+          value = _keys[name].get(instance_variable_get("@#{name}"))
+          instance_variable_set "@#{name}", value if !frozen?
+          value
+        end
+
+        def read_attribute_before_typecast(name)
+          instance_variable_get("@#{name}_before_typecast")
+        end
+
+        def write_attribute(name, value)
+          key = _keys[name]
+          instance_variable_set "@#{name}_before_typecast", value
+          instance_variable_set "@#{name}", key.set(value)          
+        end
+        
+        def embedded_associations
+          self.class.associations.select do |name, association|
+            association.embeddable?
+          end.map do |name, association|
+            association
+          end
+        end        
+    end # InstanceMethods
+  end # EmbeddedDocument
+end # MongoMapper

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'