mingo 0.2.0 → 0.3.2

data/lib/mingo/connection.rb

@@ -0,0 +1,29 @@
+class Mingo
+  module Connection
+    attr_writer :db, :collection
+    
+    def db
+      @db || superclass.db
+    end
+    
+    def connect(dbname_or_uri)
+      self.collection = nil
+      self.db = if dbname_or_uri.index('mongodb://') == 0
+        connection = Mongo::Connection.from_uri(dbname_or_uri)
+        connection.db(connection.auths.last['db_name'])
+      else
+        Mongo::Connection.new.db(dbname_or_uri)
+      end
+    end
+    
+    def collection_name
+      self.name
+    end
+    
+    def collection
+      @collection ||= db.collection(collection_name).tap { |col|
+        col.extend Cursor::CollectionPlugin
+      }
+    end
+  end
+end

data/lib/mingo/cursor.rb

@@ -1,11 +1,10 @@
 class Mingo
+  # Custom Cursor subclass.
   # TODO: contribute this to the official driver
   class Cursor < Mongo::Cursor
     module CollectionPlugin
-      def find(selector={}, opts={})
-        opts = opts.dup
-        convert = opts.delete(:convert)
-        cursor = Cursor.from_mongo(super(selector, opts), convert)
+      def find(*args)
+        cursor = Cursor.from_mongo(super(*args))
         
         if block_given?
           yield cursor
@@ -17,34 +16,96 @@ class Mingo
       end
     end
     
-    def self.from_mongo(cursor, convert)
-      new(cursor.collection, :convert => convert).tap do |sub|
+    def self.from_mongo(cursor)
+      new(cursor.collection).tap do |sub|
         cursor.instance_variables.each { |ivar|
           sub.instance_variable_set(ivar, cursor.instance_variable_get(ivar))
         }
       end
     end
     
-    def initialize(collection, options={})
-      super
-      @convert = options[:convert]
+    def empty?
+      !has_next?
+    end
+    
+    def by_ids?
+      Hash === selector[:_id] && selector[:_id]["$in"]
     end
     
     def next_document
-      convert_document super
+      if !@query_run && by_ids? && !order
+        limit_ids do
+          preload_cache
+          sort_cache_by_ids
+        end
+      end
+      super
     end
     
-    def empty?
-      !has_next?
+    def reverse
+      check_modifiable
+      if by_ids? and !order
+        selector[:_id]["$in"] = selector[:_id]["$in"].reverse
+        self
+      elsif order && (!(Array === order) || !(Array === order.first) || order.size == 1)
+        if Array === order
+          field, dir = *order.flatten
+          dir = Mongo::Conversions::ASCENDING_CONVERSION.include?(dir.to_s) ? -1 : 1
+        else
+          field = order
+          dir = -1
+        end
+        sort(field, dir)
+      else
+        raise "can't reverse complex query"
+      end
     end
     
     private
     
-    def convert_document(doc)
-      if @convert.nil? or doc.nil? then doc
-      elsif @convert.respond_to?(:call) then @convert.call(doc)
-      else @convert.new(doc)
+    def limit_ids
+      if @limit > 0 || @skip > 0
+        ids = selector[:_id]["$in"]
+        old_skip = @skip
+        selector[:_id]["$in"] = ids[@skip, @limit > 0 ? @limit : ids.size]
+        @skip = 0
+        begin
+          yield
+        ensure
+          @skip = old_skip
+          selector[:_id]["$in"] = ids
+        end
+      else
+        yield
+      end
+    end
+    
+    def preload_cache
+      begin
+        refresh
+      end until @cursor_id.zero? || closed? || @n_received.to_i < 1
+    end
+    
+    def sort_cache_by_ids
+      ids = selector[:_id]["$in"]
+      results = []
+      
+      index = @cache.inject({}) do |all, doc|
+        if doc["$err"]
+          results << doc
+        else
+          all[doc["_id"]] = doc
+        end
+        all
+      end
+      
+      ids.each do |id|
+        if doc = index[id]
+          results << doc
+        end
       end
+      
+      @cache = results
     end
   end
 end

data/lib/mingo/finders.rb

@@ -0,0 +1,17 @@
+class Mingo
+  module Finders
+    def first(id_or_selector = nil, options = {})
+      unless id_or_selector.nil? or Hash === id_or_selector
+        id_or_selector = BSON::ObjectId[id_or_selector]
+      end
+      options = { :transformer => lambda {|doc| self.new(doc)} }.update(options)
+      collection.find_one(id_or_selector, options)
+    end
+    
+    def find(selector = {}, options = {}, &block)
+      selector = {:_id => {'$in' => selector}} if Array === selector
+      options = { :transformer => lambda {|doc| self.new(doc)} }.update(options)
+      collection.find(selector, options, &block)
+    end
+  end
+end

data/lib/mingo/many_proxy.rb

@@ -71,8 +71,8 @@ class Mingo
       !!@loaded
     end
     
-    def find_by_ids(ids)
-      @model.find_by_ids(ids, {}, find_options)
+    def find(selector = {}, options = {}, &block)
+      @model.find(selector, find_options.merge(options), &block)
     end
     
     def respond_to?(method, priv = false)
@@ -122,7 +122,7 @@ class Mingo
         decorate_block = self.class.decorate_each
         
         if decorator or decorate_block
-          {:convert => lambda { |doc|
+          {:transformer => lambda { |doc|
             @model.new(doc).tap do |obj|
               obj.extend decorator if decorator
               if decorate_block
@@ -152,7 +152,7 @@ class Mingo
   
     def load_collection
       @loaded ||= if self.object_ids.empty? then []
-      else find_by_ids(self.object_ids)
+      else find(self.object_ids)
       end
     end
   

data/lib/mingo/pagination.rb

@@ -0,0 +1,29 @@
+require 'will_paginate/finders/base'
+
+class Mingo
+  module Pagination
+    def self.extended(base)
+      klass = base::Cursor
+      unless klass.instance_methods.map(&:to_sym).include? :paginate
+        klass.send(:include, PaginatedCursor)
+      end
+    end
+    
+    def paginate(options)
+      find.paginate(options)
+    end
+    
+    module PaginatedCursor
+      include WillPaginate::Finders::Base
+
+      def wp_query(options, pager, args)
+        self.limit pager.per_page
+        self.skip pager.offset
+        pager.replace self.to_a
+        pager.total_entries = self.count unless pager.total_entries
+      end
+    end
+  end
+  
+  extend Pagination
+end

data/lib/mingo/persistence.rb

@@ -39,7 +39,7 @@ class Mingo
       end
 
       def reload
-        doc = self.class.first(id, :convert => nil)
+        doc = self.class.first(id, :transformer => nil)
         replace doc
       end
 

data/lib/mingo.rb

@@ -18,78 +18,27 @@ class Mingo < Hashie::Dash
   extend ActiveModel::Translation
   
   autoload :Cursor,       'mingo/cursor'
+  autoload :Connection,   'mingo/connection'
+  autoload :Finders,      'mingo/finders'
   autoload :ManyProxy,    'mingo/many_proxy'
   autoload :Persistence,  'mingo/persistence'
   autoload :Callbacks,    'mingo/callbacks'
   autoload :Changes,      'mingo/changes'
   autoload :Timestamps,   'mingo/timestamps'
+  autoload :Pagination,   'mingo/pagination'
   
-  class << self
-    attr_writer :db, :collection
-    
-    def db
-      @db || superclass.db
-    end
-    
-    def connect(dbname_or_uri)
-      self.collection = nil
-      self.db = if dbname_or_uri.index('mongodb://') == 0
-        connection = Mongo::Connection.from_uri(dbname_or_uri)
-        connection.db(connection.auths.last['db_name'])
-      else
-        Mongo::Connection.new.db(dbname_or_uri)
-      end
-    end
-    
-    def collection_name
-      self.name
-    end
-    
-    def collection
-      @collection ||= db.collection(collection_name).tap { |col|
-        col.extend Cursor::CollectionPlugin
-      }
-    end
-    
-    def first(id_or_selector = nil, options = {})
-      unless id_or_selector.nil? or Hash === id_or_selector
-        id_or_selector = BSON::ObjectId[id_or_selector]
-      end
-      collection.find_one(id_or_selector, {:convert => self}.update(options))
-    end
-    
-    def find(selector = {}, options = {}, &block)
-      collection.find(selector, {:convert => self}.update(options), &block)
-    end
-    
-    def find_by_ids(object_ids, query = {}, options = {})
-      find({:_id => {'$in' => object_ids}}.update(query), options)
-    end
-    
-    def find_ordered_ids(object_ids, query = {}, options = {})
-      indexed = find_by_ids(object_ids, query, options).inject({}) do |hash, object|
-        hash[object.id] = object
-        hash
-      end
-      
-      object_ids.map { |id| indexed[id] }
-    end
-    
-    def paginate_ids(object_ids, paginate_options, options = {})
-      object_ids.paginate(paginate_options).tap do |collection|
-        collection.replace find_ordered_ids(collection, {}, options)
-      end
-    end
+  extend Connection
+  extend Finders
+
+  # highly experimental stuff
+  def self.many(property, *args, &block)
+    proxy_class = block_given?? Class.new(ManyProxy, &block) : ManyProxy
+    ivar = "@#{property}"
     
-    def many(property, *args, &block)
-      proxy_class = block_given?? Class.new(ManyProxy, &block) : ManyProxy
-      ivar = "@#{property}"
-      
-      define_method(property) {
-        (instance_variable_defined?(ivar) && instance_variable_get(ivar)) ||
-          instance_variable_set(ivar, proxy_class.new(self, property, *args))
-      }
-    end
+    define_method(property) {
+      (instance_variable_defined?(ivar) && instance_variable_get(ivar)) ||
+        instance_variable_set(ivar, proxy_class.new(self, property, *args))
+    }
   end
   
   include Module.new {
@@ -252,6 +201,68 @@ if $0 == __FILE__
       one_dup.should == one
     end
     
+    it "returns a custom cursor" do
+      cursor = described_class.collection.find({})
+      cursor.should respond_to(:empty?)
+    end
+    
+    context "cursor reverse" do
+      it "can't reverse no order" do
+        lambda {
+          described_class.find({}).reverse
+        }.should raise_error
+      end
+
+      it "reverses simple order" do
+        cursor = described_class.find({}, :sort => :name).reverse
+        cursor.order.should == [[:name, -1]]
+      end
+
+      it "reverses simple desc order" do
+        cursor = described_class.find({}, :sort => [:name, :desc]).reverse
+        cursor.order.should == [[:name, 1]]
+      end
+
+      it "reverses simple nested desc order" do
+        cursor = described_class.find({}, :sort => [[:name, :desc]]).reverse
+        cursor.order.should == [[:name, 1]]
+      end
+
+      it "can't reverse complex order" do
+        lambda {
+          described_class.find({}, :sort => [[:name, :desc], [:other, :asc]]).reverse
+        }.should raise_error
+      end
+
+      it "reverses find by ids" do
+        cursor = described_class.find([1,3,5]).reverse
+        cursor.selector.should == {:_id => {"$in" => [5,3,1]}}
+      end
+    end
+    
+    context "find by ids" do
+      before :all do
+        @docs = [create, create, create]
+        @doc1, @doc2, @doc3 = *@docs
+      end
+
+      it "orders results by ids" do
+        results = described_class.find([@doc3.id, @doc1.id, @doc2.id]).to_a
+        results.should == [@doc3, @doc1, @doc2]
+      end
+
+      it "handles limit + skip" do
+        cursor = described_class.find([@doc3.id, @doc1.id, @doc2.id]).limit(1).skip(2)
+        cursor.to_a.should == [@doc2]
+      end
+
+      it "returns correct count" do
+        cursor = described_class.find([@doc3.id, @doc1.id, @doc2.id]).limit(1).skip(2)
+        cursor.next_document
+        cursor.count.should == 3
+      end
+    end
+    
     def build(*args)
       described_class.new(*args)
     end
@@ -261,7 +272,7 @@ if $0 == __FILE__
     end
     
     def raw_doc(selector)
-      described_class.first(selector, :convert => nil)
+      described_class.first(selector, :transformer => nil)
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mingo
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-04-26 00:00:00.000000000Z
+date: 2011-06-19 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mongo
-  requirement: &2157911220 !ruby/object:Gem::Requirement
+  requirement: &70206780980160 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '1.3'
   type: :runtime
   prerelease: false
-  version_requirements: *2157911220
+  version_requirements: *70206780980160
 - !ruby/object:Gem::Dependency
   name: hashie
-  requirement: &2157910740 !ruby/object:Gem::Requirement
+  requirement: &70206780979680 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,7 +32,7 @@ dependencies:
         version: 0.4.0
   type: :runtime
   prerelease: false
-  version_requirements: *2157910740
+  version_requirements: *70206780979680
 description: Mingo is a minimal document-object mapper for MongoDB.
 email: mislav.marohnic@gmail.com
 executables: []
@@ -42,8 +42,11 @@ files:
 - Rakefile
 - lib/mingo/callbacks.rb
 - lib/mingo/changes.rb
+- lib/mingo/connection.rb
 - lib/mingo/cursor.rb
+- lib/mingo/finders.rb
 - lib/mingo/many_proxy.rb
+- lib/mingo/pagination.rb
 - lib/mingo/persistence.rb
 - lib/mingo/timestamps.rb
 - lib/mingo.rb
@@ -67,9 +70,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.7.2
+rubygems_version: 1.8.5
 signing_key: 
 specification_version: 3
 summary: Minimal Mongo
 test_files: []
-has_rdoc: