mongodbmodel 0.0.1

data/lib/mongo/model/query_mixin.rb

@@ -0,0 +1,45 @@
+module Mongo::Model::QueryMixin
+  module ClassMethods
+    include Mongo::DynamicFinders
+
+    def count selector = {}, options = {}
+      collection.count selector, options
+    end
+
+    def first selector = {}, options = {}
+      collection.first selector, options
+    end
+
+    def each selector = {}, options = {}, &block
+      collection.each selector, options, &block
+    end
+
+    def all selector = {}, options = {}, &block
+      if block
+        each selector, options, &block
+      else
+        list = []
+        each(selector, options){|doc| list << doc}
+        list
+      end
+    end
+
+    def first! selector = {}, options = {}
+      first(selector, options) || raise(Mongo::NotFound, "document with selector #{selector} not found!")
+    end
+
+    def exists? selector = {}, options = {}
+      count(selector, options) > 0
+    end
+    alias :exist? :exists?
+
+    def query *args
+      if args.first.is_a? Mongo::Model::Query
+        args.first
+      else
+        selector, options = args.first.is_a?(::Array) ? args.first : args
+        Mongo::Model::Query.new self, (selector || {}), (options || {})
+      end
+    end
+  end
+end

data/lib/mongo/model/scope.rb

@@ -0,0 +1,84 @@
+module Mongo::Model::Scope
+  module ClassMethods
+    def current_scope
+      scope, exclusive = Thread.current[:mongo_model_scope]
+      current = if exclusive
+        scope
+      elsif scope
+        default_scope ? default_scope.merge(scope) : scope
+      else
+        default_scope
+      end
+    end
+
+    def with_exclusive_scope *args, &block
+      with_scope *(args << true), &block
+    end
+
+    def with_scope *args, &block
+      if args.last.is_a?(TrueClass) or args.last.is_a?(FalseClass)
+        exclusive = args.pop
+      else
+        exclusive = false
+      end
+
+      scope = query *args
+      previous_scope, previous_exclusive = Thread.current[:mongo_model_scope]
+      raise "exclusive scope already applied!" if previous_exclusive
+
+      begin
+        scope = previous_scope.merge scope if !exclusive and previous_scope
+        Thread.current[:mongo_model_scope] = [scope, exclusive]
+        return block.call
+      ensure
+        Thread.current[:mongo_model_scope] = [previous_scope, false]
+      end
+    end
+
+    inheritable_accessor :_default_scope, nil
+    def default_scope *args, &block
+      if block
+        self._default_scope = -> {query block.call}
+      elsif !args.empty?
+        self._default_scope = -> {query *args}
+      else
+        _default_scope && _default_scope.call
+      end
+    end
+
+    def scope name, *args, &block
+      model = self
+      metaclass.define_method name do
+        query (block && instance_eval(&block)) || args
+      end
+    end
+
+
+    #
+    # finders
+    #
+    def count selector = {}, options = {}
+      if current = current_scope
+        super current.selector.merge(selector), current.options.merge(options)
+      else
+        super selector, options
+      end
+    end
+
+    def first  selector = {}, options = {}
+      if current = current_scope
+        super current.selector.merge(selector), current.options.merge(options)
+      else
+        super selector, options
+      end
+    end
+
+    def each  selector = {}, options = {}, &block
+      if current = current_scope
+        super current.selector.merge(selector), current.options.merge(options), &block
+      else
+        super selector, options, &block
+      end
+    end
+  end
+end

data/lib/mongo/model/spec.rb

@@ -0,0 +1,12 @@
+require 'mongo/object/spec'
+
+rspec do
+  class << self
+    def with_mongo_model
+      with_mongo
+
+      before{Mongo::Model.db = mongo.db}
+      after{Mongo::Model.db = nil}
+    end
+  end
+end

data/lib/mongo/model/support/types.rb

@@ -0,0 +1,110 @@
+#
+# Boolean
+#
+module Mongo::Model::BooleanType
+  Mapping = {
+    true    => true,
+    'true'  => true,
+    'TRUE'  => true,
+    'True'  => true,
+    't'     => true,
+    'T'     => true,
+    '1'     => true,
+    1       => true,
+    1.0     => true,
+    false   => false,
+    'false' => false,
+    'FALSE' => false,
+    'False' => false,
+    'f'     => false,
+    'F'     => false,
+    '0'     => false,
+    0       => false,
+    0.0     => false,
+    nil     => nil
+  }
+
+  def cast value
+    if value.is_a? Boolean
+      value
+    else
+      Mapping[value] || false
+    end
+  end
+end
+
+class Boolean; end unless defined?(Boolean)
+
+Boolean.extend Mongo::Model::BooleanType
+
+
+#
+# Date
+#
+require 'date'
+Date.class_eval do
+  def self.cast value
+    if value.nil? || value == ''
+      nil
+    else
+      date = value.is_a?(::Date) || value.is_a?(::Time) ? value : ::Date.parse(value.to_s)
+      date.to_date
+    end
+  rescue
+    nil
+  end
+end
+
+
+#
+# Float
+#
+Float.class_eval do
+  def self.cast value
+    value.nil? ? nil : value.to_f
+  end
+end
+
+
+#
+# Integer
+#
+Integer.class_eval do
+  def self.cast value
+    value_to_i = value.to_i
+    if value_to_i == 0 && value != value_to_i
+      value.to_s =~ /^(0x|0b)?0+/ ? 0 : nil
+    else
+      value_to_i
+    end
+  end
+end
+
+
+#
+# String
+#
+String.class_eval do
+  def self.cast value
+    value.nil? ? nil : value.to_s
+  end
+end
+
+
+#
+# Time
+#
+Time.class_eval do
+  def self.cast value
+    if value.nil? || value == ''
+      nil
+    else
+      # time_class = ::Time.try(:zone).present? ? ::Time.zone : ::Time
+      # time = value.is_a?(::Time) ? value : time_class.parse(value.to_s)
+      # strip milliseconds as Ruby does micro and bson does milli and rounding rounded wrong
+      # at(time.to_i).utc if time
+
+      value.is_a?(::Time) ? value : Date.parse(value.to_s).to_time
+    end
+  end
+end

data/lib/mongo/model/validation.rb

@@ -0,0 +1,41 @@
+module Mongo::Model::Validation
+  def errors
+    @_errors ||= Validatable::Errors.new
+  end
+
+  def run_validations
+    self.class.validations.each do |v|
+      if v.respond_to?(:validate)
+        v.validate self
+      elsif v.is_a? Proc
+        v.call self
+      else
+        send v
+      end
+    end
+    true
+  end
+
+  module ClassMethods
+    include ::Validatable::Macros
+
+    inheritable_accessor :validations, []
+
+    def validates_uniqueness_of *args
+      add_validations(args, Mongo::Model::UniquenessValidator)
+    end
+
+    def validate validation
+      validations << validation
+    end
+
+    protected
+      def add_validations(args, klass)
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        args.each do |attribute|
+          new_validation = klass.new self, attribute, options
+          validate new_validation
+        end
+      end
+  end
+end

data/lib/mongo/model/validation/uniqueness_validator.rb

@@ -0,0 +1,30 @@
+class Mongo::Model::UniquenessValidator < Validatable::ValidationBase
+  attr_accessor :scope, :case_sensitive
+
+  def initialize(klass, attribute, options={})
+    super
+    self.case_sensitive = false if case_sensitive == nil
+  end
+
+  def valid?(instance)
+    conditions = {}
+
+    conditions[scope] = instance.send scope if scope
+
+    value = instance.send attribute
+    if case_sensitive
+      conditions[attribute] = value
+    else
+      conditions[attribute] = /^#{Regexp.escape(value.to_s)}$/i
+    end
+
+    # Make sure we're not including the current document in the query
+    conditions[:_id] = {_ne: instance._id} if instance._id
+
+    !klass.exists?(conditions)
+  end
+
+  def message(instance)
+    super || "#{attribute} must be unique!"
+  end
+end

data/lib/mongodb_model/gems.rb

@@ -0,0 +1,8 @@
+gem 'i18n', '~> 0.5'
+
+if respond_to? :fake_gem
+  fake_gem 'mongodb'
+  fake_gem 'file_model'
+  fake_gem 'validatable2'
+  fake_gem 'ruby_ext'
+end

data/readme.md

@@ -0,0 +1,72 @@
+Object Model for MongoDB (callbacks, validations, mass-assignment, finders, ...).
+
+- The same API for pure driver and Models.
+- Minimum extra abstractions, trying to keep things as close to the MongoDB semantic as possible.
+- Schema-less, dynamic (with ability to specify types for mass-assignment).
+- Models can be saved to any collection.
+- Full support for embedded objects (validations, callbacks, ...).
+- Scope, default_scope
+- Doesn't try to mimic ActiveRecord, MongoDB is differrent and this tool designed to get most of it.
+- Very small, see [code stats][code_stats].
+
+Other ODM usually try to cover simple but non-standard API of MongoDB behind complex ORM-like abstractions. This tool **exposes simplicity and power of MongoDB and leverages it's differences**.
+
+``` ruby
+# Connecting to MongoDB.
+require 'mongo/model'
+Mongo.defaults.merge! symbolize: true, multi: true, safe: true
+connection = Mongo::Connection.new
+db = connection.db 'default_test'
+db.units.drop
+Mongo::Model.db = db
+
+# Let's define the game unit.
+class Unit
+  inherit Mongo::Model
+  collection :units
+
+  attr_accessor :name, :status, :stats
+
+  scope :alive, status: 'alive'
+
+  class Stats
+    inherit Mongo::Model
+    attr_accessor :attack, :life, :shield
+  end
+end
+
+# Create.
+zeratul  = Unit.build(name: 'Zeratul',  status: 'alive', stats: Unit::Stats.build(attack: 85, life: 300, shield: 100))
+tassadar = Unit.build(name: 'Tassadar', status: 'dead',  stats: Unit::Stats.build(attack: 0,  life: 80,  shield: 300))
+
+zeratul.save
+tassadar.save
+
+# Udate (we made error - mistakenly set Tassadar's attack as zero, let's fix it).
+tassadar.stats.attack = 20
+tassadar.save
+
+# Querying first & all, there's also :each, the same as :all.
+Unit.first name: 'Zeratul'                         # => zeratul
+Unit.all name: 'Zeratul'                           # => [zeratul]
+Unit.all name: 'Zeratul' do |unit|
+  unit                                             # => zeratul
+end
+
+# Simple finders (bang versions also availiable).
+Unit.by_name 'Zeratul'                             # => zeratul
+Unit.first_by_name 'Zeratul'                       # => zeratul
+Unit.all_by_name 'Zeratul'                         # => [zeratul]
+
+# Scopes.
+Unit.alive.count                                   # => 1
+Unit.alive.first                                   # => zeratul
+
+# Callbacks & callbacks on embedded models.
+
+# Validations.
+
+# Save model to any collection.
+```
+
+Source: examples/model.rb

data/spec/assignment_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+describe 'Model callbacks' do
+  with_mongo_model
+
+  after{remove_constants :User, :Writer}
+
+  it "should update attributes" do
+    class User
+      inherit Mongo::Model
+
+      attr_accessor :name, :has_mail, :age, :banned
+    end
+
+    u = User.new
+    u.set name: 'Alex', has_mail: '1', age: '31', banned: '0'
+    [u.name, u.has_mail, u.age, u.banned].should == ['Alex', '1', '31', '0']
+  end
+
+  it "should update only specified attributes" do
+    class User
+      inherit Mongo::Model
+
+      attr_accessor :name, :has_mail, :age, :position, :banned
+
+      assign do
+        name     String,  true
+        has_mail Boolean, true
+        age      Integer, true
+        position true
+        banned   Boolean
+      end
+    end
+
+    u = User.new
+    u.set name: 'Alex', has_mail: '1', age: '31', position: [11, 34] ,banned: '0'
+    [u.name, u.has_mail, u.age, u.position, u.banned].should == ['Alex', true, 31, [11, 34], nil]
+
+    # should allow to forcefully cast and update any attribute
+    u.set! banned: '0'
+    u.banned.should == false
+  end
+
+  it "should inherit assignment rules" do
+    class User
+      inherit Mongo::Model
+
+      attr_accessor :age
+
+      assign do
+        age Integer,  true
+      end
+    end
+
+    class Writer < User
+      attr_accessor :posts
+
+      assign do
+        posts Integer, true
+      end
+    end
+
+    u = Writer.new
+    u.set age: '20', posts: '12'
+    [u.age, u.posts].should == [20, 12]
+  end
+
+  it 'casting smoke test' do
+    [
+      Boolean, '1',          true,
+      Date,    '2011-08-23', Date.parse('2011-08-23'),
+      Float,   '1.2',        1.2,
+      Integer, '10',         10,
+      String,  'Hi',         'Hi',
+      Time,    '2011-08-23', Date.parse('2011-08-23').to_time
+    ].each_slice 3 do |type, raw, expected|
+      type.cast(raw).should == expected
+    end
+  end
+end