mongodb_model 0.0.1 → 0.0.2

data/lib/mongodb_model/assignment.rb

@@ -0,0 +1,65 @@
+module Mongo::Model::Assignment
+  class Dsl < BasicObject
+    def initialize
+      @attributes = {}
+    end
+
+    def self.const_missing name
+      # BasicObject doesn't have access to any constants like String, Symbol, ...
+      ::Object.const_get name
+    end
+
+    def to_h; attributes end
+
+    protected
+      attr_reader :attributes
+
+      def method_missing attribute_name, *args
+        attribute_name.must_be.a Symbol
+
+        args.size.must_be.in 1..2
+        if args.first.is_a? Class
+          type, mass_assignment = args
+          mass_assignment ||= false
+          type.must.respond_to :cast
+        else
+          type, mass_assignment = nil, args.first
+        end
+
+        attributes[attribute_name] = [type, mass_assignment]
+      end
+  end
+
+  def set attributes, options = {}
+    if rules = self.class._assign
+      force = options[:force]
+      attributes.each do |n, v|
+        n = n.to_sym
+        if rule = rules[n]
+          type, mass_assignment = rule
+          if mass_assignment or force
+            v = type.cast(v) if type
+            send "#{n}=", v
+          end
+        end
+      end
+    else
+      attributes.each{|n, v| send "#{n}=", v}
+    end
+    self
+  end
+
+  def set! attributes, options = {}
+    set attributes, options.merge(force: true)
+  end
+
+  module ClassMethods
+    inheritable_accessor :_assign, nil
+
+    def assign &block
+      dsl = ::Mongo::Model::Assignment::Dsl.new
+      dsl.instance_eval &block
+      self._assign = (_assign || {}).merge dsl.to_h
+    end
+  end
+end

data/lib/mongodb_model/attribute_convertors.rb

@@ -0,0 +1,54 @@
+require 'json'
+require 'yaml'
+
+module Mongo::Model::AttributeConvertors
+  CONVERTORS = {
+    line: {
+      from_string: -> s {(s || "").split(',').collect{|s| s.strip}},
+      to_string:   -> v {v.join(', ')}
+    },
+    column: {
+      from_string: -> s {(s || "").split("\n").collect{|s| s.strip}},
+      to_string:   -> v {v.join("\n")}
+    },
+    yaml: {
+      from_string: -> s {YAML.load s rescue {}},
+      to_string:   -> v {v.to_yaml.strip}
+    },
+    json: {
+      from_string: -> s {JSON.parse s rescue {}},
+      to_string:   -> v {v.to_json.strip}
+    }
+  }
+
+  module ClassMethods
+    def available_as_string name, converter_name
+      converter = CONVERTORS[converter_name]
+      raise "unknown converter name :#{converter_name} for :#{name} field!" unless converter
+
+      from_string, to_string = converter[:from_string], converter[:to_string]
+      name_as_string = "#{name}_as_string".to_sym
+      define_method name_as_string do
+        _cache[name_as_string] ||= to_string.call(send(name))
+      end
+
+      define_method "#{name_as_string}=" do |value|
+        _cache.delete name_as_string
+        self.send "#{name}=", from_string.call(value)
+      end
+    end
+
+    def available_as_yaml name
+      raise "delimiter not specified for :#{name} field!" unless delimiter
+      method = "#{name}_as_string"
+      define_method method do
+        self.send(name).join(delimiter)
+      end
+      define_method "#{method}=" do |value|
+        value = (value || "").split(delimiter.strip).collect{|s| s.strip}
+        self.send "#{name}=", value
+      end
+    end
+  end
+
+end

data/lib/mongodb_model/callbacks.rb

@@ -0,0 +1,36 @@
+module Mongo::Model::Callbacks
+  inherit RubyExt::Callbacks
+
+  def _run_callbacks type, method_name
+    if type == :before
+      run_before_callbacks method_name, method: method_name
+    elsif type == :after
+      run_after_callbacks method_name, method: method_name
+    else
+      raise "invalid callback type (#{type})!"
+    end
+  end
+
+  module ClassMethods
+    [:validate, :update, :save, :destroy].each do |method_name|
+      define_method "before_#{method_name}" do |*args, &block|
+        opt = args.extract_options!
+        if block
+          set_callback method_name, :before, opt, &block
+        else
+          opt[:terminator] = false unless opt.include? :terminator
+          args.each{|executor| set_callback method_name, :before, executor, opt}
+        end
+      end
+
+      define_method "after_#{method_name}" do |*args, &block|
+        opt = args.extract_options!
+        if block
+          set_callback method_name, :after, opt, &block
+        else
+          args.each{|executor| set_callback method_name, :after, executor, opt}
+        end
+      end
+    end
+  end
+end

data/lib/mongodb_model/crud.rb

@@ -0,0 +1,57 @@
+module Mongo::Model::Crud
+  def save opts = {}
+    with_collection opts do |collection, opts|
+      collection.save self, opts
+    end
+  end
+
+  def save! *args
+    save(*args) || raise(Mongo::Error, "can't save #{self.inspect}!")
+  end
+
+  def destroy opts = {}
+    with_collection opts do |collection, opts|
+      collection.destroy self, opts
+    end
+  end
+
+  def destroy! *args
+    destroy(*args) || raise(Mongo::Error, "can't destroy #{self.inspect}!")
+  end
+
+  module ClassMethods
+    def build attributes, opts = {}
+      self.new.set attributes, opts
+    end
+
+    def create attributes, opts = {}
+      o = build attributes, opts
+      o.save
+      o
+    end
+
+    def create! attributes, opts = {}
+      o = create attributes
+      raise(Mongo::Error, "can't create #{attributes.inspect}!") if o.new_record?
+      o
+    end
+
+    def destroy_all selector = {}, opts = {}
+      success = true
+      collection = opts[:collection] || self.collection
+      each(selector){|o| success = false unless o.destroy}
+      success
+    end
+
+    def destroy_all! selector = {}, opts = {}
+      destroy_all(selector, opts) || raise(Mongo::Error, "can't destroy #{selector.inspect}!")
+    end
+  end
+
+  protected
+    def with_collection opts, &block
+      opts = opts.clone
+      collection = opts.delete(:collection) || self.class.collection
+      block.call collection, opts
+    end
+end

data/lib/mongodb_model/db.rb

@@ -0,0 +1,53 @@
+module Mongo::Model::Db
+  module ClassMethods
+    inheritable_accessor :_db, nil
+    def db= v
+      self._db = if v.is_a? ::Proc
+        v
+      elsif v.is_a? ::Symbol
+        -> {::Mongo::Model.connection.db v.to_s}
+      else
+        -> {v}
+      end
+    end
+
+    def db *args, &block
+      if block
+        self.db = block
+      elsif !args.empty?
+        args.size.must == 1
+        self.db = args.first
+      else
+        (_db && _db.call) || ::Mongo::Model.db
+      end
+    end
+
+    inheritable_accessor :_collection, nil
+    def collection= v
+      self._collection = if v.is_a? ::Proc
+        v
+      elsif v.is_a? ::Symbol
+        -> {db.collection v}
+      else
+        -> {v}
+      end
+    end
+
+    def collection *args, &block
+      if block
+        self.collection = block
+      elsif !args.empty?
+        args.size.must == 1
+        self.collection = args.first
+      else
+        (_collection && _collection.call) || db.collection(default_collection_name)
+      end
+    end
+
+    def default_collection_name
+      first_ancestor_class = ancestors.find{|a| a.is_a? Class} ||
+        raise("can't evaluate default collection name for #{self}!")
+      first_ancestor_class.alias.pluralize.underscore.to_sym
+    end
+  end
+end

data/lib/mongodb_model/gems.rb

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

data/lib/mongodb_model/misc.rb

@@ -0,0 +1,33 @@
+module Mongo::Model::Misc
+  def update_timestamps
+    now = Time.now.utc
+    self.created_at ||= now
+    self.updated_at = now
+  end
+
+
+  def _cache
+    @_cache ||= {}
+  end
+  def _clear_cache
+    @_cache = {}
+  end
+
+
+  def dom_id
+    # new_record? ? "new_#{self.class.name.underscore}" : to_param
+    to_param
+  end
+
+  def to_param
+    (_id || '').to_s
+  end
+
+
+  module ClassMethods
+    def timestamps!
+      attr_accessor :created_at, :updated_at
+      before_save :update_timestamps
+    end
+  end
+end

data/lib/mongodb_model/model.rb

@@ -0,0 +1,11 @@
+module Mongo::Model
+  attr_accessor :_id, :_class
+
+  def _id?; !!_id end
+  def new_record?; !_id end
+
+  class << self
+    attr_accessor :db, :connection
+    attr_required :db, :connection
+  end
+end

data/lib/mongodb_model/query.rb

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

data/lib/mongodb_model/scope.rb

@@ -0,0 +1,99 @@
+module Mongo::Model::Scope
+  class ScopeProxy < BasicObject
+    def initialize model, scope
+      @model, @scope = model, scope
+    end
+
+    def class
+      ::Mongo::Model::Scope::ScopeProxy
+    end
+
+    def reverse_merge! scope
+      @scope = scope.merge @scope
+    end
+
+    def inspect
+      "#<ScopeProxy:{#{scope.inspect}}>"
+    end
+    alias_method :to_s, :inspect
+
+    protected
+      attr_reader :model, :scope
+
+      def method_missing method, *args, &block
+        model.with_scope scope do
+          result = model.send method, *args, &block
+          result.reverse_merge! scope if result.class == ::Mongo::Model::Scope::ScopeProxy
+          result
+        end
+      end
+  end
+
+  module ClassMethods
+    def current_scope
+      scope, exclusive = Thread.current[:mongo_model_scope]
+      if exclusive
+        scope
+      elsif scope
+        default_scope.merge scope
+      else
+        default_scope
+      end
+    end
+
+    def with_exclusive_scope options = {}, &block
+      with_scope options, true, &block
+    end
+
+    def with_scope options = {}, exclusive = false, &block
+      previous_options, previous_exclusive = Thread.current[:mongo_model_scope]
+      raise "exclusive scope already applied!" if previous_exclusive
+
+      begin
+        options = previous_options.merge options if previous_options and !exclusive
+        Thread.current[:mongo_model_scope] = [options, exclusive]
+        return block.call
+      ensure
+        Thread.current[:mongo_model_scope] = [previous_options, false]
+      end
+    end
+
+    inheritable_accessor :_default_scope, -> {{}}
+    def default_scope *args, &block
+      if block
+        self._default_scope = block
+      elsif !args.empty?
+        args.size.must == 1
+        args.first.must_be.a Hash
+        scope = args.first
+        self._default_scope = -> {args.first}
+      else
+        _default_scope.call
+      end
+    end
+
+    def scope name, options = nil, &block
+      model = self
+      metaclass.define_method name do
+        scope = (block && block.call) || options
+        ScopeProxy.new model, scope
+      end
+    end
+
+
+    #
+    # finders
+    #
+    def count selector = {}, opts = {}
+      super current_scope.merge(selector), opts
+    end
+
+    def first selector = {}, opts = {}
+      super current_scope.merge(selector), opts
+    end
+
+    def each selector = {}, opts = {}, &block
+      super current_scope.merge(selector), opts, &block
+    end
+  end
+end

data/lib/mongodb_model/spec.rb

@@ -0,0 +1,12 @@
+require 'mongodb/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/mongodb_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/mongodb_model/validation.rb

@@ -0,0 +1,5 @@
+module Mongo::Model::Validation
+  def _valid?
+    !(respond_to?(:errors) and errors and !errors.empty?)
+  end
+end

data/lib/mongodb_model.rb

@@ -0,0 +1,36 @@
+require 'mongodb_model/gems'
+
+require 'validatable'
+require 'i18n'
+require 'ruby_ext'
+require 'mongodb/object'
+
+module Mongo::Model; end
+
+%w(
+  support/types
+
+  db
+  assignment
+  callbacks
+  validation
+  crud
+  query
+  scope
+  attribute_convertors
+  misc
+  model
+).each{|f| require "mongodb_model/#{f}"}
+
+module Mongo
+  module Model
+    inherit Db, Assignment, Callbacks, Validation, Crud, Query, Scope, AttributeConvertors, Misc
+  end
+end
+
+Mongo.defaults.merge! \
+  symbolize:                    true,
+  convert_underscore_to_dollar: true,
+  batch_size:                   50,
+  multi:                        true,
+  safe:                         true

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 'mongodb/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