mongo_odm 0.1.8

data/lib/mongo_odm/document/attribute_methods/dirty.rb

@@ -0,0 +1,51 @@
+# encoding: utf-8
+require 'active_support/core_ext/module/aliasing'
+
+module MongoODM
+  module Document
+    module AttributeMethods
+      module Dirty
+
+        extend ActiveSupport::Concern
+
+        included do
+          include ActiveModel::Dirty
+
+          alias_method_chain :initialize, :dirty
+          alias_method_chain :write_attribute, :dirty
+          alias_method_chain :save, :dirty
+          alias_method_chain :reload, :dirty
+        end
+    
+        module InstanceMethods
+          def initialize_with_dirty(*args)
+            initialize_without_dirty(*args)
+            changed_attributes.clear
+            self
+          end
+        
+          def write_attribute_with_dirty(attr_name, value)
+            send("#{attr_name}_will_change!") if respond_to?("#{attr_name}_will_change!")
+            write_attribute_without_dirty(attr_name, value)
+          end
+      
+          def save_with_dirty(*args)
+            if status = save_without_dirty(*args)
+              @previously_changed = changes
+              changed_attributes.clear
+            end
+            status
+          end
+      
+          def reload_with_dirty(*args)
+            reload_without_dirty(*args).tap do
+              previously_changed_attributes.clear
+              changed_attributes.clear
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/mongo_odm/document/attribute_methods/localization.rb

@@ -0,0 +1,67 @@
+# encoding: utf-8
+require 'active_support/core_ext/hash/indifferent_access'
+
+module MongoODM
+  module Document
+    module AttributeMethods
+      module Localization
+
+        extend ActiveSupport::Concern
+
+        included do
+          attribute_method_suffix "_localized?"
+          attribute_method_suffix "_without_localization"
+
+          alias_method_chain :read_attribute, :localization
+          alias_method_chain :write_attribute, :localization
+          alias_method_chain :inspect, :localization
+        end
+        
+        module ClassMethods
+          def define_method_attribute_localized?(attr_name)
+            generated_attribute_methods.module_eval("def #{attr_name}_localized?; localized_attribute?('#{attr_name}'); end", __FILE__, __LINE__)
+          end
+          protected :define_method_attribute_localized?
+          
+          def define_method_attribute_without_localization(attr_name)
+            generated_attribute_methods.module_eval("def #{attr_name}_without_localization; read_attribute_without_localization('#{attr_name}'); end", __FILE__, __LINE__)
+          end
+          protected :define_method_attribute_localized?
+        end
+
+        module InstanceMethods
+          def localized_attribute?(attr_name)
+            field = self.class.fields[attr_name]
+            localized = field ? !!field.options[:localized] : false
+            raise MongoODM::Errors::InvalidLocalizedField.new(field.name, field.type) if localized && field && field.type != Hash
+            localized
+          end
+          
+          def read_attribute_with_localization(attr_name, locale = nil)
+            if localized_attribute?(attr_name)
+              locale = I18n.locale || I18n.default_locale if locale.nil?
+              (read_attribute_without_localization(attr_name) || {}.with_indifferent_access)[locale]
+            else
+              read_attribute_without_localization(attr_name)
+            end
+          end
+
+          def write_attribute_with_localization(attr_name, value, locale = nil)
+            if localized_attribute?(attr_name)
+              locale = I18n.locale || I18n.default_locale if locale.nil?
+              current_value = read_attribute_without_localization(attr_name) || {}.with_indifferent_access
+              write_attribute_without_localization(attr_name, current_value.merge(locale => value))
+            else
+              write_attribute_without_localization(attr_name, value)
+            end
+          end
+          
+          def inspect_with_localization
+            "#<#{self.class.name} #{attributes.except(*private_attribute_names).keys.map{|k| "#{localized_attribute?(k) ? "#{k}[#{I18n.locale}]" : k}: #{read_attribute(k).inspect}"}.join(", ")}>"
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/mongo_odm/document/attribute_methods/query.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+module MongoODM
+  module Document
+    module AttributeMethods
+      module Query
+
+        extend ActiveSupport::Concern
+        
+        included do
+          attribute_method_suffix "?"
+        end
+
+        module ClassMethods
+          def define_method_attribute?(attr_name)
+            generated_attribute_methods.module_eval("def #{attr_name}?; query_attribute('#{attr_name}'); end", __FILE__, __LINE__)
+          end
+          protected :define_method_attribute?
+        end
+
+        module InstanceMethods
+          def query_attribute(attr_name)
+            !!@attributes[attr_name]
+          end
+
+          def attribute?(attr_name)
+            query_attribute(attr_name)
+          end
+          private :attribute?
+        end
+
+      end
+    end
+  end
+end

data/lib/mongo_odm/document/attribute_methods/read.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+
+module MongoODM
+  module Document
+    module AttributeMethods
+      module Read
+
+        extend ActiveSupport::Concern
+        
+        included do
+          attribute_method_suffix ""
+        end
+
+        module ClassMethods
+          def define_method_attribute(attr_name)
+            generated_attribute_methods.module_eval("def #{attr_name}; read_attribute('#{attr_name}'); end", __FILE__, __LINE__)
+          end
+          protected :define_method_attribute
+        end
+
+        module InstanceMethods
+          def read_attribute(attr_name)
+            @attributes[attr_name]
+          end
+          
+          def [](attr_name)
+            read_attribute[attr_name]
+          end
+
+          def attribute(attr_name)
+            read_attribute(attr_name)
+          end
+          private :attribute
+        end
+
+      end
+    end
+  end
+end

data/lib/mongo_odm/document/attribute_methods/write.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+module MongoODM
+  module Document
+    module AttributeMethods
+      module Write
+
+        extend ActiveSupport::Concern
+        
+        included do
+          attribute_method_suffix "="
+        end
+
+        module ClassMethods
+          def define_method_attribute=(attr_name)
+            generated_attribute_methods.module_eval("def #{attr_name}=(new_value); write_attribute('#{attr_name}', new_value); end", __FILE__, __LINE__)
+          end
+          protected :define_method_attribute=
+        end
+
+        module InstanceMethods          
+          def write_attribute(attr_name, value)
+            field = self.class.fields[attr_name]
+            type = field ? field.type : value.class
+            @attributes[attr_name] = attr_name.to_sym == :_id ? value : type.type_cast(value)
+          end
+
+          def attribute=(attr_name, value)
+            write_attribute(attr_name, value)
+          end
+          private :attribute=
+        end
+
+      end
+    end
+  end
+end

data/lib/mongo_odm/document/callbacks.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+require 'active_support/core_ext/module/aliasing'
+
+module MongoODM
+  module Document
+    module Callbacks
+
+      extend ActiveSupport::Concern
+
+      included do
+        extend ActiveModel::Callbacks
+
+        alias_method_chain :initialize, :callbacks
+
+        define_model_callbacks :initialize, :only => :after
+        define_model_callbacks :save, :destroy
+      end
+      
+      module InstanceMethods
+        def initialize_with_callbacks(*args)
+          initialize_without_callbacks(*args)
+          _run_initialize_callbacks
+          self
+        end
+      end
+
+    end
+  end
+end

data/lib/mongo_odm/document/fields.rb

@@ -0,0 +1,66 @@
+# encoding: utf-8
+require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/core_ext/hash/keys'
+require 'mongo_odm/core_ext/conversions'
+
+module MongoODM
+  module Document
+    module Fields
+
+      extend ActiveSupport::Concern
+
+      class Field
+        # @return [Symbol] the name of this field in the Document.
+        attr_reader :name
+        # @return [Class] the Ruby type of field.
+        attr_reader :type
+        # @return [Hash] configuration options.
+        attr_reader :options
+
+        # Creates a new document field.
+        # @param [String, Symbol] name the name of the field.
+        # @param [Class] type the Ruby type of the field. It should respond to 'type_cast'. Use {Boolean} for true or false types.
+        # @param [Hash] options configuration options.
+        # @option options [Object, Proc] :default (nil) a default value for the field, or a lambda to evaluate when providing the default.
+        def initialize(name, type, options = {})
+          @options = options.to_options
+          @name = name.to_sym
+          @type = type
+        end
+
+        # @return [Object] The default value for this field if defined, or nil.
+        def default
+          if default = options[:default]
+            type_cast(default.respond_to?(:call) ? default.call : default)
+          end
+        end
+
+        # Attempt to coerce the passed value into this field's type
+        # @param [Object] value the value to coerce
+        # @return [Object] the value coerced into this field's type
+        # @raise [MongoODM::Errors::TypeCastMissing] if the value cannot be coerced into the field's type
+        def type_cast(value)
+          raise MongoODM::Errors::TypeCastMissing.new(value, @type) unless @type.respond_to?(:type_cast)
+          @type.type_cast(value)
+        end
+      end
+
+      module ClassMethods
+        def inherited(subclass)
+          super
+          subclass.fields.merge!(fields)
+        end
+
+        def fields
+          @fields ||= {}.with_indifferent_access
+        end
+
+        def field(name, type = String, options = {})
+          fields[name] = Field.new(name, type, options)
+          fields[name]
+        end
+      end
+
+    end
+  end
+end

data/lib/mongo_odm/document/inspect.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+require 'active_support/core_ext/hash/except'
+
+module MongoODM
+  module Document
+    module Inspect
+
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def inspect
+          "#{name}(#{fields.map{|k, v| "#{k}: #{v.type}"}.join(", ")})"
+        end
+      end
+    
+      module InstanceMethods
+        def private_attribute_names
+          %w(_class)
+        end
+      
+        def inspect
+          "#<#{self.class.name} #{attributes.except(*private_attribute_names).keys.map{|k| "#{k}: #{read_attribute(k).inspect}"}.join(", ")}>"
+        end
+      end
+
+    end
+  end
+end

data/lib/mongo_odm/document/persistence.rb

@@ -0,0 +1,96 @@
+# encoding: utf-8
+require 'active_support/core_ext/string/inflections'
+require 'forwardable'
+
+module MongoODM
+  module Document
+    module Persistence
+      
+      extend ActiveSupport::Concern
+
+      module InstanceMethods
+        def id
+          attributes[:_id]
+        end
+
+        def new_record?
+          id.nil?
+        end
+      
+        def reload
+          self.load_attributes_or_defaults(self.class.find_one(:_id => id).attributes) unless new_record?
+        end
+      
+        # Save a document to its collection.
+        #
+        # @return [ObjectID] the _id of the saved document.
+        #
+        # @option opts [Boolean] :safe (+false+) 
+        #   If true, check that the save succeeded. OperationFailure
+        #   will be raised on an error. Note that a safe check requires an extra
+        #   round-trip to the database.
+        def save(options = {})
+          _run_save_callbacks do
+            write_attribute(:_id, self.class.save(to_mongo, options))
+          end
+        end
+      
+        def update_attributes(attributes)
+          self.attributes = attributes
+          save
+        end
+        
+        def destroy
+          return false if new_record?
+          _run_destroy_callbacks do
+            self.class.remove({ :_id => self.id })
+          end
+        end
+      
+        def to_mongo
+          attributes.inject({}.with_indifferent_access) do |attrs, (key, value)|
+            attrs[key] = value.to_mongo unless value.nil?
+            attrs
+          end
+        end
+      end
+    
+      module ClassMethods
+        def collection
+          @collection ||= MongoODM::Collection.new(MongoODM.database, name.tableize)
+        end
+      
+        def set_collection(name_or_collection)
+          @collection = case name_or_collection
+                        when MongoODM::Collection
+                          name_or_collection
+                        when String, Symbol
+                          MongoODM::Collection.new(MongoODM.database, name_or_collection)
+                        else
+                          raise "MongoODM::Collection instance or valid collection name required"
+                        end
+        end
+        
+        def destroy_all(*args)
+          documents = find(*args)
+          count = documents.count
+          documents.each { |doc| doc.destroy }
+          count
+        end
+      
+        def type_cast(value)
+          return nil if value.nil?
+          return value if value.class == self
+          new(value)
+        end
+
+        extend Forwardable
+        def_delegators :collection, :db, :hint, :hint=, :pk_factory, :[], :count, :create_index, :distinct,
+                       :drop, :drop_index, :drop_indexes, :find, :find_and_modify, :find_one, :group,
+                       :index_information, :insert, :<<, :map_reduce, :mapreduce, :options, :remove, :rename,
+                       :save, :stats, :update
+      end
+
+    end
+  end
+end