mongomodel 0.1

data/lib/mongomodel/concerns/logging.rb

@@ -0,0 +1,15 @@
+module MongoModel
+  module Logging
+    extend ActiveSupport::Concern
+    
+    module ClassMethods
+      def logger
+        MongoModel.logger
+      end
+    end
+    
+    def logger
+      self.class.logger
+    end
+  end
+end

data/lib/mongomodel/concerns/pretty_inspect.rb

@@ -0,0 +1,29 @@
+module MongoModel
+  module PrettyInspect
+    extend ActiveSupport::Concern
+  
+    module ClassMethods
+      # Returns a string like 'Post(title:String, body:String)'
+      def inspect
+        if [Document, EmbeddedDocument].include?(self)
+          super
+        else
+          attr_list = model_properties.map { |name, property| "#{name}: #{property.type.inspect}" } * ', '
+          "#{super}(#{attr_list})"
+        end
+      end
+    end
+  
+    # Returns the contents of the document as a nicely formatted string.
+    def inspect
+      "#<#{self.class.name} #{attributes_for_inspect}>"
+    end
+  
+  private
+    def attributes_for_inspect
+      attrs = self.class.model_properties.map { |name, property| "#{name}: #{send(name).inspect}" }
+      attrs.unshift "id: #{id}" if self.class.properties.include?(:id)
+      attrs * ', '
+    end
+  end
+end

data/lib/mongomodel/concerns/properties.rb

@@ -0,0 +1,69 @@
+require 'active_support/core_ext/class/inheritable_attributes'
+require 'active_support/core_ext/module/delegation'
+require 'active_support/core_ext/array/extract_options'
+require 'active_support/core_ext/hash/except'
+
+module MongoModel
+  module Properties
+    extend ActiveSupport::Concern
+    
+    included do
+      class_inheritable_accessor :properties
+      self.properties = ActiveSupport::OrderedHash.new
+    end
+    
+    module ClassMethods
+      def property(name, type, options={})
+        properties[name.to_sym] = Property.new(name, type, options)
+      end
+      
+      def model_properties
+        properties.reject { |k, p| p.internal? }
+      end
+    end
+  
+    class Property
+      delegate :cast, :boolean, :to_mongo, :from_mongo, :to => :type_converter
+      
+      attr_reader :name, :type, :options
+    
+      def initialize(name, type, options={})
+        @name, @type, @options = name.to_sym, type, options
+      end
+    
+      def as
+        options[:as] || name.to_s
+      end
+    
+      def default(instance)
+        default = options[:default]
+        
+        if default.respond_to?(:call)
+          case default.arity
+          when 0 then default.call
+          else        default.call(instance)
+          end
+        else
+          default.duplicable? ? default.dup : default
+        end
+      end
+    
+      def ==(other)
+        other.is_a?(self.class) && name == other.name && type == other.type && options == other.options
+      end
+      
+      def embeddable?
+        type.ancestors.include?(EmbeddedDocument)
+      end
+      
+      def internal?
+        as =~ /^_/ || options[:internal]
+      end
+      
+    private
+      def type_converter
+        @type_converter ||= Types.converter_for(type)
+      end
+    end
+  end
+end

data/lib/mongomodel/concerns/record_status.rb

@@ -0,0 +1,42 @@
+require 'active_support/core_ext/module/aliasing'
+
+module MongoModel
+  module RecordStatus
+    extend ActiveSupport::Concern
+    
+    included do
+      alias_method_chain :initialize, :record_status
+    end
+    
+    def new_record?
+      @_new_record
+    end
+    
+    def destroyed?
+      @_destroyed
+    end
+    
+    def initialize_with_record_status(*args, &block)
+      set_new_record(true)
+      set_destroyed(false)
+      
+      initialize_without_record_status(*args, &block)
+    end
+    
+  protected
+    def set_new_record(value)
+      set_record_status(:new_record, value)
+    end
+    
+    def set_destroyed(value)
+      set_record_status(:destroyed, value)
+    end
+  
+  private
+    def set_record_status(type, value)
+      instance_variable_set("@_#{type}", value)
+      embedded_documents.each { |doc| doc.send(:set_record_status, type, value) }
+      value
+    end
+  end
+end

data/lib/mongomodel/concerns/timestamps.rb

@@ -0,0 +1,32 @@
+module MongoModel
+  # MongoModel automatically timestamps create and update operations if the document has properties
+  # named created_at/created_on or updated_at/updated_on.
+  module Timestamps #:nodoc:
+    extend ActiveSupport::Concern
+    
+    included do
+      before_save   :set_update_timestamps
+      before_create :set_create_timestamps
+    end
+    
+    module ClassMethods
+      # Defines timestamp properties created_at and updated_at.
+      # When the document is created or updated, these properties will be respectively updated.
+      def timestamps!
+        property :created_at, Time
+        property :updated_at, Time
+      end
+    end
+  
+  private
+    def set_update_timestamps
+      write_attribute(:updated_at, Time.now) if properties.include?(:updated_at)
+      write_attribute(:updated_on, Time.now) if properties.include?(:updated_on)
+    end
+    
+    def set_create_timestamps
+      write_attribute(:created_at, Time.now) if properties.include?(:created_at) && !query_attribute(:created_at)
+      write_attribute(:created_on, Time.now) if properties.include?(:created_on) && !query_attribute(:created_on)
+    end
+  end
+end

data/lib/mongomodel/concerns/validations.rb

@@ -0,0 +1,38 @@
+module MongoModel
+  module Validations
+    extend ActiveSupport::Concern
+    
+    include ActiveModel::Validations
+    
+    module ClassMethods
+      def property(name, *args, &block) #:nodoc:
+        property = super
+        
+        validates_associated(name) if property.embeddable?
+        validates_presence_of(name) if property.options[:required]
+        validates_format_of(name, property.options[:format]) if property.options[:format]
+        
+        property
+      end
+      
+      # Set the i18n scope to overwrite ActiveModel.
+      def i18n_scope #:nodoc:
+        :mongomodel
+      end
+    end
+    
+    def valid?
+      errors.clear
+      
+      @_on_validate = new_record? ? :create : :update
+      run_callbacks(:validate)
+      
+      errors.empty?
+    end
+  end
+end
+
+Dir[File.dirname(__FILE__) + "/validations/*.rb"].sort.each do |path|
+  filename = File.basename(path)
+  require "mongomodel/concerns/validations/#{filename}"
+end

data/lib/mongomodel/concerns/validations/associated.rb

@@ -0,0 +1,46 @@
+module MongoModel
+  module Validations
+    module ClassMethods
+      # Validates whether the associated object or objects are all valid themselves. Works with any kind of association.
+      #
+      #   class Book < MongoModel::Document
+      #     has_many :pages
+      #     belongs_to :library
+      #
+      #     validates_associated :pages, :library
+      #   end
+      #
+      # Warning: If, after the above definition, you then wrote:
+      #
+      #   class Page < MongoModel::Document
+      #     belongs_to :book
+      #
+      #     validates_associated :book
+      #   end
+      #
+      # this would specify a circular dependency and cause infinite recursion.
+      #
+      # NOTE: This validation will not fail if the association hasn't been assigned. If you want to ensure that the association
+      # is both present and guaranteed to be valid, you also need to use +validates_presence_of+.
+      #
+      # Configuration options:
+      # * <tt>:message</tt> - A custom error message (default is: "is invalid")
+      # * <tt>:on</tt> - Specifies when this validation is active (default is <tt>:save</tt>, other options <tt>:create</tt>, <tt>:update</tt>).
+      # * <tt>:if</tt> - Specifies a method, proc or string to call to determine if the validation should
+      #   occur (e.g. <tt>:if => :allow_validation</tt>, or <tt>:if => Proc.new { |user| user.signup_step > 2 }</tt>).  The
+      #   method, proc or string should return or evaluate to a true or false value.
+      # * <tt>:unless</tt> - Specifies a method, proc or string to call to determine if the validation should
+      #   not occur (e.g. <tt>:unless => :skip_validation</tt>, or <tt>:unless => Proc.new { |user| user.signup_step <= 2 }</tt>).  The
+      #   method, proc or string should return or evaluate to a true or false value.
+      def validates_associated(*attr_names)
+        configuration = attr_names.extract_options!
+
+        validates_each(attr_names, configuration) do |record, attr_name, value|
+          unless (value.is_a?(Array) ? value : [value]).collect { |r| r.nil? || r.valid? }.all?
+            record.errors.add(attr_name, :invalid, :default => configuration[:message], :value => value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongomodel/document.rb

@@ -0,0 +1,20 @@
+require 'active_support/core_ext/hash/reverse_merge'
+require 'active_support/core_ext/hash/deep_merge'
+require 'active_support/core_ext/string/inflections'
+
+module MongoModel
+  class Document < EmbeddedDocument
+    include DocumentExtensions::Persistence
+    include DocumentExtensions::OptimisticLocking
+    
+    extend  DocumentExtensions::Finders
+    extend  DocumentExtensions::DynamicFinders
+    include DocumentExtensions::Indexes
+    
+    include DocumentExtensions::Scopes
+    include DocumentExtensions::Validations
+    include DocumentExtensions::Callbacks
+    
+    self.abstract_class = true
+  end
+end

data/lib/mongomodel/document/callbacks.rb

@@ -0,0 +1,46 @@
+module MongoModel
+  module DocumentExtensions
+    module Callbacks
+      extend ActiveSupport::Concern
+      
+      included do
+        [:instantiate, :create_or_update, :create, :update, :destroy].each do |method|
+          alias_method_chain method, :callbacks
+        end
+      end
+      
+      def instantiate_with_callbacks(*args) #:nodoc:
+        instantiate_without_callbacks(*args)
+        run_callbacks_with_embedded(:find)
+      end
+      private :instantiate_with_callbacks
+
+      def create_or_update_with_callbacks #:nodoc:
+        run_callbacks_with_embedded(:save) do
+          create_or_update_without_callbacks
+        end
+      end
+      private :create_or_update_with_callbacks
+
+      def create_with_callbacks #:nodoc:
+        run_callbacks_with_embedded(:create) do
+          create_without_callbacks
+        end
+      end
+      private :create_with_callbacks
+
+      def update_with_callbacks(*args) #:nodoc:
+        run_callbacks_with_embedded(:update) do
+          update_without_callbacks(*args)
+        end
+      end
+      private :update_with_callbacks
+
+      def destroy_with_callbacks #:nodoc:
+        run_callbacks_with_embedded(:destroy) do
+          destroy_without_callbacks
+        end
+      end
+    end
+  end
+end

data/lib/mongomodel/document/dynamic_finders.rb

@@ -0,0 +1,88 @@
+module MongoModel
+  module DocumentExtensions
+    module DynamicFinders
+      def respond_to?(method_id, include_private = false)
+        if DynamicFinder.match(self, method_id)
+          true
+        else
+          super
+        end
+      end
+      
+      def method_missing(method_id, *args, &block)
+        if finder = DynamicFinder.match(self, method_id)
+          finder.execute(*args)
+        else
+          super
+        end
+      end
+    end
+    
+    class DynamicFinder
+      def initialize(model, attribute_names, finder=:first, bang=false)
+        @model, @attribute_names, @finder, @bang = model, attribute_names, finder, bang
+      end
+      
+      def execute(*args)
+        options = args.extract_options!
+        conditions = build_conditions(args)
+        
+        result = @model.send(instantiator? ? :first : @finder, options.deep_merge(:conditions => conditions))
+        
+        if result.nil?
+          if bang?
+            raise DocumentNotFound, "Couldn't find #{@model.to_s} with #{conditions.inspect}"
+          elsif instantiator?
+            return @model.send(@finder, conditions)
+          end
+        end
+        
+        result
+      end
+      
+      def bang?
+        @bang
+      end
+      
+      def instantiator?
+        @finder == :new || @finder == :create
+      end
+      
+      def self.match(model, method)
+        finder = :first
+        bang = false
+        
+        case method.to_s
+        when /^find_(all_by|last_by|by)_([_a-zA-Z]\w*)$/
+          finder = :last if $1 == 'last_by'
+          finder = :all if $1 == 'all_by'
+          names = $2
+        when /^find_by_([_a-zA-Z]\w*)\!$/
+          bang = true
+          names = $1
+        when /^find_or_(initialize|create)_by_([_a-zA-Z]\w*)$/
+          finder = ($1 == 'initialize' ? :new : :create)
+          names = $2
+        else
+          return nil
+        end
+        
+        names = names.split('_and_')
+        if names.all? { |n| model.properties.include?(n.to_sym) }
+          new(model, names, finder, bang)
+        end
+      end
+    
+    private
+      def build_conditions(args)
+        result = {}
+        
+        @attribute_names.zip(args) do |attribute, value|
+          result[attribute.to_sym] = value
+        end
+        
+        result
+      end
+    end
+  end
+end

data/lib/mongomodel/document/finders.rb

@@ -0,0 +1,82 @@
+require 'active_support/core_ext/hash/keys'
+
+module MongoModel
+  module DocumentExtensions
+    module Finders
+      def find(*args)
+        options = args.extract_options!
+      
+        case args.first
+        when :first then find_first(options)
+        when :last then  find_last(options)
+        when :all then   find_all(options)
+        else             find_by_ids(args, options)
+        end
+      end
+    
+      def first(options={})
+        find(:first, options)
+      end
+    
+      def last(options={})
+        find(:last, options)
+      end
+    
+      def all(options={})
+        find(:all, options)
+      end
+    
+      def count(conditions={})
+        _find(:conditions => conditions).count
+      end
+    
+      def exists?(id_or_conditions)
+        case id_or_conditions
+        when String
+          exists?(:id => id_or_conditions)
+        else
+          count(id_or_conditions) > 0
+        end
+      end
+  
+    private
+      def find_first(options={})
+        _find_and_instantiate(options.merge(:limit => 1)).first
+      end
+    
+      def find_last(options={})
+        order = MongoOrder.parse(options[:order]) || :id.asc
+        _find_and_instantiate(options.merge(:order => order.reverse, :limit => 1)).first
+      end
+    
+      def find_all(options={})
+        _find_and_instantiate(options)
+      end
+    
+      def find_by_ids(ids, options={})
+        ids.flatten!
+      
+        case ids.size
+        when 0
+          raise ArgumentError, "At least one id must be specified"
+        when 1
+          id = ids.first.to_s
+          _find_and_instantiate(options.deep_merge(:conditions => { :id => id })).first || raise(DocumentNotFound, "Couldn't find document with id: #{id}")
+        else
+          docs = _find_and_instantiate(options.deep_merge(:conditions => { :id.in => ids.map { |id| id.to_s } }))
+          raise DocumentNotFound if docs.size != ids.size
+          docs.sort_by { |doc| ids.index(doc.id) }
+        end
+      end
+    
+      def _find(options={})
+        selector, options = MongoOptions.new(self, options).to_a
+        collection.find(selector, options)
+      end
+    
+      def _find_and_instantiate(options={})
+        _find(options).to_a.map { |doc| from_mongo(doc) }
+      end
+    end
+  end
+end