mongomodel 0.1

data/lib/mongomodel/document/validations/uniqueness.rb

@@ -0,0 +1,78 @@
+module MongoModel
+  module DocumentExtensions
+    module Validations
+      module ClassMethods
+        # Validates whether the value of the specified attributes are unique across the system. Useful for making sure that only one user
+        # can be named "davidhh".
+        #
+        #   class Person < MongoModel::Document
+        #     validates_uniqueness_of :user_name, :scope => :account_id
+        #   end
+        #
+        # It can also validate whether the value of the specified attributes are unique based on multiple scope parameters. For example,
+        # making sure that a teacher can only be on the schedule once per semester for a particular class.
+        #
+        #   class TeacherSchedule < MongoModel::Document
+        #     validates_uniqueness_of :teacher_id, :scope => [:semester_id, :class_id]
+        #   end
+        #
+        # When the document is created, a check is performed to make sure that no document exists in the database with the given value for the specified
+        # attribute (that maps to a property). When the document is updated, the same check is made but disregarding the document itself.
+        #
+        # Configuration options:
+        # * <tt>:message</tt> - Specifies a custom error message (default is: "has already been taken").
+        # * <tt>:scope</tt> - One or more properties by which to limit the scope of the uniqueness constraint.
+        # * <tt>:case_sensitive</tt> - Looks for an exact match. Ignored by non-text columns (+true+ by default).
+        # * <tt>:allow_nil</tt> - If set to true, skips this validation if the attribute is +nil+ (default is +false+).
+        # * <tt>:allow_blank</tt> - If set to true, skips this validation if the attribute is blank (default is +false+).
+        # * <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.
+        #
+        # === Concurrency and integrity
+        #
+        # Note that this validation method does not have the same race condition suffered by ActiveRecord and other ORMs.
+        # A unique index is added to the collection to ensure that the collection never ends up in an invalid state.
+        def validates_uniqueness_of(*attr_names)
+          configuration = { :case_sensitive => true }
+          configuration.update(attr_names.extract_options!)
+          
+          # Enable safety checks on save
+          self.save_safely = true
+          
+          # Create unique indexes to deal with race condition
+          attr_names.each do |attr_name|
+            if configuration[:case_sensitive]
+              index *[attr_name] + Array(configuration[:scope]) << { :unique => true }
+            else
+              lowercase_key = "_lowercase_#{attr_name}"
+              before_save { attributes[lowercase_key] = send(attr_name).downcase }
+              index *[lowercase_key] + Array(configuration[:scope]) << { :unique => true }
+            end
+          end
+          
+          validates_each(attr_names, configuration) do |record, attr_name, value|
+            if configuration[:case_sensitive] || !value.is_a?(String)
+              conditions = { attr_name => value }
+            else
+              conditions = { "_lowercase_#{attr_name}" => value.downcase }
+            end
+            
+            Array(configuration[:scope]).each do |scope|
+              conditions[scope] = record.send(scope)
+            end
+            
+            conditions.merge!(:id.ne => record.id) unless record.new_record?
+            
+            if exists?(conditions)
+              record.errors.add(attr_name, :taken, :default => configuration[:message], :value => value)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongomodel/embedded_document.rb

@@ -0,0 +1,42 @@
+module MongoModel
+  class EmbeddedDocument
+    def to_param
+      id
+    end
+    
+    def ==(other)
+      other.is_a?(self.class) && other.attributes == attributes
+    end
+    
+    include Attributes
+    include Properties
+    
+    include Validations
+    include Callbacks
+    
+    include Associations
+    
+    include AttributeMethods
+    include AttributeMethods::Read
+    include AttributeMethods::Write
+    include AttributeMethods::Query
+    include AttributeMethods::BeforeTypeCast
+    include AttributeMethods::Protected
+    include AttributeMethods::Dirty
+    
+    include Logging
+    include RecordStatus
+    include ActiveModelCompatibility
+    include Timestamps
+    include PrettyInspect
+    include AbstractClass
+    
+    # Allow Collection class to be used in property definitions
+    Collection = MongoModel::Collection
+    
+    undef_method :type if method_defined?(:type)
+    property :type, String, :as => '_type', :default => lambda { |doc| doc.class.name }, :protected => true
+    
+    self.abstract_class = true
+  end
+end

data/lib/mongomodel/locale/en.yml

@@ -0,0 +1,55 @@
+en:
+  mongomodel:
+    errors:
+      # The values :model, :attribute and :value are always available for interpolation
+      # The value :count is available when applicable. Can be used for pluralization.
+      messages:
+        inclusion: "is not included in the list"
+        exclusion: "is reserved"
+        invalid: "is invalid"
+        confirmation: "doesn't match confirmation"
+        accepted: "must be accepted"
+        empty: "can't be empty"
+        blank: "can't be blank"
+        too_long: "is too long (maximum is {{count}} characters)"
+        too_short: "is too short (minimum is {{count}} characters)"
+        wrong_length: "is the wrong length (should be {{count}} characters)"
+        taken: "has already been taken"
+        not_a_number: "is not a number"
+        greater_than: "must be greater than {{count}}"
+        greater_than_or_equal_to: "must be greater than or equal to {{count}}"
+        equal_to: "must be equal to {{count}}"
+        less_than: "must be less than {{count}}"
+        less_than_or_equal_to: "must be less than or equal to {{count}}"
+        odd: "must be odd"
+        even: "must be even"
+        document_invalid: "Validation failed: {{errors}}"
+        # Append your own errors here or at the model/attributes scope.
+
+        # You can define own errors for models or model attributes.
+        # The values :model, :attribute and :value are always available for interpolation.
+        #
+        # For example,
+        #   models:
+        #     user:
+        #       blank: "This is a custom blank message for {{model}}: {{attribute}}"
+        #       attributes:
+        #         login:
+        #           blank: "This is a custom blank message for User login"
+        # Will define custom blank validation message for User model and
+        # custom blank validation message for login attribute of User model.
+        #models:
+
+        # Translate model names. Used in Model.human_name().
+        #models:
+          # For example,
+          #   user: "Dude"
+          # will translate User model name to "Dude"
+
+        # Translate model attribute names. Used in Model.human_attribute_name(attribute).
+        #attributes:
+          # For example,
+          #   user:
+          #     login: "Handle"
+          # will translate User attribute "login" as "Handle"
+          

data/lib/mongomodel/support/collection.rb

@@ -0,0 +1,109 @@
+module MongoModel
+  class Collection < Array
+    ARRAY_CONVERTER = Types.converter_for(Array)
+    
+    class_inheritable_accessor :type
+    self.type = Object
+    
+    def initialize(array=[])
+      super(array.map { |i| convert(i) })
+    end
+    
+    def []=(index, value)
+      super(index, convert(value))
+    end
+    
+    def <<(value)
+      super(convert(value))
+    end
+    
+    def +(other)
+      self.class.new(super(other))
+    end
+    
+    def concat(values)
+      super(values.map { |v| convert(v) })
+    end
+    
+    def delete(value)
+      super(convert(value))
+    end
+    
+    def include?(value)
+      super(convert(value))
+    end
+    
+    def index(value)
+      super(convert(value))
+    end
+    
+    def insert(index, value)
+      super(index, convert(value))
+    end
+    
+    def push(*values)
+      super(*values.map { |v| convert(v) })
+    end
+    
+    def rindex(value)
+      super(convert(value))
+    end
+    
+    def unshift(*values)
+      super(*values.map { |v| convert(v) })
+    end
+    
+    def to_mongo
+      ARRAY_CONVERTER.to_mongo(self)
+    end
+    
+    def embedded_documents
+      select { |item| item.is_a?(EmbeddedDocument) }
+    end
+    
+    class << self
+      def inspect
+        if type == Object
+          "Collection"
+        else
+          "Collection[#{type}]"
+        end
+      end
+    
+      def [](type)
+        @collection_class_cache ||= {}
+        @collection_class_cache[type] ||= begin
+          collection = Class.new(Collection)
+          collection.type = type
+          collection
+        end
+      end
+      
+      def from_mongo(array)
+        new(array.map { |i| instantiate(i) })
+      end
+    
+      def converter
+        @converter ||= Types.converter_for(type)
+      end
+    
+    private
+      def instantiate(item)
+        if item.is_a?(Hash) && item['_type']
+          item['_type'].constantize.from_mongo(item)
+        else
+          converter.from_mongo(item)
+        end
+      end
+    end
+  
+  private
+    def convert(value)
+      converter.cast(value)
+    end
+    
+    def converter
+      self.class.converter
+    end
+  end
+end

data/lib/mongomodel/support/configuration.rb

@@ -0,0 +1,35 @@
+require 'active_support/core_ext/hash/keys'
+
+module MongoModel
+  class Configuration
+    def initialize(options)
+      @options = DEFAULTS.merge(options).stringify_keys
+    end
+    
+    def host
+      @options['host']
+    end
+    
+    def port
+      @options['port']
+    end
+    
+    def database
+      @options['database']
+    end
+    
+    def establish_connection
+      Mongo::Connection.new(host, port).db(database)
+    end
+    
+    DEFAULTS = {
+      'host'     => 'localhost',
+      'port'     => 27017,
+      'database' => 'mongomodel-default'
+    }
+    
+    def self.defaults
+      new({})
+    end
+  end
+end

data/lib/mongomodel/support/core_extensions.rb

@@ -0,0 +1,10 @@
+class Boolean < TrueClass; end
+
+class Symbol
+  [:lt, :lte, :gt, :gte, :ne, :in, :nin, :mod, :all, :size, :exists].each do |operator|
+    define_method(operator) { MongoModel::MongoOperator.new(self, operator) }
+  end
+  
+  define_method(:asc) { MongoModel::MongoOrder::Clause.new(self, :ascending) }
+  define_method(:desc) { MongoModel::MongoOrder::Clause.new(self, :descending) }
+end

data/lib/mongomodel/support/exceptions.rb

@@ -0,0 +1,25 @@
+module MongoModel
+  class DocumentNotFound < StandardError; end
+  
+  class DocumentNotSaved < StandardError; end
+  
+  # Raised by <tt>save!</tt> and <tt>create!</tt> when the document is invalid.  Use the
+  # +document+ method to retrieve the document which did not validate.
+  #   begin
+  #     complex_operation_that_calls_save!_internally
+  #   rescue MongoModel::DocumentInvalid => invalid
+  #     puts invalid.document.errors
+  #   end
+  class DocumentInvalid < DocumentNotSaved
+    attr_reader :document
+    
+    def initialize(document)
+      @document = document
+      
+      errors = @document.errors.full_messages.join(I18n.t('support.array.words_connector', :default => ', '))
+      super(I18n.t('mongomodel.errors.messages.document_invalid', :errors => errors))
+    end
+  end
+  
+  class AssociationTypeMismatch < StandardError; end
+end

data/lib/mongomodel/support/mongo_options.rb

@@ -0,0 +1,177 @@
+module MongoModel
+  class MongoOptions
+    ValidKeys = [ :conditions, :select, :offset, :limit, :order ]
+    
+    attr_reader :selector, :options
+    
+    def initialize(model, options={})
+      options.assert_valid_keys(ValidKeys)
+      
+      @model = model
+      
+      @selector = extract_conditions(options)
+      @options  = extract_options(options)
+      
+      add_type_to_selector
+    end
+    
+    def to_a
+      [selector, options]
+    end
+  
+  private
+    def extract_conditions(options)
+      result = {}
+      
+      (options[:conditions] || {}).each do |k, v|
+        if k.is_a?(MongoOperator)
+          key = k.field
+          value = k.to_mongo_selector(v)
+        else
+          key = k
+          value = v
+        end
+        
+        property = @model.properties[key]
+        
+        result[property ? property.as : key] = value
+      end
+      
+      result
+    end
+    
+    def extract_options(options)
+      result = {}
+      
+      result[:fields] = options[:select] if options[:select]
+      result[:skip]   = options[:offset] if options[:offset]
+      result[:limit]  = options[:limit]  if options[:limit]
+      result[:sort]   = MongoOrder.parse(options[:order]).to_sort(@model) if options[:order]
+      
+      result
+    end
+    
+    def convert_order(order)
+      case order
+      when Array
+        order.map { |clause|
+          key, sort = clause.split(/ /)
+          
+          property = @model.properties[key.to_sym]
+          sort = (sort =~ /desc/i) ? :descending : :ascending
+          
+          [property ? property.as : key, sort]
+        } if order.size > 0
+      when String, Symbol
+        convert_order(order.to_s.split(/,/).map { |c| c.strip })
+      end
+    end
+    
+    def add_type_to_selector
+      unless selector['_type'] || @model.superclass.abstract_class?
+        selector['_type'] = { '$in' => [@model.to_s] + @model.subclasses }
+      end
+    end
+  end
+  
+  class MongoOrder
+    attr_reader :clauses
+    
+    def initialize(*clauses)
+      @clauses = clauses
+    end
+    
+    def to_s
+      clauses.map { |c| c.to_s }.join(', ')
+    end
+    
+    def to_sort(model)
+      clauses.map { |c| c.to_sort(model.properties[c.field]) }
+    end
+    
+    def ==(other)
+      other.is_a?(self.class) && clauses == other.clauses
+    end
+    
+    def reverse
+      self.class.new(*clauses.map { |c| c.reverse })
+    end
+    
+    def self.parse(order)
+      case order
+      when MongoOrder
+        order
+      when Clause
+        new(order)
+      when Symbol
+        new(Clause.new(order))
+      when String
+        new(*order.split(',').map { |c| Clause.parse(c) })
+      when Array
+        new(*order.map { |c| Clause.parse(c) })
+      end
+    end
+    
+    class Clause
+      attr_reader :field, :order
+      
+      def initialize(field, order=:ascending)
+        @field, @order = field.to_sym, order.to_sym
+      end
+      
+      def to_s
+        "#{field} #{order}"
+      end
+      
+      def to_sort(property)
+        [property ? property.as : field.to_s, order]
+      end
+      
+      def reverse
+        self.class.new(field, order == :ascending ? :descending : :ascending)
+      end
+      
+      def ==(other)
+        other.is_a?(self.class) && field == other.field && order == other.order
+      end
+      
+      def self.parse(clause)
+        case clause
+        when Clause
+          clause
+        when String, Symbol
+          field, order = clause.to_s.strip.split(/ /)
+          new(field, order =~ /^desc/i ? :descending : :ascending)
+        end
+      end
+    end
+  end
+  
+  class MongoOperator
+    attr_reader :field, :operator
+    
+    def initialize(field, operator)
+      @field, @operator = field, operator
+    end
+    
+    def to_mongo_selector(value)
+      { "$#{operator}" => value }
+    end
+    
+    def inspect
+      "#{field.inspect}.#{operator}"
+    end
+    
+    def ==(other)
+      other.is_a?(self.class) && field == other.field && operator == other.operator
+    end
+    
+    def hash
+      field.hash ^ operator.hash
+    end
+    
+    def eql?(other)
+      self == other
+    end
+  end
+end