rethinkdb 1.11.0.2 → 1.12.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9f587abb21c2f7e36f127e616288c54b13dfd301
-  data.tar.gz: 6882be24c8e9299e6e28fd2856807e687a2123e0
+  metadata.gz: eba1925eeec3a40cbebb6209d1f659b7880ac82f
+  data.tar.gz: a84db592ff134e93e9505fb1bc1e84a147643aab
 SHA512:
-  metadata.gz: bf87c17c7361a4fe68ecdf69196a41c253e0177c2d5a7ca308f992dce9c1f419cbad037bf563d5db0417eb9e5253d7350201642276fe0a846b6ecf64706831aa
-  data.tar.gz: 33ee490117e89cfa8cabc2f793dbd08ae6a8050de0ecb5094282c2303eaab8bba804104eda3d6a5f7e4e2f4e13e497ec44aa57e907b004a83008de6de0cc1cb9
+  metadata.gz: 2a31d54964b3086feac437eb843bedbc83cc3c4cdf7999128775b121576488ad6f06c5f03c45397b92d243c6e0000b866fad7d7f5797995f370420eb9d2391f2
+  data.tar.gz: a67cf797dd62f616e0992b913b028b8c8ef919388f90ae54301b1a4ba5730b6a66f9d135cd660368df82137b29af437278ddc6c557806b25fbe10f223d635ac3

data/lib/func.rb

@@ -15,89 +15,95 @@ module RethinkDB
     # only be removed from the argument list and treated as an optarg
     # if it's a Hash.  A positive value is necessary for functions
     # that can take a hash for the last non-optarg argument.
-    # NOTE: we search for the optarg after we apply the rewrite rules below.
-    # For example we need to use orderby not order_by
     @@optarg_offsets = {
       :replace => {:with_block => 0, :without => 1},
       :update => {:with_block => 0, :without => 1},
       :insert => 1,
       :delete => -1,
-      :reduce => -1, :between => 2, :grouped_map_reduce => -1,
-      :table => -1, :table_create => -1,
-      :get_all => -1, :eq_join => -1,
-      :javascript => -1, :filter => {:with_block => 0, :without => 1},
-      :slice => -1, :during => -1, :orderby => -1,
-      :iso8601 => -1, :index_create => -1
+      :reduce => -1,
+      :between => 2,
+      :table => -1,
+      :table_create => -1,
+      :get_all => -1,
+      :eq_join => -1,
+      :javascript => -1,
+      :filter => {:with_block => 0, :without => 1},
+      :slice => -1,
+      :during => -1,
+      :orderby => -1,
+      :group => -1,
+      :iso8601 => -1,
+      :index_create => -1
     }
-    @@rewrites = {
-      :< => :lt, :<= => :le, :> => :gt, :>= => :ge,
-      :+ => :add, :- => :sub, :* => :mul, :/ => :div, :% => :mod,
-      :"|" => :any, :or => :any,
-      :"&" => :all, :and => :all,
-      :order_by => :orderby,
-      :group_by => :groupby,
-      :concat_map => :concatmap,
-      :for_each => :foreach,
-      :js => :javascript,
-      :type_of => :typeof
+    @@method_aliases = {
+      :lt => :<,
+      :le => :<=,
+      :gt => :>,
+      :ge => :>=,
+      :add => :+,
+      :sub => :-,
+      :mul => :*,
+      :div => :/,
+      :mod => :%,
+      :any => [:"|", :or],
+      :all => [:"&", :and],
+      :orderby => :order_by,
+      :concatmap => :concat_map,
+      :foreach => :for_each,
+      :javascript => :js,
+      :typeof => :type_of
     }
-    @@allow_json = {:insert => true}
-    def method_missing(m, *a, &b)
-      unbound_if(m.to_s.downcase != m.to_s, m)
-      bitop = [:"|", :"&"].include?(m) ? [m, a, b] : nil
-      if [:<, :<=, :>, :>=, :+, :-, :*, :/, :%].include?(m)
-        a.each {|arg|
-          if arg.class == RQL && arg.bitop
-            err = "Calling #{m} on result of infix bitwise operator:\n" +
-              "#{arg.inspect}.\n" +
-              "This is almost always a precedence error.\n" +
-              "Note that `a < b | b < c` <==> `a < (b | b) < c`.\n" +
-              "If you really want this behavior, use `.or` or `.and` instead."
-            raise ArgumentError, err
-          end
-        }
-      end
-
-      old_m = m
-      m = @@rewrites[m] || m
-      begin
-        termtype = Term::TermType.const_get(m.to_s.upcase)
-      rescue NameError => e
-        unbound_if(true, old_m)
-      end
-      unbound_if(!termtype, m)
+    @@allow_json = {:INSERT => true}
+
+    termtypes = Term::TermType.constants.map{ |c| c.to_sym }
+    termtypes.each {|termtype|
+
+      method = define_method(termtype.downcase){|*a, &b|
+        bitop = [:"|", :"&"].include?(__method__)
+
+        if [:<, :<=, :>, :>=, :+, :-, :*, :/, :%].include?(__method__)
+          a.each {|arg|
+            if arg.class == RQL && arg.bitop
+              err = "Calling #{__method__} on result of infix bitwise operator:\n" +
+                "#{arg.inspect}.\n" +
+                "This is almost always a precedence error.\n" +
+                "Note that `a < b | b < c` <==> `a < (b | b) < c`.\n" +
+                "If you really want this behavior, use `.or` or `.and` instead."
+              raise RqlDriverError, err
+            end
+          }
+        end
 
-      if (opt_offset = @@optarg_offsets[m])
-        if opt_offset.class == Hash
-          opt_offset = opt_offset[b ? :with_block : :without]
+        if (opt_offset = @@optarg_offsets[termtype.downcase])
+          if opt_offset.class == Hash
+            opt_offset = opt_offset[b ? :with_block : :without]
+          end
+          # TODO: This should drop the Hash comparison or at least
+          # @@optarg_offsets should stop specifying -1, where possible.
+          # Any time one of these operations is changed to support a
+          # hash argument, we'll have to remember to fix
+          # @@optarg_offsets, otherwise.
+          optargs = a.delete_at(opt_offset) if a[opt_offset].class == Hash
         end
-        # TODO: This should drop the Hash comparison or at least
-        # @@optarg_offsets should stop specifying -1, where possible.
-        # Any time one of these operations is changed to support a
-        # hash argument, we'll have to remember to fix
-        # @@optarg_offsets, otherwise.
-        optargs = a.delete_at(opt_offset) if a[opt_offset].class == Hash
-      end
 
-      args = (@body ? [self] : []) + a + (b ? [new_func(&b)] : [])
+        args = (@body ? [self] : []) + a + (b ? [new_func(&b)] : [])
 
-      t = Term.new
-      t.type = termtype
-      t.args = args.map{|x| RQL.new.expr(x, :allow_json => @@allow_json[m]).to_pb}
-      t.optargs = (optargs || {}).map {|k,v|
-        ap = Term::AssocPair.new
-        ap.key = k.to_s
-        ap.val = RQL.new.expr(v, :allow_json => @@allow_json[m]).to_pb
-        ap
+        t = Term.new
+        t.type = Term::TermType.const_get(termtype)
+        t.args = args.map{|x| RQL.new.expr(x, :allow_json => @@allow_json[termtype]).to_pb}
+        t.optargs = (optargs || {}).map {|k,v|
+          ap = Term::AssocPair.new
+          ap.key = k.to_s
+          ap.val = RQL.new.expr(v, :allow_json => @@allow_json[termtype]).to_pb
+          ap
+        }
+        return RQL.new(t, bitop)
       }
-      return RQL.new(t, bitop)
-    end
 
-    def group_by(*a, &b)
-      a = [self] + a if @body
-      RQL.new.method_missing(:group_by, a[0], a[1..-2], a[-1], &b)
-    end
-    def groupby(*a, &b); group_by(*a, &b); end
+      [*@@method_aliases[termtype.downcase]].each{|method_alias|
+        define_method method_alias, method
+      }
+    }
 
     def connect(*args, &b)
       unbound_if @body
@@ -105,33 +111,6 @@ module RethinkDB
       b ? begin b.call(c) ensure c.close end : c
     end
 
-    def avg(attr)
-      unbound_if @body
-      {:AVG => attr}
-    end
-    def sum(attr)
-      unbound_if @body
-      {:SUM => attr}
-    end
-    def count(*a, &b)
-      !@body && a == [] ? {:COUNT => true} : super(*a, &b)
-    end
-
-    def reduce(*a, &b)
-      args = a.dup
-      base_offset_front = (@body ? 0 : 1)
-      base_offset_back = args.size - (b ? 1 : 2)
-      if base_offset_front == base_offset_back
-        args << {:base => args.delete_at(base_offset_front)}
-      end
-      super(*args, &b)
-    end
-
-    def grouped_map_reduce(*a, &b)
-      a << {:base => a.delete_at(-2)} if a.size >= 2 && a[-2].class != Proc
-      super(*a, &b)
-    end
-
     def -@; RQL.new.sub(0, self); end
 
     def [](ind)
@@ -155,7 +134,6 @@ module RethinkDB
       their protobufs like: `query1.to_pb == query2.to_pb`."
     end
 
-
     def do(*args, &b)
       a = (@body ? [self] : []) + args.dup
       if a == [] && !b

data/lib/net.rb

@@ -34,6 +34,12 @@ module RethinkDB
           raise ArgumentError, "`time_format` must be 'raw' or 'native' (got `#{tf}`)."
         end
       end
+      if (gf = opts[:group_format])
+        opts[:group_format] = (gf = gf.to_s)
+        if gf != 'raw' && gf != 'native'
+          raise ArgumentError, "`group_format` must be 'raw' or 'native' (got `#{gf}`)."
+        end
+      end
       if !c
         raise ArgumentError, "No connection specified!\n" \
         "Use `query.run(conn)` or `conn.repl(); query.run`."
@@ -199,10 +205,10 @@ module RethinkDB
       begin
         res = nil
         raise RqlRuntimeError, "Connection closed by server!" if not @listener
-        @mutex.synchronize do
+        @mutex.synchronize {
           (@waiters[token] = ConditionVariable.new).wait(@mutex) if not @data[token]
           res = @data.delete token if @data[token]
-        end
+        }
         raise RqlRuntimeError, "Connection closed by server!" if !@listener or !res
         return res
       rescue @abort_module::Abort => e
@@ -309,16 +315,16 @@ module RethinkDB
       end
 
       @listener.terminate if @listener
-      @listener = Thread.new do
-        loop do
+      @listener = Thread.new {
+        loop {
           begin
             response_length = @socket.read_exn(4).unpack('L<')[0]
             response = @socket.read_exn(response_length)
           rescue RqlRuntimeError => e
-            @mutex.synchronize do
+            @mutex.synchronize {
               @listener = nil
               @waiters.each {|kv| kv[1].signal}
-            end
+            }
             Thread.current.terminate
             abort("unreachable")
           end
@@ -329,7 +335,7 @@ module RethinkDB
             raise RqlRuntimeError, "Bad Protobuf #{response}, server is buggy."
           end
           if protob.token == -1
-            @mutex.synchronize do
+            @mutex.synchronize {
               @waiters.keys.each {|k|
                 @data[k] = protob
                 if @waiters[k]
@@ -337,18 +343,18 @@ module RethinkDB
                   cond.signal
                 end
               }
-            end
+            }
           else
-            @mutex.synchronize do
+            @mutex.synchronize {
               @data[protob.token] = protob
               if @waiters[protob.token]
                 cond = @waiters.delete protob.token
                 cond.signal
               end
-            end
+            }
           end
-        end
-      end
+        }
+      }
     end
   end
 end

data/lib/ql2.pb.rb

@@ -200,6 +200,7 @@ class Term < ::ProtocolBuffers::Message
     CONTAINS = 93
     GET_FIELD = 31
     KEYS = 94
+    OBJECT = 143
     HAS_FIELDS = 32
     WITH_FIELDS = 96
     PLUCK = 33
@@ -216,8 +217,6 @@ class Term < ::ProtocolBuffers::Message
     IS_EMPTY = 86
     UNION = 44
     NTH = 45
-    GROUPED_MAP_REDUCE = 46
-    GROUPBY = 47
     INNER_JOIN = 48
     OUTER_JOIN = 49
     EQ_JOIN = 50
@@ -254,6 +253,8 @@ class Term < ::ProtocolBuffers::Message
     DESC = 74
     INFO = 79
     MATCH = 97
+    UPCASE = 141
+    DOWNCASE = 142
     SAMPLE = 81
     DEFAULT = 92
     JSON = 98
@@ -296,6 +297,13 @@ class Term < ::ProtocolBuffers::Message
     NOVEMBER = 124
     DECEMBER = 125
     LITERAL = 137
+    GROUP = 144
+    SUM = 145
+    AVG = 146
+    MIN = 147
+    MAX = 148
+    SPLIT = 149
+    UNGROUP = 150
   end
 
   set_fully_qualified_name "Term"

data/lib/rethinkdb.rb

@@ -18,7 +18,6 @@ class Term::AssocPair
 end
 
 class Term
-  attr_accessor :context
   attr_accessor :is_error
 
   def deep_dup
@@ -60,12 +59,13 @@ module RethinkDB
 
   module Utils
     def get_mname(i = 0)
-      caller[i]=~/`(.*?)'/
-      $1
+      caller(i, 1)[0] =~ /`(.*?)'/; $1
     end
     def unbound_if (x, name = nil)
-      name = get_mname(1) if not name
-      raise NoMethodError, "undefined method `#{name}'" if x
+      if x
+        name = get_mname(2) if not name
+        raise NoMethodError, "undefined method `#{name}'"
+      end
     end
   end
 
@@ -74,10 +74,9 @@ module RethinkDB
 
     attr_accessor :body, :bitop
 
-    def initialize(body = nil, bitop = nil, context = nil)
+    def initialize(body = nil, bitop = nil)
       @body = body
       @bitop = bitop
-      @body.context = (context || RPP.sanitize_context(caller)) if @body
     end
 
     def pp

data/lib/rpp.rb

@@ -6,15 +6,7 @@ module RethinkDB
     @@termtype_to_str = Hash[
       Term::TermType.constants.map{|x| [Term::TermType.const_get(x), x.to_s]}
     ]
-
-    def self.sanitize_context context
-      if __FILE__ =~ /^(.*\/)[^\/]+.rb$/
-        prefix = $1;
-        context.reject{|x| x =~ /^#{prefix}/}
-      else
-        context
-      end
-    end
+    @@regex = if __FILE__ =~ /^(.*\/)[^\/]+.rb$/ then /^#{$1}/ else nil end
 
     def self.pp_int_optargs(q, optargs, pre_dot = false)
       q.text("r(") if pre_dot
@@ -77,7 +69,6 @@ module RethinkDB
     end
     def self.pp_int(q, term, pre_dot=false)
       q.text("\x7", 0) if term.is_error
-      @@context = term.context if term.is_error
 
       if term.type == Term::TermType::DATUM
         res = pp_int_datum(q, term.datum, pre_dot)
@@ -165,7 +156,6 @@ module RethinkDB
 
     def self.pp term
       begin
-        @@context = nil
         q = PrettyPrint.new
         pp_int(q, term, true)
         q.flush
@@ -180,11 +170,7 @@ module RethinkDB
           else
             line
           end
-        }.flatten.join("\n") +
-          (@@context ?
-           "\nErroneous_Portion_Constructed:\n" +
-           "#{@@context.map{|x| "\tfrom "+x}.join("\n")}" +
-           "\nCalled:" : "")
+        }.flatten.join("\n")
       rescue Exception => e
         raise e
         "AN ERROR OCCURED DURING PRETTY-PRINTING:\n#{e.inspect}\n" +

data/lib/shim.rb

@@ -2,9 +2,7 @@ require 'json'
 require 'time'
 
 module RethinkDB
-
   module Shim
-
     def self.is_reql_time(obj)
       obj.is_a? Hash and obj["$reql_type$"] == "TIME"
     end
@@ -15,26 +13,50 @@ module RethinkDB
       (tz && tz != "" && tz != "Z") ? t.getlocal(tz) : t.utc
     end
 
-    def self.convert_times!(result)
+    def self.is_grouped_data(obj)
+      obj.is_a? Hash and obj["$reql_type$"] == "GROUPED_DATA"
+    end
+
+    def self.convert_grouped_data(obj, opts)
+      convert_reql_types!(obj['data'], opts)
+      Hash[obj["data"]]
+    end
+
+    def self.maybe_convert_type(obj, opts)
+      if opts[:time_format] != 'raw' && is_reql_time(obj)
+        convert_time(obj)
+      elsif opts[:group_format] != 'raw' && is_grouped_data(obj)
+        convert_grouped_data(obj, opts)
+      else
+        nil
+      end
+    end
+
+    def self.convert_reql_types!(result, opts)
       case result
       when Hash
-        result.each { |k, v|
-          if is_reql_time v
-            result[k] = convert_time v
+        result.each {|k,v|
+          if (new_res = maybe_convert_type(v, opts))
+            result[k] = new_res
           else
-            convert_times! v
+            convert_reql_types!(v, opts)
           end
         }
       when Array
-        result.each_index { |i|
-          if is_reql_time result[i]
-            result[i] = convert_time result[i]
+        result.each_index {|i|
+          if (new_res = maybe_convert_type(result[i], opts))
+            result[i] = new_res;
           else
-            convert_times! result[i]
+            convert_reql_types!(result[i], opts)
           end
         }
       end
-      result
+      nil
+    end
+
+    def self.postprocess!(result, opts)
+      maybe_convert_type(result, opts) \
+      || (convert_reql_types!(result, opts); result)
     end
 
     def self.datum_to_native(d, opts)
@@ -48,18 +70,9 @@ module RethinkDB
       when dt::R_ARRAY then d.r_array.map{|d2| datum_to_native(d2, opts)}
       when dt::R_OBJECT then
         obj = Hash[d.r_object.map{|x| [x.key, datum_to_native(x.val, opts)]}]
-        if opts[:time_format] != 'raw'
-          is_reql_time(obj) ? convert_time(obj) : obj
-        else
-          obj
-        end
+        postprocess!(obj, opts)
       when dt::R_JSON then
-        result = JSON.parse("[" + d.r_str + "]")[0]
-        if opts[:time_format] != 'raw'
-          is_reql_time(result) ? convert_time(result) : convert_times!(result)
-        else
-          result
-        end
+        postprocess!(JSON.parse("[" + d.r_str + "]")[0], opts)
       else raise RqlRuntimeError, "#{dt} Unimplemented."
       end
     end
@@ -121,7 +134,7 @@ module RethinkDB
     @@datum_types = [Fixnum, Float, Bignum, String, Symbol,
                      TrueClass, FalseClass, NilClass]
 
-    def any_to_pb(x, context)
+    def any_to_pb(x)
       return x.to_pb if x.class == RQL
       t = Term.new
       t.type = Term::TermType::JSON
@@ -136,23 +149,23 @@ module RethinkDB
       return (offset < 0 ? "-" : "+") + sprintf("%02d:%02d", raw_hours, raw_minutes);
     end
 
-    def fast_expr(x, context, allow_json)
+    def fast_expr(x, allow_json)
       return x if x.class == RQL
       if @@datum_types.include?(x.class)
         return x if allow_json
-        return RQL.new(Shim.native_to_datum_term(x), nil, context)
+        return RQL.new(Shim.native_to_datum_term(x), nil)
       end
 
       case x
       when Array
-        args = x.map{|y| fast_expr(y, context, allow_json)}
+        args = x.map{|y| fast_expr(y, allow_json)}
         return x if allow_json && args.all?{|y| y.class != RQL}
         t = Term.new
         t.type = Term::TermType::MAKE_ARRAY
-        t.args = args.map{|y| any_to_pb(y, context)}
-        return RQL.new(t, nil, context)
+        t.args = args.map{|y| any_to_pb(y)}
+        return RQL.new(t, nil)
       when Hash
-        kvs = x.map{|k,v| [k, fast_expr(v, context, allow_json)]}
+        kvs = x.map{|k,v| [k, fast_expr(v, allow_json)]}
         return x if allow_json && kvs.all? {|k,v|
           (k.class == String || k.class == Symbol) && v.class != RQL
         }
@@ -166,13 +179,13 @@ module RethinkDB
             raise RqlDriverError, "Object keys must be strings or symbols." +
               "  (Got object `#{k.inspect}` of class `#{k.class}`.)"
           end
-          ap.val = any_to_pb(v, context)
+          ap.val = any_to_pb(v)
           ap
         }
-        return RQL.new(t, nil, context)
+        return RQL.new(t, nil)
       when Proc
-        t = RQL.new(nil, nil, context).new_func(&x).to_pb
-        return RQL.new(t, nil, context)
+        t = RQL.new(nil, nil).new_func(&x).to_pb
+        return RQL.new(t, nil)
       else raise RqlDriverError, "r.expr can't handle #{x.inspect} of type #{x.class}"
       end
     end
@@ -202,10 +215,9 @@ module RethinkDB
     def expr(x, opts={})
       allow_json = opts[:allow_json]
       unbound_if @body
-      context = RPP.sanitize_context(caller)
-      res = fast_expr(reql_typify(x), context, allow_json)
+      res = fast_expr(reql_typify(x), allow_json)
       return res if res.class == RQL
-      return RQL.new(any_to_pb(res, context), nil, context)
+      return RQL.new(any_to_pb(res), nil)
     end
 
     def coerce(other)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rethinkdb
 version: !ruby/object:Gem::Version
-  version: 1.11.0.2
+  version: 1.12.0.0
 platform: ruby
 authors:
 - RethinkDB Inc.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-16 00:00:00.000000000 Z
+date: 2014-03-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -60,11 +60,11 @@ extra_rdoc_files: []
 files:
 - lib/exc.rb
 - lib/ql2.pb.rb
-- lib/net.rb
 - lib/rethinkdb.rb
-- lib/shim.rb
-- lib/func.rb
 - lib/rpp.rb
+- lib/func.rb
+- lib/net.rb
+- lib/shim.rb
 homepage: http://rethinkdb.com
 licenses:
 - Apache-2