mongo_db 0.1.9 → 0.1.10

data/lib/mongo_db/driver/{core/collection.rb → collection.rb}

@@ -38,7 +38,7 @@ module Mongo::CollectionExt
   def destroy *args
     remove *args
   end
-  
+
   def create *args
     insert *args
   end
@@ -46,19 +46,23 @@ module Mongo::CollectionExt
   #
   # Querying
   #
-  def first selector = nil, opts = {}
+  def first selector = {}, opts = {}
     selector = convert_underscore_to_dollar_in_selector selector if selector.is_a? Hash
 
     h = find_one selector, opts
     symbolize_doc h
   end
 
-  def all *args, &block
+  def first! selector = {}, opts = {}
+    first(selector, opts) || raise(Mongo::NotFound, "document with selector #{selector} not found!")
+  end
+
+  def all selector = {}, opts = {}, &block
     if block
-      each *args, &block
+      each selector, opts, &block
     else
       list = []
-      each(*args){|doc| list << doc}
+      each(selector, opts){|doc| list << doc}
       list
     end
   end
@@ -80,6 +84,10 @@ module Mongo::CollectionExt
     nil
   end
 
+  def count_with_ext selector = {}, opts = {}
+    find(selector, opts).count()
+  end
+
   protected
     QUERY_KEYWORDS = [
       :_lt, :_lte, :_gt, :_gte,

data/lib/mongo_db/driver/dynamic_finders.rb

@@ -0,0 +1,41 @@
+module Mongo::DynamicFinders
+  protected
+    #
+    # first_by_field, all_by_field, each_by_field, first_by_field
+    #
+    def method_missing clause, *args, &block
+      if clause =~ /^([a-z]_by_[a-z_])|(by_[a-z_])/
+        clause = clause.to_s
+
+        bang = clause =~ /!$/
+        clause = clause[0..-2] if bang
+
+        finder, field = if clause =~ /^by_/
+          ['first', clause.sub(/by_/, '')]
+        else
+          clause.split(/_by_/, 2)
+        end
+
+        finder = 'first' if finder == 'find'
+        field = '_id'    if field  == 'id'
+
+        if bang
+          raise "You can't use bang version with :#{finder}!" unless finder == 'first'
+          finder = "#{finder}!"
+        end
+
+        raise "invalid arguments for finder (#{args})!" unless args.size == 1
+        field_value = args.first
+
+        finder, field = finder.to_sym, field.to_sym
+
+        if respond_to? finder
+          send finder, {field => field_value}, &block
+        else
+          super
+        end
+      else
+        super
+      end
+    end
+end

data/lib/mongo_db/driver.rb

@@ -1,2 +1,33 @@
-require 'mongo_db/driver/core'
-require 'mongo_db/driver/more'
+require 'mongo_db/gems'
+
+require 'mongo'
+
+class Mongo::Error < StandardError; end
+class Mongo::NotFound < Mongo::Error; end
+
+%w(
+  database
+  collection
+  dynamic_finders
+).each{|f| require "mongo_db/driver/#{f}"}
+
+# defaults
+Mongo.class_eval do
+  class << self
+    def defaults; @defaults ||= {} end
+    attr_writer :defaults
+  end
+end
+
+# database
+Mongo::DB.send :include, Mongo::DBExt
+
+# collection
+Mongo::Collection.class_eval do
+  include Mongo::CollectionExt, Mongo::DynamicFinders
+
+  %w(insert update remove save count).each do |method|
+    alias_method "#{method}_without_ext", method
+    alias_method method, "#{method}_with_ext"
+  end
+end

data/lib/mongo_db/migration/definition.rb

@@ -0,0 +1,19 @@
+class Mongo::Migration::Definition
+  def upgrade &block
+    if block
+      @upgrade = block
+    else
+      @upgrade
+    end
+  end
+  alias_method :up, :upgrade
+
+  def downgrade &block
+    if block
+      @downgrade = block
+    else
+      @downgrade
+    end
+  end
+  alias_method :down, :downgrade
+end

data/lib/mongo_db/migration/migration.rb

@@ -0,0 +1,68 @@
+class Mongo::Migration
+  def initialize db
+    @db, @definitions = db, {}
+  end
+
+  def add version, &block
+    raise "version should be an Integer! (but you provided '#{version}' instad)!" unless version.is_a? Integer
+    definition = Definition.new
+    block.call definition
+    definitions[version] = definition
+  end
+
+  def update version = nil
+    version ||= definitions.keys.max
+
+    if current_version == version
+      info "database '#{db.name}' already is of #{version} version, no migration needed"
+      return false
+    else
+      info "updating '#{db.name}' to #{version}"
+    end
+
+    increase_db_version while current_version < version
+    decrease_db_version while current_version > version
+    true
+  end
+
+  def current_version
+    if doc = db.db_metadata.first(name: 'migration')
+      doc[:version] || doc['version']
+    else
+      0
+    end
+  end
+
+  protected
+    attr_accessor :db, :definitions
+
+    def info msg
+      db.connection.logger and db.connection.logger.info(msg)
+    end
+
+    def update_version new_version
+      db.db_metadata.update({name: 'migration'}, {name: 'migration', version: new_version}, {upsert: true, safe: true})
+    end
+
+    def increase_db_version
+      new_version = current_version + 1
+      migration = definitions[new_version]
+      raise "no upgrade of #{db.name} database to #{new_version} version!" unless migration and migration.up
+
+      migration.up.call db
+      update_version new_version
+
+      info "database '#{db.name}' upgraded to #{new_version} version."
+    end
+
+    def decrease_db_version
+      new_version = current_version - 1
+      migration = definitions[new_version + 1]
+      raise "no downgrade of #{db.name} database to #{new_version} version!" unless migration and migration.down
+
+      migration.down.call db
+      update_version new_version
+
+      info "database '#{db.name}' downgraded to #{new_version} version."
+    end
+end

data/lib/mongo_db/migration/tasks.rb

@@ -0,0 +1,19 @@
+# namespace :db do
+#   desc "Migrate Database"
+#   task migrate: :migration_evnironment do
+#     require 'mongo_migration'
+#
+#     database_name = (ENV['d'] || ENV['database'] || :default).to_sym
+#     version = ENV['v'] || ENV['version']
+#
+#     if version.blank?
+#       size = Mongo.migration.definitions[database_name].size
+#       highest_defined_version = size == 0 ? 0 : size - 1
+#       version = highest_defined_version
+#     else
+#       version = version.to_i
+#     end
+#
+#     Mongo.migration.update version, database_name
+#   end
+# end

data/lib/mongo_db/migration.rb

@@ -0,0 +1,8 @@
+require 'mongo_db/driver'
+
+class Mongo::Migration; end
+
+%w(
+  definition
+  migration
+).each{|f| require "mongo_db/migration/#{f}"}

data/lib/mongo_db/model/assignment.rb

@@ -0,0 +1,54 @@
+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, type, mass_assignment = false
+        attribute_name.must_be.a Symbol
+        type.must.respond_to :cast
+        attributes[attribute_name] = [type, mass_assignment]
+      end
+  end
+
+  def set attributes, options = {}
+    if rules = self.class._assignment
+      force = options[:force]
+      attributes.each do |n, v|
+        n = n.to_sym
+        type, mass_assignment = rules[n]
+        if type and (mass_assignment or force)
+          v = type.cast(v)
+          send "#{n}=", v
+        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 :_assignment, nil
+
+    def assignment &block
+      dsl = ::Mongo::Model::Assignment::Dsl.new
+      dsl.instance_eval &block
+      self._assignment = (_assignment || {}).merge dsl.to_h
+    end
+  end
+end

data/lib/mongo_db/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/mongo_db/model/crud.rb

@@ -0,0 +1,28 @@
+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
+
+  protected
+    def with_collection opts, &block
+      opts = opts.clone
+      collection = opts.delete(:collection) || self.class.collection
+      block.call collection, opts
+    end
+end

data/lib/mongo_db/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/mongo_db/model/misc.rb

@@ -0,0 +1,14 @@
+module Mongo::Model::Misc
+  def update_timestamps
+    now = Time.now.utc
+    self.created_at ||= now
+    self.updated_at = now
+  end
+
+  module ClassMethods
+    def timestamps!
+      attr_accessor :created_at, :updated_at
+      before_save :update_timestamps
+    end
+  end
+end

data/lib/mongo_db/model/model.rb

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

data/lib/mongo_db/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/mongo_db/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/mongo_db/model/spec.rb

@@ -0,0 +1,12 @@
+require 'mongo_db/driver/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