mongo_odm 0.1.8

data/lib/mongo_odm/core_ext/conversions.rb

@@ -0,0 +1,262 @@
+# encoding: utf-8
+require 'active_support/core_ext/big_decimal'
+require 'active_support/core_ext/date/conversions'
+require 'active_support/core_ext/date_time/calculations'
+require 'active_support/core_ext/date_time/conversions'
+require 'active_support/core_ext/string/conversions'
+require 'active_support/core_ext/time/conversions'
+
+# The type_cast class method is called when:
+#  * An attribute of the same class is assigned
+#  * An attribute of the same class is readed from the Mongo driver
+#
+# The to_mongo instance method is called when:
+#  * An attribute of the same class is sent to the Mongo driver
+
+# @private
+class Mongo::ObjectID
+  def self.type_cast(value)
+    return nil if value.nil?
+    return value if value.is_a?(Mongo::ObjectID)
+    value.to_s
+  end
+  
+  def to_mongo
+    self
+  end
+end
+
+# @private
+class BSON::ObjectID
+  def self.type_cast(value)
+    return nil if value.nil?
+    return value if value.is_a?(BSON::ObjectID)
+    value.to_s
+  end
+  
+  def to_mongo
+    self
+  end
+end
+
+# @private
+class Array
+  def self.type_cast(value)
+    return nil if value.nil?
+    value.to_a.map {|elem| MongoODM.instanciate(elem)}
+  end
+  
+  def to_mongo
+    self.map {|elem| elem.to_mongo}
+  end
+end
+
+# @private
+class Class
+  def self.type_cast(value)
+    return nil if value.nil?
+    value.to_s.constantize
+  end
+  
+  def to_mongo
+    self.name
+  end
+end
+
+# @private
+class Symbol
+  def self.type_cast(value)
+    return nil if value.nil?
+    value.to_s.intern
+  end
+  
+  def to_mongo
+    self
+  end
+end
+
+# @private
+class Integer
+  def self.type_cast(value)
+    return nil if value.nil?
+    value.to_i
+  end
+  
+  def to_mongo
+    self
+  end
+end
+
+# @private
+class Float
+  def self.type_cast(value)
+    return nil if value.nil?
+    value.to_f
+  end
+  
+  def to_mongo
+    self
+  end
+end
+
+# @private
+class BigDecimal
+  def self.type_cast(value)
+    return nil if value.nil?
+    value.is_a?(BigDecimal) ? value : new(value.to_s)
+  end
+  
+  def to_mongo
+    self.to_s
+  end
+end
+
+# @private
+class String
+  def self.type_cast(value)
+    return nil if value.nil?
+    value.to_s
+  end
+  
+  def to_mongo
+    self
+  end
+end
+
+# @private
+class Date
+  def self.type_cast(value)
+    return nil if value.nil?
+    value.to_date
+  end
+  
+  def to_mongo
+    Time.utc(self.year, self.month, self.day)
+  end
+end
+
+# @private
+class DateTime
+  def self.type_cast(value)
+    return nil if value.nil?
+    value.to_datetime
+  end
+  
+  def to_mongo
+    datetime = self.utc
+    Time.utc(datetime.year, datetime.month, datetime.day, datetime.hour, datetime.min, datetime.sec)
+  end
+end
+
+# @private
+class TrueClass
+  def self.type_cast(value)
+    return nil if value.nil?
+    true
+  end
+
+  def to_mongo
+    self
+  end
+end
+
+# @private
+class FalseClass
+  def self.type_cast(value)
+    return nil if value.nil?
+    false
+  end
+  
+  def to_mongo
+    self
+  end
+end
+
+# @private
+class Time
+  def self.type_cast(value)
+    return nil if value.nil?
+    value.to_time
+  end
+  
+  def to_mongo
+    self.utc
+  end
+end
+
+# Stand-in for true/false property types.
+# @private
+module Boolean
+  def self.type_cast(value)
+    case value
+    when NilClass
+      nil
+    when Numeric
+      !value.zero?
+    when TrueClass, FalseClass
+      value
+    when /^\s*t/i
+      true
+    when /^\s*f/i
+      false
+    else
+      value.present?
+    end
+  end
+end
+
+# @private
+class Numeric
+  def self.type_cast(value)
+    return nil if value.nil?
+    float_value = value.to_f
+    int_value = value.to_i
+    float_value == int_value ? int_value : float_value
+  end
+end
+
+# @private
+class Hash
+  def self.type_cast(value)
+    return nil if value.nil?
+    Hash[value.to_hash.map{|k,v| [MongoODM.instanciate(k), MongoODM.instanciate(v)]}]
+  end
+  
+  def to_mongo
+    Hash[self.map{|k,v| [k.to_mongo, v.to_mongo]}]
+  end
+end
+
+# @private
+class HashWithIndifferentAccess
+  def self.type_cast(value)
+    Hash.type_cast(value).with_indifferent_access
+  end
+  
+  def to_mongo
+    Hash[self.map{|k,v| [k.to_mongo, v.to_mongo]}]
+  end
+end
+
+# @private
+class Regexp
+  def self.type_cast(value)
+    return nil if value.nil?
+    new(value)
+  end
+  
+  def to_mongo
+    self
+  end
+end
+
+# @private
+class NilClass
+  def self.type_cast(value)
+    nil
+  end
+  
+  def to_mongo
+    nil
+  end
+end

data/lib/mongo_odm/cursor.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module MongoODM
+
+  class Cursor < Mongo::Cursor  
+    def next_document
+      doc = super
+      MongoODM.instanciate_doc(doc)
+    end
+  end
+
+end

data/lib/mongo_odm/document.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+require 'mongo_odm'
+
+module MongoODM
+  module Document
+
+    extend ActiveSupport::Concern
+    extend ActiveSupport::Autoload
+
+    autoload :Associations
+    autoload :AttributeMethods
+    autoload :Callbacks
+    autoload :Fields
+    autoload :Inspect
+    autoload :Persistence
+    autoload :Validations
+
+    included do
+      include ActiveModel::Conversion
+      include ActiveModel::Serializers::JSON
+      include ActiveModel::Serializers::Xml
+      include ActiveModel::Observing
+      include ActiveModel::Translation
+      include MongoODM::Document::Persistence
+      include MongoODM::Document::AttributeMethods
+      include MongoODM::Document::Fields
+      include MongoODM::Document::Inspect
+      include MongoODM::Document::Associations
+      include MongoODM::Document::Callbacks
+      include MongoODM::Document::Validations
+    end
+
+  end
+end

data/lib/mongo_odm/document/associations.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+
+module MongoODM
+  module Document
+    module Associations
+
+      extend ActiveSupport::Concern
+      extend ActiveSupport::Autoload
+      
+      autoload :HasOne
+      autoload :HasMany
+
+      included do
+        class_inheritable_accessor :associations
+        self.associations = {}
+
+        include MongoODM::Document::Associations::HasOne
+        include MongoODM::Document::Associations::HasMany
+      end
+    
+      module InstanceMethods
+        def associations
+          self.class.associations
+        end
+      end
+    
+      module ClassMethods
+        def associate(type, options)
+          name = options.name.to_s
+          associations[name] = MetaData.new(type, options)
+          define_method(name) { memoized(name) { type.instantiate(self, options) } }
+          define_method("#{name}=") { |object| reset(name) { type.update(object, self, options) } }
+        end
+        protected :associate
+      end
+    
+    end
+  end
+end

data/lib/mongo_odm/document/associations/has_many.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+module MongoODM
+  module Document
+    module Associations
+      module HasMany
+
+        extend ActiveSupport::Concern
+    
+        module ClassMethods
+          def has_many
+            
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/mongo_odm/document/associations/has_one.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+module MongoODM
+  module Document
+    module Associations
+      module HasOne
+
+        extend ActiveSupport::Concern
+    
+        module ClassMethods
+          def has_one
+            
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/mongo_odm/document/attribute_methods.rb

@@ -0,0 +1,103 @@
+# encoding: utf-8
+require 'active_support/core_ext/hash/indifferent_access'
+
+module MongoODM
+  module Document
+    module AttributeMethods
+
+      extend ActiveSupport::Concern
+      extend ActiveSupport::Autoload
+      
+      autoload :Read
+      autoload :Write
+      autoload :Query
+      autoload :Dirty
+      autoload :Localization
+
+      included do
+        include ActiveModel::AttributeMethods
+        include MongoODM::Document::AttributeMethods::Read
+        include MongoODM::Document::AttributeMethods::Write
+        include MongoODM::Document::AttributeMethods::Query
+        include MongoODM::Document::AttributeMethods::Dirty
+        include MongoODM::Document::AttributeMethods::Localization
+      end
+
+      module InstanceMethods
+        attr_reader :attributes
+
+        def initialize(attrs = {})
+          @attributes = {:_class => self.class.name}.with_indifferent_access
+          load_attributes_or_defaults(attrs)
+          self
+        end
+
+        def force_attributes=(new_attributes)
+          send(:attributes=, new_attributes, true)
+        end
+
+        def attributes=(new_attributes, auto_generate_attributes = false)
+          return if new_attributes.blank?
+          new_attributes.each do |name, value|
+            if respond_to?(:"#{name}=")
+              send(:"#{name}=", value)
+            else
+              auto_generate_attributes ? write_attribute(name, value) : raise(MongoODM::Errors::UnknownFieldError, "unknown field: #{name}")
+            end
+          end
+        end
+
+        def freeze
+          @attributes.freeze; super
+        end
+
+        def has_attribute?(name)
+          @attributes.has_key?(name)
+        end
+      
+        def load_attributes_or_defaults(attrs)
+          attrs = self.class.default_attributes.merge(attrs)
+          self.force_attributes = attrs
+        end
+      
+        def remove_attribute(name)
+          @attributes.delete(name)
+        end
+
+        def method_missing(method_id, *args, &block)
+          # If we haven't generated any methods yet, generate them, then
+          # see if we've created the method we're looking for.
+          if !self.class.attribute_methods_generated?
+            self.class.define_attribute_methods_for_fields
+            method_name = method_id.to_s
+            guard_private_attribute_method!(method_name, args)
+            send(method_id, *args, &block)
+          else
+            super
+          end
+        end
+        
+        def respond_to?(*args)
+          self.class.define_attribute_methods_for_fields
+          super
+        end
+        
+        def attribute_method?(attr_name)
+          attr_name == '_id' || attributes.include?(attr_name)
+        end
+        protected :attribute_method?
+      end
+    
+      module ClassMethods
+        def default_attributes
+          HashWithIndifferentAccess[fields.values.map{|field| [field.name, field.default]}]
+        end
+        
+        def define_attribute_methods_for_fields
+          define_attribute_methods(fields.keys + [:_id, :_class])
+        end
+      end
+    
+    end
+  end
+end