fcoury-mongomapper 0.2.0

data/lib/mongomapper/document_rails_compatibility.rb

@@ -0,0 +1,13 @@
+module MongoMapper
+  module DocumentRailsCompatibility
+    def self.included(model)
+      model.class_eval do
+        alias_method :new_record?, :new?
+      end
+    end
+
+    def to_param
+      id
+    end
+  end
+end

data/lib/mongomapper/embedded_document.rb

@@ -0,0 +1,248 @@
+require 'observer'
+
+module MongoMapper
+  module EmbeddedDocument
+    class NotImplemented < StandardError; end
+
+    def self.included(model)
+      model.class_eval do
+        extend ClassMethods
+        include InstanceMethods
+      
+        extend Associations::ClassMethods
+        include Associations::InstanceMethods
+
+        include EmbeddedDocumentRailsCompatibility
+        include Validatable
+        include Serialization
+      end
+    end
+
+    module ClassMethods
+      def keys
+        @keys ||= if parent = parent_model
+          parent.keys.dup
+        else
+          HashWithIndifferentAccess.new
+        end
+      end
+
+      def key(name, type, options={})
+        key = Key.new(name, type, options)
+        keys[key.name] = key
+        apply_validations_for(key)
+        create_indexes_for(key)
+        key
+      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
+        if parent = ancestors[1]
+          parent if parent.ancestors.include?(EmbeddedDocument)
+        end
+      end
+
+    private
+      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?
+          initialize_associations(attrs)
+          self.attributes = attrs
+        end
+      end
+
+      def attributes=(attrs)
+        return if attrs.blank?
+        attrs.each_pair do |key_name, value|
+          if writer?(key_name)
+            write_attribute(key_name, value)
+          else
+            writer_method ="#{key_name}="
+            self.send(writer_method, value) if respond_to?(writer_method)
+          end
+        end
+      end
+
+      def attributes
+        self.class.keys.inject(HashWithIndifferentAccess.new) do |attributes, key_hash|
+          name, key = key_hash
+          value = value_for_key(key)
+          attributes[name] = value unless value.nil?
+          attributes
+        end
+      end
+
+      def reader?(name)
+        defined_key_names.include?(name.to_s)
+      end
+
+      def writer?(name)
+        name = name.to_s
+        name = name.chop if name.ends_with?('=')
+        reader?(name)
+      end
+
+      def before_typecast_reader?(name)
+        name.to_s.match(/^(.*)_before_typecast$/) && reader?($1)
+      end
+
+      def [](name)
+        read_attribute(name)
+      end
+
+      def []=(name, value)
+        write_attribute(name, value)
+      end
+
+      def method_missing(method, *args, &block)
+        attribute = method.to_s
+
+        if reader?(attribute)
+          read_attribute(attribute)
+        elsif writer?(attribute)
+          write_attribute(attribute.chop, args[0])
+        elsif before_typecast_reader?(attribute)
+          read_attribute_before_typecast(attribute.gsub(/_before_typecast$/, ''))
+        else
+          super
+        end
+      end
+
+      def ==(other)
+        other.is_a?(self.class) && attributes == other.attributes
+      end
+
+      def inspect
+        attributes_as_nice_string = defined_key_names.collect do |name|
+          "#{name}: #{read_attribute(name)}"
+        end.join(", ")
+        "#<#{self.class} #{attributes_as_nice_string}>"
+      end
+
+      alias :respond_to_without_attributes? :respond_to?
+
+      def respond_to?(method, include_private=false)
+        return true if reader?(method) || writer?(method) || before_typecast_reader?(method)
+        super
+      end
+
+    private
+      def value_for_key(key)
+        if key.native?
+          read_attribute(key.name)
+        else
+          embedded_document = read_attribute(key.name)
+          embedded_document && embedded_document.attributes
+        end
+      end
+
+      def read_attribute(name)
+        defined_key(name).get(instance_variable_get("@#{name}"))
+      end
+
+      def read_attribute_before_typecast(name)
+        instance_variable_get("@#{name}_before_typecast")
+      end
+
+      def write_attribute(name, value)
+        instance_variable_set "@#{name}_before_typecast", value
+        instance_variable_set "@#{name}", defined_key(name).set(value)
+      end
+
+      def defined_key(name)
+        self.class.keys[name]
+      end
+
+      def defined_key_names
+        self.class.keys.keys
+      end
+
+      def only_defined_keys(hash={})
+        defined_key_names = defined_key_names()
+        hash.delete_if { |k, v| !defined_key_names.include?(k.to_s) }
+      end
+      
+      def embedded_association_attributes
+        embedded_attributes = HashWithIndifferentAccess.new
+        self.class.associations.each_pair do |name, association|
+          
+          if association.type == :many && association.klass.embeddable?            
+            if documents = instance_variable_get(association.ivar)
+              embedded_attributes[name] = documents.collect do |item|
+                attributes_hash = item.attributes
+                
+                item.send(:embedded_association_attributes).each_pair do |association_name, association_value|
+                  attributes_hash[association_name] = association_value
+                end
+                
+                attributes_hash
+              end
+            end
+          end
+        end
+        
+        embedded_attributes
+      end
+
+      def initialize_associations(attrs={})
+        self.class.associations.each_pair do |name, association|
+          if collection = attrs.delete(name)
+            __send__("#{association.name}=", collection)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongomapper/embedded_document_rails_compatibility.rb

@@ -0,0 +1,22 @@
+module MongoMapper
+  module EmbeddedDocumentRailsCompatibility
+    def self.included(model)
+      model.class_eval do
+        extend ClassMethods
+      end
+      class << model
+        alias_method :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.name}. You should implement it to return the unique identifier of this document within a collection."
+    end
+  end
+end

data/lib/mongomapper/finder_options.rb

@@ -0,0 +1,81 @@
+module MongoMapper
+  class FinderOptions
+    attr_reader :options
+    
+    def self.to_mongo_criteria(conditions)
+      conditions = conditions.dup
+      criteria = {}
+      conditions.each_pair do |field, value|
+        case value
+          when Array
+            criteria[field] = {'$in' => value}
+          when Hash
+            criteria[field] = to_mongo_criteria(value)
+          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)),
+        :offset => (options.delete(:offset) || 0).to_i,
+        :limit  => (options.delete(:limit) || 0).to_i,
+        :sort   => to_mongo_sort(options.delete(:order))
+      }
+    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/mongomapper/key.rb

@@ -0,0 +1,82 @@
+class Boolean; end
+class Ref; end
+
+module MongoMapper
+  class Key
+    # DateTime and Date are currently not supported by mongo's bson so just use Time
+    NativeTypes = [String, Float, Time, Integer, Boolean, Array, Hash, Ref]
+
+    attr_accessor :name, :type, :options, :default_value
+
+    def initialize(name, type, options={})
+      @name, @type = name.to_s, type
+      self.options = options.symbolize_keys
+      self.default_value = options.delete(:default)
+    end
+
+    def ==(other)
+      @name == other.name && @type == other.type
+    end
+
+    def set(value)
+      typecast(value)
+    end
+
+    def native?
+      @native ||= NativeTypes.include?(type)
+    end
+
+    def embedded_document?
+      type.ancestors.include?(EmbeddedDocument) && !type.ancestors.include?(Document)
+    end
+
+    def get(value)
+      return default_value if value.nil? && !default_value.nil?
+      if type == Array
+        value || []
+      elsif type == Hash
+        HashWithIndifferentAccess.new(value || {})
+      else
+        value
+      end
+    end
+
+    private
+      def typecast(value)
+        return HashWithIndifferentAccess.new(value) if value.is_a?(Hash) && type == Hash
+        return value if value.kind_of?(type) || value.nil?
+        begin
+          if    type == String    then value.to_s
+          elsif type == Float     then value.to_f
+          elsif type == Array     then value.to_a
+          elsif type == Time      then Time.parse(value.to_s)
+          #elsif type == Date      then Date.parse(value.to_s)
+          elsif type == Boolean   then ['true', 't', '1'].include?(value.to_s.downcase)
+          elsif type == Integer
+            # ganked from datamapper
+            value_to_i = value.to_i
+            if value_to_i == 0 && value != '0'
+              value_to_s = value.to_s
+              begin
+                Integer(value_to_s =~ /^(\d+)/ ? $1 : value_to_s)
+              rescue ArgumentError
+                nil
+              end
+            else
+              value_to_i
+            end
+          elsif embedded_document?
+            typecast_embedded_document(value)
+          else
+            value
+          end
+        rescue
+          value
+        end
+      end
+
+      def typecast_embedded_document(value)
+        value.is_a?(type) ? value : type.new(value)
+      end
+  end
+end