mongous 0.2.1 → 0.4.4

data/Rakefile

@@ -13,7 +13,7 @@ class Bundler::GemHelper
     dest_path  =  File.join(dir, "#{name}-#{version}.zip")
     cmnd  =  "git archive --format zip --prefix=#{name}/ HEAD > #{dest_path}"
 
-    out, code = sh_with_status( cmnd )
+    _, code = sh_with_status( cmnd )
     raise "Couldn't archive gem,"  unless  code == 0
 
     Bundler.ui.confirm "#{name} #{version} archived to #{dest_path}."
@@ -23,11 +23,11 @@ class Bundler::GemHelper
     ver  =  version.to_s
 
     cmnd  =  "git push origin  #{ver} "
-    out, code = sh_with_status( cmnd )
+    _, code = sh_with_status( cmnd )
     raise "Couldn't git push origin."  unless  code == 0
 
     cmnd  =  "git push "
-    out, code = sh_with_status( cmnd )
+    _, code = sh_with_status( cmnd )
     raise "Couldn't git push."         unless  code == 0
 
     Bundler.ui.confirm "Git Push #{ver}."
@@ -43,15 +43,15 @@ class Bundler::GemHelper
     end
 
     cmnd  =  "git add  #{version_pathname} "
-    out, code = sh_with_status( cmnd )
+    _, code = sh_with_status( cmnd )
     raise "Couldn't git add,"  unless  code == 0
 
     cmnd  =  "git commit -m  '#{new_version}' "
-    out, code = sh_with_status( cmnd )
+    _, code = sh_with_status( cmnd )
     raise "Couldn't git commit."  unless  code == 0
 
     cmnd  =  "git tag        #{new_version} "
-    out, code = sh_with_status( cmnd )
+    _, code = sh_with_status( cmnd )
     raise "Couldn't git tag."          unless  code == 0
 
     Bundler.ui.confirm "Update Tags to #{new_version}."
@@ -80,14 +80,14 @@ Bundler::GemHelper.new(Dir.pwd).instance_eval do
 
   desc "Update Version Minor"
   task 'minor' do
-    major, minor, tiny  =  version.to_s.split('.')
+    major, minor, _tiny  =  version.to_s.split('.')
     new_version  =  [major, minor.to_i + 1, 0].join('.')
     update_version( new_version )
   end
 
   desc "Update Version Major"
   task 'major' do
-    major, minor, tiny  =  version.to_s.split('.')
+    major, _minor, _tiny  =  version.to_s.split('.')
     new_version  =  [major.to_i + 1, 0, 0].join('.')
     update_version( new_version )
   end

data/_Gemfile.lock

@@ -0,0 +1,38 @@
+PATH
+  remote: .
+  specs:
+    mongous (0.4.3)
+      mongo
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    bson (4.11.1)
+    diff-lcs (1.4.4)
+    mongo (2.14.0)
+      bson (>= 4.8.2, < 5.0.0)
+    rake (13.0.3)
+    rspec (3.10.0)
+      rspec-core (~> 3.10.0)
+      rspec-expectations (~> 3.10.0)
+      rspec-mocks (~> 3.10.0)
+    rspec-core (3.10.1)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-mocks (3.10.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-support (3.10.1)
+
+PLATFORMS
+  x86_64-linux
+
+DEPENDENCIES
+  mongous!
+  rake
+  rspec
+
+BUNDLED WITH
+   2.2.6

data/lib/mongous/base.rb

@@ -11,7 +11,7 @@ module Mongous
     def connect( hosts_or_uri = nil, file: nil, mode: nil, loglevel: nil, **options )
       case  hosts_or_uri
       when  Array, String
-        ;
+        hosts_or_uri
 
       when  NilClass
         if file
@@ -46,19 +46,63 @@ module Mongous
     end
 
     def connect!( hosts_or_uri = nil, **options )
-      _client  =  connect( hosts_or_uri, **options )
-      self.class_variable_set( :@@client, _client )
+      client_  =  connect( hosts_or_uri, **options )
+      self.class_variable_set( :@@client, client_ )
     end
 
+    def document!( *names, **opts )
+      raise  Mongous::Error, "missing argument."   if names.empty?
+
+      names.each do |name|
+        case  name
+        when  String
+          name
+        when  Symbol
+          name  =  name.to_s
+        else
+          raise  Mongous::Error, "type invalid. :  #{ name }"
+        end
+
+        raise  Mongous::Error, "missing argument."   unless  /^[A-Z]/.match(name)
+
+        if  Object.const_defined?( name )
+          if  Object.const_get( name ).include?( Mongous::Document )
+            Object.class_eval{ remove_const( name ) }
+          else
+            raise  Mongous::Error, "type invalid. :  #{ Object.class_eval(name) }"
+          end
+        end
+
+        klass  =  Object.class_eval <<-CLASS
+          class #{name}
+            include Mongous::Document
+          end
+        CLASS
+
+        if opts[:timestamp]
+          klass.class_eval do
+            field  :created_at, Time, create: proc{ Time.now }
+            field  :updated_at, Time, update: proc{ Time.now }
+            index  :created_at
+            index  :updated_at
+          end
+        end
+      end
+    end
+    alias  :attach!  :document!
+ 
     def client
-      self.class_variable_get( :@@client )    rescue  nil
+      if not self.class_variable_defined?( :@@client )
+        connect!
+      end
+      self.class_variable_get( :@@client )
     end
 
-    def client=( _client )
-      if  !_client.is_a?( ::Mongo::Client )
-        raise  Mongous::Error, "type invalid. :  #{ _client }"
+    def client=( new_client )
+      if not new_client.is_a?( ::Mongo::Client )
+        raise  Mongous::Error, "type invalid. :  #{ new_client }"
       end
-      self.class_variable_set( :@@client, _client )
+      self.class_variable_set( :@@client, new_client )
     end
 
     def loger

data/lib/mongous/document.rb

@@ -15,7 +15,7 @@ module Mongous
       end
     end
 
-    def method_missing( sym, *args, **opts, &block )
+    def method_missing( sym, *args, **_opts, &_block )
       m  =  /\A(\w+)([=])?\Z/.match( sym.to_s )
       if  args.size == 0 && m[2].nil?
         self[ m[1] ]
@@ -55,12 +55,12 @@ module Mongous
 
       self.class.fields.each do |label, field|
         default_value  =  getvalue_or_callproc( field[:default] )
-        _must  =  field[:_attrs].include?(:must)
+        must  =  field[:_attrs].include?(:must)
         if  @doc.has_key?(label)
           if  !having?( @doc[label] )
             if  default_value
               self[label]  =  default_value
-            elsif  _must
+            elsif  must
               raise  Mongous::Error, "must but unassigned field. : #{ label }"
             elsif  self.class.symbols[:strict]
               self[label]  =  nil
@@ -69,7 +69,7 @@ module Mongous
         else
           if  default_value
             self[label]  =  default_value
-          elsif  _must
+          elsif  must
             raise  Mongous::Error, "must but unassigned field. : #{ label }"
           elsif  self.class.symbols[:strict]
             self[label]  =  nil
@@ -78,11 +78,11 @@ module Mongous
 
         case  savemode
         when  :create
-          if  create_value  =  getvalue_or_callproc( field[:create] )
+          if ( create_value  =  getvalue_or_callproc( field[:create] ) )
             self[label]  =  create_value
           end
         when  :update
-          if  update_value  =  getvalue_or_callproc( field[:update] )
+          if ( update_value  =  getvalue_or_callproc( field[:update] ) )
             self[label]  =  update_value
           end
         end
@@ -100,15 +100,23 @@ module Mongous
       when  :update
         self.class.collection.update_one( { "_id"=> @doc["_id"] }, { '$set' => @doc } )
       end
-
       self
     end
 
+    def to_hash
+      @doc.dup
+    end
+
+    def to_json( **opts )
+      ::JSON.generate( @doc, **opts )
+    end
+
     def []( label )
       label  =  label.to_s
 
       if  self.class.symbols[:strict]
-        if  !(self.class.fields.keys.include?(label) || (label == "_id"))
+        labels  =  ["_id"] + self.class.fields.keys
+        if  !labels.include?( label )
           raise  Mongous::Error, "undefined field. : #{ label }"
         end
       end
@@ -136,10 +144,13 @@ module Mongous
       end
 
       field  =  self.class.fields[label]
-      return  @doc[label]  =  value    if field.nil?
+      if field.nil?
+        @doc[label]  =  value
+        return
+      end
 
       types  =  []
-      if  attrs  =  field[:_attrs]  ||  []
+      if ( attrs  =  field[:_attrs]  ||  [] )
         attrs.each do |attr|
           if  attr.class == Class
             types  <<  attr

data/lib/mongous/extention.rb

@@ -5,87 +5,93 @@ module Mongous
       if self.class_variable_defined?( :@@client )
         self.class_variable_get( :@@client )
       else
-        _client  =  Mongous.client
-        self.class_variable_set( :@@client, _client )
+        new_client  =  Mongous.client
+        self.class_variable_set( :@@client, new_client )
       end
     end
 
-    def client=( _client )
-      m  =  /(.*?):(\d+)/.match( caller()[0] )
-      call_from  =  [ m[1], m[2] ].join(":")
-      if  !_client.is_a?( Mongo::Client )
-        raise  Mongous::Error, "type invalid. :  #{ _client }"
+    def client=( new_client )
+      if  !new_client.is_a?( Mongo::Client )
+        m  =  /(.*?):(\d+)/.match( caller()[0] )
+        call_from  =  [ m[1], m[2] ].join(":")
+        raise  Mongous::Error, "type invalid. :  #{ new_client } at #{ call_from }"
       end
-      self.class_variable_set( :@@client, _client )
+      self.class_variable_set( :@@client, new_client )
     end
 
     def collection_name
       if self.class_variable_defined?( :@@collection_name )
-        self.class_variable_get( :@@collection_name )
-      else
-        _client_name  =  self.name
-        self.class_variable_set( :@@collection_name, _client_name )
+        value  =  self.class_variable_get( :@@collection_name )
+        return  value    if value
       end
+
+      self.class_variable_set( :@@collection_name, self.name )
     end
 
-    def collection_name=( _collection_name )
-      self.class_variable_set( :@@collection_name, _collection_name )
+    def collection_name=( new_collection_name )
+      self.class_variable_set( :@@collection_name, new_collection_name )
       if self.class_variable_defined?( :@@collection )
         self.remove_class_variable( :@@collection )
       end
     end
 
-    def collection
-      if self.class_variable_defined?( :@@collection )
-        if  _collection  =  self.class_variable_get( :@@collection )
-          return  _collection
+    def collection( temp_collection_name = nil )
+      if  temp_collection_name.nil?
+        if self.class_variable_defined?( :@@collection )
+          if ( new_collection  =  self.class_variable_get( :@@collection ) )
+            return  new_collection
+          end
         end
+        new_collection_name  =  collection_name
+      else
+        new_collection_name  =  temp_collection_name
       end
+      new_client  =  client
 
-      _collection_name  =  collection_name
-      _client  =  client
-
-      if  _client.database.collection_names.include?( _collection_name )
-        _collection  =  _client[ _collection_name ]
+      if  new_client.database.collection_names.include?( new_collection_name )
+        new_collection  =  new_client[ new_collection_name ]
       else
-        _collection  =  _client[ _collection_name ]
-        _collection.create
+        new_collection  =  new_client[ new_collection_name ]
+        new_collection.create
       end
 
       indexes.each do |keys, opts|
-        _collection.indexes.create_one( keys, opts )    rescue  nil
+        new_collection.indexes.create_one( keys, opts )    rescue  nil
       end
 
-      self.class_variable_set( :@@collection, _collection )
+      self.class_variable_set( :@@collection, new_collection )    if temp_collection_name.nil?
+      new_collection
     end
 
     def fields
-      self_class_variable( :@@fields, {} )
+      setup_class_variable( :@@fields, {} )
     end
 
     def symbols
-      self_class_variable( :@@symbols, {} )
+      setup_class_variable( :@@symbols, {} )
     end
 
     def blocks
-      self_class_variable( :@@blocks, {} )
+      setup_class_variable( :@@blocks, {} )
     end
 
     def indexes
-      self_class_variable( :@@indexes, [] )
+      setup_class_variable( :@@indexes, [] )
     end
 
     def filters
-      self_class_variable( :@@filters, {} )
+      setup_class_variable( :@@filters, {} )
     end
 
     def defaults
-      self_class_variable( :@@defaults, {} )
+      setup_class_variable( :@@defaults, {} )
     end
 
-    def self_class_variable( symbol, default )
+    def setup_class_variable( symbol, default = {}, &block )
       if self.class_variable_defined?( symbol )
         self.class_variable_get( symbol )
+      elsif block_given?
+        self.class_variable_set( symbol, block.call )
       else
         self.class_variable_set( symbol, default )
       end
@@ -95,6 +101,10 @@ module Mongous
       self.new( **doc ).save
     end
 
+    def drop
+      self.collection.drop
+    end
+
     def find( conditios = {}, options = {} )
       self.collection.find( conditios, options )
     end
@@ -104,7 +114,7 @@ module Mongous
       call_from  =  [ m[1], m[2] ].join(":")
 
       attrs.each do |attr|
-        if klass  =  attr.class 
+        if ( klass  =  attr.class )
           if ![Class, Range, Array, Regexp, Proc, Symbol].include?(klass)
             raise  Mongous::Error, "'field' arguments error. : #{ attr } on #{ symbol } at #{ call_from }"
           end

data/lib/mongous/filter.rb

@@ -1,230 +1,316 @@
-
-module Mongous
-  module Extention
-    def count
-#     self.collection.find.count
-      self.collection.estimated_document_count
-    end
-
-    def first
-      doc  =  self.collection.find.first
-      self.new( **doc )    if doc
-    end
-
-    def all
-      self.collection.find.map do |doc|
-        self.new( **doc )
-      end
-    end
-
-    def each( &block )
-      all.each( &block )
-    end
-
-    def delete
-      self.collection.delete_many({})
-    end
-
-    def where( filter = nil, **conditions )
-      condition  =  normalize( filter, conditions )
-      Filter.new( self ).where( condition )
-    end
-
-    def not( filter = nil, **conditions )
-      raise  Mongous::Error, "Unset args for #{self}.not."    if filter.nil? && conditions.empty?
-
-      condition  =  normalize( filter, conditions )
-      Filter.new( self ).where({"$nor" => [condition]})
-    end
-
-    def and( *filters )
-      raise  Mongous::Error, "Unset args for #{self}.and."    if filters.empty?
-
-      conditions  =  filters.map do |filter|
-        normalize( filter, {} )
-      end
-      Filter.new( self ).where({"$and" => conditions})
-    end
-
-    def or( *filters )
-      raise  Mongous::Error, "Unset args for #{self}.or."    if filters.empty?
-
-      conditions  =  filters.map do |filter|
-        normalize( filter, {} )
-      end
-      Filter.new( self ).where({"$or" => conditions})
-    end
-
-    def normalize( filter, conditions )
-      condition  =  case  filter
-      when  Filter
-        filter.to_condition
-      when  Symbol
-        case  _filter  =  filters[filter]
-        when  Filter
-          _filter.to_condition
-        when  Hash
-          _filter
-        end
-      when  NilClass
-        Filter.new( self ).where( **conditions ).to_condition
-      else
-        caller_method  =  /`(.*?)'/.match( caller()[0] )[1]
-        raise  Mongous::Error, "Invalid args for #{self}.#{ caller_method }. : #{filter}, #{conditions}"
-      end
-    end
-  end
-end
-
-module Mongous
-  class Filter
-    def initialize( klass )
-      @klass  =  klass
-      @filter  =  {}
-      @option  =  {}
-    end
-
-    def where( conditions )
-      hash  =  {}
-      conditions.each do |key, item|
-        case  key
-        when  /\$(and|or|nor)/
-          hash[key]  =  item
-
-        else
-          case  item
-          when  Array
-            hash[key]  =  {"$in"=>item}
-
-          when  Range
-            _begin_oper  =  "$gte"
-            _end_oper  =  item.exclude_end?  ?  "$lt"  :  "$lte"
-
-            if      item.begin  &&   item.end
-              hash[key]  =  { _begin_oper => item.begin, _end_oper => item.end }
-
-            elsif  !item.begin  &&   item.end
-              hash[key]  =  { _end_oper => item.end }
-
-            elsif   item.begin  &&  !item.end
-              hash[key]  =  { _begin_oper => item.begin }
-
-            else
-              raise  Mongous::Error, "invalid range. :  #{ item }"
-
-            end
-
-          else
-            hash[key]  =  item
-
-          end
-        end
-      end
-      @filter.merge!( hash )
-      self.dup
-    end
-
-    def to_condition
-      @filter.dup
-    end
-
-    def option( _option )
-      @option.merge!( _option )
-      self.dup
-    end
-
-    def projection( _projection )
-      @projection  =  _projection
-      self.dup
-    end
-    alias  :select  :projection
-
-    def sort( _sort )
-      @sort  =  _sort
-      self.dup
-    end
-    alias  :order  :sort
-
-    def []( nth_or_range, len = nil )
-      case  nth_or_range
-      when  Integer
-        @skip  =  nth_or_range
-
-        if  len
-          raise  Mongous::Error, "invalid len. :  #{ len }"    if  !len.is_a? Integer || len <= 0
-          @limit  =  len
-        end
-
-      when  Range
-        from  =  nth_or_range.begin
-        raise  Mongous::Error, "invalid range. :  #{ nth_or_range }"    unless  from.is_a? Integer
-
-        to    =  nth_or_range.end
-        raise  Mongous::Error, "invalid range. :  #{ nth_or_range }"    unless  to.is_a? Integer
-
-        to  -=  1    if nth_or_range.exclude_end?
-        @skip  =  from
-        @limit  =  to - from + 1
-
-      else
-        raise  Mongous::Error, "invalid class. :  #{ nth_or_range }"
-
-      end
-
-      self.dup
-    end
-
-    def do_find
-      _filter  =  @filter
-      _option  =  @option.dup
-      _option[:projection]  =  @projection    if @projection
-      found  =  @klass.collection.find( _filter, _option )
-      found  =  found.sort( @sort )    if  @sort
-      found  =  found.skip( @skip )    if  @skip
-      found  =  found.limit( @limit )    if  @limit
-      found
-    end
-
-    def count
-      found  =  @klass.collection.find( @filter )
-      found  =  found.skip( @skip )    if  @skip
-      found  =  found.limit( @limit )    if  @limit
-      _count  =  found.count_documents
-      if  @skip
-        if  @skip > _count
-          0
-        elsif  @limit
-          [_count - @skip, @limit].min
-        else
-          _count - @skip
-        end
-      else
-        if  @limit
-          [_count, @limit].min
-        else
-          _count
-        end
-      end
-    end
-
-    def first
-      doc  =  do_find.first
-      @klass.new( **doc )    if doc
-    end
-
-    def all
-      do_find.map do |doc|
-        @klass.new( **doc )
-      end
-    end
-
-    def each( &block )
-      all.each( &block )
-    end
-
-    def delete
-      @klass.collection.delete_many( @filter )
-    end
-  end
-end
-
+
+module Mongous
+  module Extention
+    def count
+      self.collection.estimated_document_count
+    end
+
+    def all
+      self.collection.find.map do |doc|
+        self.new( **doc )
+      end
+    end
+
+    def each( &block )
+      all.each( &block )
+    end
+
+    def map( &block )
+      all.map( &block )
+    end
+
+    def delete
+      self.collection.delete_many({})
+    end
+
+    def attach( collection_name )
+      Filter.new( self ).attach( collection_name )
+    end
+
+    def []( nth_or_range, len = nil )
+      Filter.new( self )[ nth_or_range, len ]
+    end
+
+    def first
+      Filter.new( self ).first
+    end
+
+    def last
+      Filter.new( self ).last
+    end
+
+    def sort( *keys, **hash )
+      Filter.new( self ).sort( *keys, **hash )
+    end
+
+    def select( *keys, **hash )
+      Filter.new( self ).select( *keys, **hash )
+    end
+
+    def where( filter = nil, **conditions )
+      condition  =  normalize( filter, conditions )
+      Filter.new( self ).where( condition )
+    end
+
+    def not( filter = nil, **conditions )
+      raise  Mongous::Error, "Unset args for #{self}.not."    if filter.nil? && conditions.empty?
+
+      condition  =  normalize( filter, conditions )
+      Filter.new( self ).not( condition )
+    end
+
+    def and( *filters )
+      raise  Mongous::Error, "Unset args for #{self}.and."    if filters.empty?
+
+      conditions  =  filters.map do |filter|
+        normalize( filter, {} )
+      end
+      Filter.new( self ).where({"$and" => conditions})
+    end
+
+    def or( *filters )
+      raise  Mongous::Error, "Unset args for #{self}.or."    if filters.empty?
+
+      conditions  =  filters.map do |filter|
+        normalize( filter, {} )
+      end
+      Filter.new( self ).where({"$or" => conditions})
+    end
+
+    def normalize( filter, conditions )
+      case  filter
+      when  Filter
+        filter.to_condition
+      when  Symbol
+        case  ( new_filter  =  filters[filter] )
+        when  Filter
+          new_filter.to_condition
+        when  Hash
+          new_filter
+        end
+      when  NilClass
+        Filter.new( self ).where( conditions ).to_condition
+      else
+        caller_method  =  /`(.*?)'/.match( caller()[0] )[1]
+        raise  Mongous::Error, "Invalid args for #{self}.#{ caller_method }. : #{filter}, #{conditions}"
+      end
+    end
+  end
+end
+
+module Mongous
+  class Filter
+    def initialize( klass )
+      @klass  =  klass
+      @filter  =  {}
+      @option  =  {}
+    end
+
+    def attach( collection_name )
+      w  =  self.dup
+      w.instance_variable_set( :@collection_name, collection_name.to_s )
+      w
+    end
+
+    def build_condition( conditions )
+      hash  =  {}
+      conditions.each do |key, item|
+        case  key
+        when  /\$(and|or|nor)/
+          hash[key]  =  item
+
+        else
+          case  item
+          when  Array
+            hash[key]  =  {"$in"=>item}
+
+          when  Range
+            begin_oper  =  "$gte"
+            end_oper  =  item.exclude_end?  ?  "$lt"  :  "$lte"
+
+            if      item.begin  &&   item.end
+              hash[key]  =  { begin_oper => item.begin, end_oper => item.end }
+
+            elsif  !item.begin  &&   item.end
+              hash[key]  =  { end_oper => item.end }
+
+            elsif   item.begin  &&  !item.end
+              hash[key]  =  { begin_oper => item.begin }
+
+            else
+              raise  Mongous::Error, "invalid range. :  #{ item }"
+
+            end
+
+          else
+            hash[key]  =  item
+
+          end
+        end
+      end
+      hash
+    end
+
+    def where( conditions = {} )
+      hash  =  build_condition( conditions )
+      w  =  self.dup
+      w.instance_variable_set( :@filter, @filter.merge( hash ) )
+      w
+    end
+
+    def not( conditions = {} )
+      hash  =  build_condition( conditions )
+      w  =  self.dup
+      w.instance_variable_set( :@filter, @filter.merge( {"$nor" => [hash]} ) )
+      w
+    end
+
+    def to_condition
+      @filter.dup
+    end
+
+    def option( new_option )
+      w  =  self.dup
+      w.instance_variable_set( :@option, @option.merge( new_option ) )
+      w
+    end
+
+    def select( *keys, **hash )
+      if not keys.empty?
+        new_projection  =  Hash[ keys.zip( Array.new(keys.length, 1) ) ]
+      elsif not hash.empty?
+        new_projection  =  hash
+      else
+        new_projection  =  nil
+      end
+      w  =  self.dup
+      w.instance_variable_set( :@projection, new_projection )
+      w
+    end
+
+    def sort( *keys, **hash )
+      if not keys.empty?
+        new_sort  =  Hash[ keys.zip( Array.new( keys.length, 1 ) ) ]
+      elsif not hash.empty?
+        new_sort  =  hash
+      else
+        new_sort  =  nil
+      end
+      w  =  self.dup
+      w.instance_variable_set( :@sort, new_sort )
+      w
+    end
+
+    def []( nth_or_range, len = nil )
+      case  nth_or_range
+      when  Integer
+        new_skip  =  nth_or_range
+
+        if  len.is_a?(NilClass)
+          new_limit  =  1
+        elsif  len.is_a?(Integer) && len == 0
+          new_limit  =  nil
+        elsif  len.is_a?(Integer) && len > 0
+          new_limit  =  len
+        else
+          raise  Mongous::Error, "invalid len. :  #{ len }"
+        end
+
+      when  Range
+        from  =  nth_or_range.begin
+        raise  Mongous::Error, "invalid range. :  #{ nth_or_range }"    unless  from.is_a? Integer
+
+        to    =  nth_or_range.end
+        raise  Mongous::Error, "invalid range. :  #{ nth_or_range }"    unless  to.is_a? Integer
+
+        to  -=  1    if nth_or_range.exclude_end?
+        new_skip  =  from
+        new_limit  =  to - from + 1
+
+      else
+        raise  Mongous::Error, "invalid class. :  #{ nth_or_range }"
+
+      end
+
+      w  =  self.dup
+      w.instance_variable_set( :@skip, new_skip )
+      w.instance_variable_set( :@limit, new_limit )
+      w
+    end
+
+    def exec_query
+      new_filter  =  @filter
+      new_option  =  @option.dup
+      new_option[:projection]  =  @projection    if @projection
+      found  =  @klass.collection( @collection_name ).find( new_filter, new_option )
+      found  =  found.sort( @sort )    if  @sort
+      found  =  found.skip( @skip )    if  @skip
+      found  =  found.limit( @limit )    if  @limit
+      found
+    end
+
+    def count
+      found  =  @klass.collection.find( @filter )
+      found  =  found.skip( @skip )    if  @skip
+      found  =  found.limit( @limit )    if  @limit
+      new_count  =  found.count_documents
+      if  @skip
+        if  @skip > new_count
+          0
+        elsif  @limit
+          [new_count - @skip, @limit].min
+        else
+          new_count - @skip
+        end
+      else
+        if  @limit
+          [new_count, @limit].min
+        else
+          new_count
+        end
+      end
+    end
+
+    def first
+      new_filter  =  @filter
+      new_option  =  @option.dup
+      new_option[:projection]  =  @projection    if @projection
+      found  =  @klass.collection( @collection_name ).find( new_filter, new_option )
+      new_order  =  @sort  ||  { _id: 1 }
+      doc  =  found.sort( new_order ).first
+      @klass.new( **doc )    if doc
+    end
+
+    def last
+      new_filter  =  @filter
+      new_option  =  @option.dup
+      new_option[:projection]  =  @projection    if @projection
+      found  =  @klass.collection( @collection_name ).find( new_filter, new_option )
+      new_order  =  {}
+      ( @sort  ||  {_id: 1} ).each do |k,v|
+        new_order[k]  =  - v
+      end
+      doc  =  found.sort( new_order ).first
+      @klass.new( **doc )    if doc
+    end
+
+    def all
+      exec_query.map do |doc|
+        @klass.new( **doc )
+      end
+    end
+
+    def each( &block )
+      all.each( &block )
+    end
+
+    def map( &block )
+      all.map( &block )
+    end
+
+    def delete
+      @klass.collection.delete_many( @filter )
+    end
+  end
+end
+