mongous 0.1.5 → 0.3.0

data/lib/mongous/base.rb

@@ -50,6 +50,36 @@ module Mongous
       self.class_variable_set( :@@client, _client )
     end
 
+    def attach!( *names )
+      raise  Mongous::Error, "missing argument."   if names.empty?
+
+      names.each do |name|
+        case  name
+        when  String
+        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
+
+        Object.class_eval <<-CLASS
+          class #{name}
+            include Mongous::Document
+          end
+        CLASS
+      end
+    end
+ 
     def client
       self.class_variable_get( :@@client )    rescue  nil
     end

data/lib/mongous/document.rb

@@ -26,33 +26,66 @@ module Mongous
       end
     end
 
-    def having?( value )
-      case  value
+    def having?( label )
+      case  label
       when  NilClass
         false
       when  String
-        !value.strip.empty?
+        !label.strip.empty?
       else
         true
       end
     end
 
+    def getvalue_or_callproc( value_or_proc )
+      case  value_or_proc
+      when  Proc
+        value_or_proc.call
+      else
+        value_or_proc
+      end
+    end
+
     def save
+      if  @doc["_id"].nil? || self.class.collection.find( { "_id"=> @doc["_id"] } ).count == 0
+        savemode  =  :create
+      else
+        savemode  =  :update
+      end
+
       self.class.fields.each do |label, field|
-        _must  =  field[:_args].include?(:must)
+        default_value  =  getvalue_or_callproc( field[:default] )
+        _must  =  field[:_attrs].include?(:must)
         if  @doc.has_key?(label)
-          if  _must  &&  !having?( @doc[label] )
-            raise  Mongous::Error, "must and not having field. : #{ label }"
+          if  !having?( @doc[label] )
+            if  default_value
+              self[label]  =  default_value
+            elsif  _must
+              raise  Mongous::Error, "must but unassigned field. : #{ label }"
+            elsif  self.class.symbols[:strict]
+              self[label]  =  nil
+            end
           end
         else
-          if  block  =  field[:_block]
-            self[label]  =  block.call
+          if  default_value
+            self[label]  =  default_value
           elsif  _must
-            raise  Mongous::Error, "must and unassigned field. : #{ label }"
+            raise  Mongous::Error, "must but unassigned field. : #{ label }"
           elsif  self.class.symbols[:strict]
             self[label]  =  nil
           end
         end
+
+        case  savemode
+        when  :create
+          if  create_value  =  getvalue_or_callproc( field[:create] )
+            self[label]  =  create_value
+          end
+        when  :update
+          if  update_value  =  getvalue_or_callproc( field[:update] )
+            self[label]  =  update_value
+          end
+        end
       end
 
       self.class.blocks.each do |call_from, block|
@@ -61,23 +94,29 @@ module Mongous
         end
       end
 
-      if  @doc["_id"]
-        _filter  =  { "_id"=> @doc["_id"] }
-        if  self.class.collection.find( _filter ).first
-          self.class.collection.update_one( _filter, { '$set' => @doc } )
-          return  self
-        end
+      case  savemode
+      when  :create
+        self.class.collection.insert_one( @doc )
+      when  :update
+        self.class.collection.update_one( { "_id"=> @doc["_id"] }, { '$set' => @doc } )
       end
-
-      self.class.collection.insert_one( @doc )
       self
     end
 
+    def to_hash
+      @doc.dup
+    end
+
+    def to_json
+      @doc.to_json
+    end
+
     def []( label )
       label  =  label.to_s
 
       if  self.class.symbols[:strict]
-        if  !self.class.fields.keys.include?(label)
+        labels  =  ["_id"] + self.class.fields.keys
+        if  !labels.include?( label )
           raise  Mongous::Error, "undefined field. : #{ label }"
         end
       end
@@ -108,18 +147,18 @@ module Mongous
       return  @doc[label]  =  value    if field.nil?
 
       types  =  []
-      if  args  =  field[:_args]  ||  []
-        args.each do |arg|
-          if  arg.class == Class
-            types  <<  arg
-            args  -=  [arg]
+      if  attrs  =  field[:_attrs]  ||  []
+        attrs.each do |attr|
+          if  attr.class == Class
+            types  <<  attr
+            attrs  -=  [attr]
             break
           end
         end
       end
 
       if  !types.empty?
-        if  !(args & [:must, :not_null]).empty?
+        if  !(attrs & [:must, :not_null]).empty?
           if  !types.include?( value.class )
             raise  Mongous::Error, "invalid type. : #{ label } : #{ value.class }"
           end
@@ -129,7 +168,7 @@ module Mongous
           end
         end
       else
-        if  !(args & [:must, :not_null]).empty?
+        if  !(attrs & [:must, :not_null]).empty?
           if  [NilClass].include?( value.class )
             raise  Mongous::Error, "invalid type. : #{ label } : #{ value.class }"
           end
@@ -138,19 +177,23 @@ module Mongous
 
       @doc[label]  =  value
 
-      args.each do |arg|
-        case  arg
+      attrs.each do |attr|
+        case  attr
         when  Proc
-          if  !self.instance_eval( &arg )
+          if  !self.instance_eval( &attr )
             raise  Mongous::Error, "violation detected. : #{ label } : #{ value }"
           end
         when  Array
-          if  !arg.include?( value )
-            raise  Mongous::Error, "not include. : #{ label } :#{ value }"
+          if  !attr.include?( value )
+            raise  Mongous::Error, "not include. : #{ label } : #{ value }"
           end
         when  Range
-          if  !arg.cover?( value )
-            raise  Mongous::Error, "out of range. : #{ label } :#{ value }"
+          if  !attr.cover?( value )
+            raise  Mongous::Error, "out of range. : #{ label } : #{ value }"
+          end
+        when  Regexp
+          if  !attr.match( value )
+            raise  Mongous::Error, "unmatch regexp. : #{ label } : #{ value }"
           end
         end
       end

data/lib/mongous/extention.rb

@@ -10,7 +10,7 @@ module Mongous
       end
     end
 
-    def set_client( _client )
+    def client=( _client )
       m  =  /(.*?):(\d+)/.match( caller()[0] )
       call_from  =  [ m[1], m[2] ].join(":")
       if  !_client.is_a?( Mongo::Client )
@@ -28,7 +28,7 @@ module Mongous
       end
     end
 
-    def set_collection_name( _collection_name )
+    def collection_name=( _collection_name )
       self.class_variable_set( :@@collection_name, _collection_name )
       if self.class_variable_defined?( :@@collection )
         self.remove_class_variable( :@@collection )
@@ -60,34 +60,34 @@ module Mongous
     end
 
     def fields
-      if self.class_variable_defined?( :@@fields )
-        self.class_variable_get( :@@fields )
-      else
-        self.class_variable_set( :@@fields, {} )
-      end
+      self_class_variable( :@@fields, {} )
     end
 
     def symbols
-      if self.class_variable_defined?( :@@symbols )
-        self.class_variable_get( :@@symbols )
-      else
-        self.class_variable_set( :@@symbols, {} )
-      end
+      self_class_variable( :@@symbols, {} )
     end
 
     def blocks
-      if self.class_variable_defined?( :@@blocks )
-        self.class_variable_get( :@@blocks )
-      else
-        self.class_variable_set( :@@blocks, {} )
-      end
+      self_class_variable( :@@blocks, {} )
     end
 
     def indexes
-      if self.class_variable_defined?( :@@indexes )
-        self.class_variable_get( :@@indexes )
+      self_class_variable( :@@indexes, [] )
+    end
+
+    def filters
+      self_class_variable( :@@filters, {} )
+    end
+
+    def defaults
+      self_class_variable( :@@defaults, {} )
+    end
+
+    def self_class_variable( symbol, default )
+      if self.class_variable_defined?( symbol )
+        self.class_variable_get( symbol )
       else
-        self.class_variable_set( :@@indexes, [] )
+        self.class_variable_set( symbol, default )
       end
     end
 
@@ -99,53 +99,62 @@ module Mongous
       self.collection.find( conditios, options )
     end
 
-    def field( label, *args, **opts, &block )
+    def field( symbol, *attrs, **items )
       m  =  /(.*?):(\d+)/.match( caller()[0] )
       call_from  =  [ m[1], m[2] ].join(":")
 
-      args.each do |arg|
-        if klass  =  arg.class 
-          if ![Class, Range, Array, Proc, Symbol].include?(klass)
-            raise  Mongous::Error, "field error. :  #{arg} on #{ label } at #{ call_from }"
+      attrs.each do |attr|
+        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
         end
       end
 
-      opts.each do |key, value|
-        case  key
-        when  :default
-          case  value
-          when  Proc, String, Numeric
-          else
-            raise  Mongous::Error, "field error. : #{key} on #{ label } at #{ call_from }"
-          end
-        end
+      items.each do |key, value|
+        next    if [:default, :create, :update].include?(key) && [Proc, String, Numeric].include?(value.class)
+
+        raise  Mongous::Error, "'field' options error. : #{key} on #{ symbol } at #{ call_from }"
       end
 
-      opts[:_args]  =  args
-      opts[:_block]  =  block
-      fields[label.to_s]  =  opts
+      items[:_attrs]  =  attrs
+      fields[symbol.to_s]  =  items
     end
 
-    def verify( *syms, &block )
-      if !syms.empty?
-        syms.each do |sym|
-          symbols[sym]  =  true
+    def verify( *directives, &block )
+      if !directives.empty?
+        directives.each do |directive|
+          symbols[directive]  =  true
         end
       elsif block
         m  =  /(.*?):(\d+)/.match( caller()[0] )
         call_from  =  [ m[1], m[2] ].join(":")
         blocks[call_from]  =  block
+      else
+        raise  Mongous::Error, "'verify' arguments error. need directives or block."
       end
     end
 
-    def index( *syms, **opts )
-      opts[:background]  =  true    unless opts.has_key?(:background)
+    def index( *symbols, **options )
+      options[:background]  =  true    unless  options.has_key?(:background)
       keys  =  {}
-      syms.each do |sym|
-        keys[sym]  =  1
+      symbols.each do |symbol|
+        keys[symbol]  =  1
+      end
+      indexes.push  <<  [keys, options]
+    end
+
+    def filter( symbol, filter_or_condition )
+      case  filter_or_condition
+      when  Filter
+        filters[symbol]  =  filter_or_condition.to_condition
+      when  Hash
+        filters[symbol]  =  filter_or_condition
+      else
+        m  =  /(.*?):(\d+)/.match( caller()[0] )
+        call_from  =  [ m[1], m[2] ].join(":")
+        raise  Mongous::Error, "'filter' arguments error. : #{symbol}, #{filter_or_condition} at #{ call_from }"
       end
-      indexes.push  <<  [keys, opts]
     end
   end
 end

data/lib/mongous/filter.rb

@@ -1,6 +1,11 @@
 
 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
@@ -20,55 +25,53 @@ module Mongous
       self.collection.delete_many({})
     end
 
-    def filter( **conditions )
-      Filter.new( self ).filter( conditions )
+    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?
 
-      filter  ||=  conditions
-      condition  =  case filter
-      when  Hash
-        filter
-      when  Filter
-        filter.to_condition
-      else
-        raise  Mongous::Error, "Invalid args for #{self}.not. : #{filter}"
-      end
-      Filter.new( self ).filter({"$nor" => [condition]})
+      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|
-        case  filter
-        when  Hash
-          filter
-        when  Filter
-          filter.to_condition
-        else
-          raise  Mongous::Error, "Invalid args for #{self}.and. : #{filter}"
-        end
+        normalize( filter, {} )
       end
-      Filter.new( self ).filter({"$and" => conditions})
+      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|
-        case  filter
-        when  Hash
-          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
-        else
-          raise  Mongous::Error, "Invalid args for #{self}.or. : #{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
-      Filter.new( self ).filter({"$or" => conditions})
     end
   end
 end
@@ -81,7 +84,7 @@ module Mongous
       @option  =  {}
     end
 
-    def filter( conditions )
+    def where( conditions )
       hash  =  {}
       conditions.each do |key, item|
         case  key
@@ -126,56 +129,54 @@ module Mongous
     end
 
     def option( _option )
-      self.option!( _option )
-      self.dup
-    end
-
-    def option!( _option )
       @option.merge!( _option )
+      self.dup
     end
 
     def projection( _projection )
-      self.projection!( _projection )
+      @projection  =  _projection
       self.dup
     end
     alias  :select  :projection
 
-    def projection!( _projection )
-      @projection  =  _projection
-    end
-
     def sort( _sort )
-      self.sort!( _sort )
+      @sort  =  _sort
       self.dup
     end
     alias  :order  :sort
 
-    def sort!( _sort )
-      @sort  =  _sort
-    end
+    def []( nth_or_range, len = nil )
+      case  nth_or_range
+      when  Integer
+        @skip  =  nth_or_range
 
-    def skip( _skip )
-      self.skip!( _skip )
-      self.dup
-    end
-    alias  :offset  :skip
+        if  len
+          raise  Mongous::Error, "invalid len. :  #{ len }"    if  !len.is_a? Integer || len <= 0
+          @limit  =  len
+        end
 
-    def skip!( _skip )
-      @skip  =  _skip
-    end
+      when  Range
+        from  =  nth_or_range.begin
+        raise  Mongous::Error, "invalid range. :  #{ nth_or_range }"    unless  from.is_a? Integer
 
-    def limit( _limit )
-      self.limit!( _limit )
-      self.dup
-    end
+        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
 
-    def limit!( _limit )
-      @limit  =  _limit
+      self.dup
     end
 
     def do_find
       _filter  =  @filter
-      _option  =  @option
+      _option  =  @option.dup
       _option[:projection]  =  @projection    if @projection
       found  =  @klass.collection.find( _filter, _option )
       found  =  found.sort( @sort )    if  @sort
@@ -184,6 +185,28 @@ module Mongous
       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
@@ -200,8 +223,7 @@ module Mongous
     end
 
     def delete
-      _filter  =  @filter
-      @klass.collection.delete_many( _filter )
+      @klass.collection.delete_many( @filter )
     end
   end
 end