rethinkdb 1.12.0.2 → 1.13.0.0

data/lib/rethinkdb.rb

@@ -1,7 +1,6 @@
 # Copyright 2010-2012 RethinkDB, all rights reserved.
 require 'rubygems'
 require 'ql2.pb.rb'
-
 require 'socket'
 require 'pp'
 
@@ -11,45 +10,6 @@ load 'shim.rb'
 load 'func.rb'
 load 'rpp.rb'
 
-class Term::AssocPair
-  def deep_dup
-    dup.tap { |pair| pair.val = pair.val.deep_dup }
-  end
-end
-
-class Term
-  attr_accessor :is_error
-
-  def deep_dup
-    dup.tap {|term|
-      term.args.map!(&:deep_dup)
-      term.optargs.map!(&:deep_dup)
-    }
-  end
-
-  def bt_tag bt
-    @is_error = true
-    begin
-      return if bt == []
-      frame, sub_bt = bt[0], bt [1..-1]
-      if frame.class == String
-        optargs.each {|optarg|
-          if optarg.key == frame
-            @is_error = false
-            optarg.val.bt_tag(sub_bt)
-          end
-        }
-      else
-        @is_error = false
-        args[frame].bt_tag(sub_bt)
-      end
-    rescue StandardError => e
-      @is_error = true
-      $stderr.puts "ERROR: Failed to parse backtrace (we'll take our best guess)."
-    end
-  end
-end
-
 module RethinkDB
   module Shortcuts
     def r(*args)
@@ -74,17 +34,17 @@ module RethinkDB
 
     attr_accessor :body, :bitop
 
-    def initialize(body = nil, bitop = nil)
+    def initialize(body = RQL, bitop = nil)
       @body = body
       @bitop = bitop
     end
 
     def pp
-      unbound_if !@body
+      unbound_if(@body == RQL)
       RethinkDB::RPP.pp(@body)
     end
     def inspect
-      @body ? pp : super
+      (@body != RQL) ? pp : super
     end
   end
 end

data/lib/rpp.rb

@@ -3,30 +3,33 @@ require 'prettyprint'
 
 module RethinkDB
   module RPP
-    @@termtype_to_str = Hash[
-      Term::TermType.constants.map{|x| [Term::TermType.const_get(x), x.to_s]}
-    ]
+    @@termtype_to_str =
+      Hash[Term::TermType.constants.map{|x| [Term::TermType.const_get(x), x.to_s]}]
     @@regex = if __FILE__ =~ /^(.*\/)[^\/]+.rb$/ then /^#{$1}/ else nil end
 
-    def self.pp_int_optargs(q, optargs, pre_dot = false)
+    def self.bt_consume(bt, el)
+      (bt && bt[0] == el) ? bt[1..-1] : nil
+    end
+
+    def self.pp_int_optargs(q, optargs, bt, pre_dot = false)
       q.text("r(") if pre_dot
       q.group(1, "{", "}") {
-        optargs.each_with_index {|optarg, i|
+        optargs.to_a.each_with_index {|optarg, i|
           if i != 0
             q.text(",")
             q.breakable
           end
-          q.text(":#{optarg.key} =>")
+          q.text("#{optarg[0].inspect} =>")
           q.nest(2) {
             q.breakable
-            pp_int(q, optarg.val)
+            pp_int(q, optarg[1], bt_consume(bt, optarg[0]))
           }
         }
       }
       q.text(")") if pre_dot
     end
 
-    def self.pp_int_args(q, args, pre_dot = false)
+    def self.pp_int_args(q, args, bt, pre_dot = false)
       q.text("r(") if pre_dot
       q.group(1, "[", "]") {
         args.each_with_index {|arg, i|
@@ -34,7 +37,7 @@ module RethinkDB
             q.text(",")
             q.breakable
           end
-          pp_int(q, arg)
+          pp_int(q, arg, bt_consume(bt, i))
         }
       }
       q.text(")") if pre_dot
@@ -42,70 +45,104 @@ module RethinkDB
 
     def self.pp_int_datum(q, dat, pre_dot)
       q.text("r(") if pre_dot
-      q.text(Shim.datum_to_native(dat, :time_format => 'raw').inspect)
+      q.text(dat.inspect)
       q.text(")") if pre_dot
     end
 
-    def self.pp_int_func(q, func)
-      func_args = func.args[0].args.map{|x| x.datum.r_num}
-      func_body = func.args[1]
-      q.text(" ")
-      q.group(0, "{", "}") {
-        if func_args != []
-          q.text(func_args.map{|x| :"var_#{x}"}.inspect.gsub(/\[|\]/,"|").gsub(":",""))
-        end
-        q.nest(2) {
-          q.breakable
-          pp_int(q, func_body)
+    def self.pp_int_func(q, func, bt)
+      # PP.pp [:func, func.to_json, bt]
+      begin
+        # PP.pp func
+        func_args = func[1][0][1].map{|x| x.to_pb}
+        # PP.pp JSON.parse(func_args.to_json)
+        func_body = func[1][1]
+        q.text(" ")
+        q.group(0, "{", "}") {
+          if func_args != []
+            q.text(func_args.map{|x| :"var_#{x}"}.inspect.gsub(/\[|\]/,"|").gsub(":",""))
+          end
+          q.nest(2) {
+            q.breakable
+            pp_int(q, func_body, bt_consume(bt, 1))
+          }
+          q.breakable('')
         }
-        q.breakable('')
-      }
+      rescue StandardError => e
+        q.text(" {#<unprintable function:`#{func}`>}")
+      end
     end
 
     def self.can_prefix (name, args)
-      return false if name == "db" || name == "funcall"
-      return false if args.size == 1 && args[0].type == Term::TermType::DATUM
-      return true
+      return !["db", "table", "funcall", "args", "branch"].include?(name)
     end
-    def self.pp_int(q, term, pre_dot=false)
-      q.text("\x7", 0) if term.is_error
+    def self.pp_int(q, term, bt, pre_dot=false)
+      q.text("\x7", 0) if bt == []
 
-      if term.type == Term::TermType::DATUM
-        res = pp_int_datum(q, term.datum, pre_dot)
-        q.text("\x7", 0) if term.is_error
-        return res
+      term = term.to_pb if term.class == RQL
+      # PP.pp [:pp_int, term.to_json, bt]
+      if term.class != Array
+        if term.class == Hash
+          pp_int_optargs(q, term, bt, pre_dot)
+        else
+          pp_int_datum(q, term, pre_dot)
+        end
+        q.text("\x7", 0) if bt == []
+        return
       end
 
-      if term.type == Term::TermType::VAR
+      type = term[0]
+      args = (term[1] || []).dup
+      optargs = (term[2] || {}).dup
+      if type == Term::TermType::VAR
         q.text("var_")
-        res = pp_int_datum(q, term.args[0].datum, false)
-        q.text("\x7", 0) if term.is_error
-        return res
-      elsif term.type == Term::TermType::FUNC
+        res = pp_int_datum(q, args[0], false)
+        q.text("\x7", 0) if bt == []
+        return
+      elsif type == Term::TermType::FUNC
         q.text("r(") if pre_dot
         q.text("lambda")
-        res = pp_int_func(q, term)
+        pp_int_func(q, term, bt)
         q.text(")") if pre_dot
-        q.text("\x7", 0) if term.is_error
-        return res
-      elsif term.type == Term::TermType::MAKE_OBJ
-        res = pp_int_optargs(q, term.optargs, pre_dot)
-        q.text("\x7", 0) if term.is_error
-        return res
-      elsif term.type == Term::TermType::MAKE_ARRAY
-        res = pp_int_args(q, term.args, pre_dot)
-        q.text("\x7", 0) if term.is_error
-        return res
+        q.text("\x7", 0) if bt == []
+        return
+      elsif type == Term::TermType::MAKE_ARRAY
+        pp_int_args(q, args, bt, pre_dot)
+        q.text("\x7", 0) if bt == []
+        return
+      elsif type == Term::TermType::FUNCALL
+        func = (args[0][0] == Term::TermType::FUNC) ? args[0] : nil
+        if args.size == 2
+          pp_int(q, args[1], bt_consume(bt, 1), pre_dot)
+          q.text(".do")
+          if !func
+            q.text("(")
+            pp_int(q, args[0], bt_consume(bt, 0)) if !func
+            q.text(")")
+          end
+        else
+          q.text("r.do(")
+          (1...args.size).each {|i|
+            q.text(", ") if i != 1
+            pp_int(q, args[i], bt_consume(bt, i))
+          }
+          if !func
+            q.text(", ")
+            pp_int(q, args[0], bt_consume(bt, 0))
+          end
+          q.text(")")
+        end
+        pp_int_func(q, args[0], bt_consume(bt, 0)) if func
+        return
       end
 
-      name = @@termtype_to_str[term.type].downcase
-      args = term.args.dup
-      optargs = term.optargs.dup
+      name = @@termtype_to_str[type].downcase
 
       if can_prefix(name, args) && first_arg = args.shift
-        pp_int(q, first_arg, true)
+        pp_int(q, first_arg, bt_consume(bt, 0), true)
+        arg_offset = 1
       else
         q.text("r")
+        arg_offset = 0
       end
       if name == "getattr"
         argstart, argstop = "[", "]"
@@ -115,13 +152,17 @@ module RethinkDB
         argstart, argstop = "(", ")"
       end
 
-      func = args[-1] && args[-1].type == Term::TermType::FUNC && args.pop
+      if args[-1] && args[-1].class == Array && args[-1][0] == Term::TermType::FUNC
+        func_bt = bt_consume(bt, args.size() - 1 + arg_offset)
+        func = args.pop
+        # PP.pp [:func_bt, bt, arg_offset, (args.size() - 1) + arg_offset, func_bt]
+      end
 
-      if args != [] || optargs != []
+      if args != [] || optargs != {}
         q.group(0, argstart, argstop) {
           pushed = nil
           q.nest(2) {
-            args.each {|arg|
+            args.each_with_index {|arg, index|
               if !pushed
                 pushed = true
                 q.breakable('')
@@ -129,35 +170,30 @@ module RethinkDB
                 q.text(",")
                 q.breakable
               end
-              pp_int(q, arg)
+              # PP.pp [:int, arg.to_json, bt_consume(bt, index)]
+              pp_int(q, arg, bt_consume(bt, index + arg_offset))
             }
-            if optargs != []
+            if optargs != {}
               if pushed
                 q.text(",")
                 q.breakable
               end
-              pp_int_optargs(q, optargs)
-            end
-            if func && name == "grouped_map_reduce"
-              q.text(",")
-              q.breakable
-              q.text("lambda")
-              pp_int_func(q, func)
-              func = nil
+              pp_int_optargs(q, optargs, bt)
             end
           }
           q.breakable('')
         }
       end
 
-      pp_int_func(q, func) if func
-      q.text("\x7", 0) if term.is_error
+      pp_int_func(q, func, func_bt) if func
+      q.text("\x7", 0) if bt == []
     end
 
-    def self.pp term
+    def self.pp(term, bt=nil)
+      # PP.pp bt
       begin
         q = PrettyPrint.new
-        pp_int(q, term, true)
+        pp_int(q, term, bt, true)
         q.flush
 
         in_bt = false
@@ -165,16 +201,15 @@ module RethinkDB
           line = line.gsub(/^ */) {|x| x+"\x7"} if in_bt
           arr = line.split("\x7")
           if arr[1]
-            in_bt = !(arr[2] || (line[-1] == 0x7))
+            in_bt = !(arr[2] || (line[-1] == "\x7"))
             [arr.join(""), " "*arr[0].size + "^"*arr[1].size]
           else
             line
           end
         }.flatten.join("\n")
-      rescue Exception => e
-        raise e
+       rescue Exception => e
         "AN ERROR OCCURED DURING PRETTY-PRINTING:\n#{e.inspect}\n" +
-          "FALLING BACK TO PROTOBUF PRETTY-PRINTER.\n#{@term.inspect}"
+          "FALLING BACK TO GENERIC PRINTER.\n#{term.inspect}"
       end
     end
   end

data/lib/shim.rb

@@ -1,225 +1,111 @@
-require 'json'
-require 'time'
-
 module RethinkDB
+  require 'json'
+  require 'time'
   module Shim
-    def self.is_reql_time(obj)
-      obj.is_a? Hash and obj["$reql_type$"] == "TIME"
-    end
-
-    def self.convert_time(obj)
-      t = Time.at(obj['epoch_time'])
-      tz = obj['timezone']
-      (tz && tz != "" && tz != "Z") ? t.getlocal(tz) : t.utc
-    end
-
-    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
+    def self.recursive_munge(x, parse_time, parse_group)
+      case x
       when Hash
-        result.each {|k,v|
-          if (new_res = maybe_convert_type(v, opts))
-            result[k] = new_res
-          else
-            convert_reql_types!(v, opts)
-          end
-        }
+        if parse_time && x['$reql_type$'] == 'TIME'
+          t = Time.at(x['epoch_time'])
+          tz = x['timezone']
+          return (tz && tz != "" && tz != "Z") ? t.getlocal(tz) : t.utc
+        elsif parse_group && x['$reql_type$'] == 'GROUPED_DATA'
+          return Hash[x['data']]
+        else
+          x.each {|k, v|
+            v2 = recursive_munge(v, parse_time, parse_group)
+            x[k] = v2 if v.object_id != v2.object_id
+          }
+        end
       when Array
-        result.each_index {|i|
-          if (new_res = maybe_convert_type(result[i], opts))
-            result[i] = new_res;
-          else
-            convert_reql_types!(result[i], opts)
-          end
+        x.each_with_index {|v, i|
+          v2 = recursive_munge(v, parse_time, parse_group)
+          x[i] = v2 if v.object_id != v2.object_id
         }
       end
-      nil
+      return x
     end
 
-    def self.postprocess!(result, opts)
-      maybe_convert_type(result, opts) \
-      || (convert_reql_types!(result, opts); result)
+    def self.load_json(target, opts=nil)
+      recursive_munge(JSON.parse(target, max_nesting: false),
+                      opts && opts[:time_format] != 'raw',
+                      opts && opts[:group_format] != 'raw')
     end
 
-    def self.datum_to_native(d, opts)
-      raise RqlRuntimeError, "SHENANIGANS" if d.class != Datum
-      dt = Datum::DatumType
-      case d.type
-      when dt::R_NUM then d.r_num == d.r_num.to_i ? d.r_num.to_i : d.r_num
-      when dt::R_STR then d.r_str
-      when dt::R_BOOL then d.r_bool
-      when dt::R_NULL then nil
-      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)]}]
-        postprocess!(obj, opts)
-      when dt::R_JSON then
-        postprocess!(JSON.parse("[" + d.r_str + "]")[0], opts)
-      else raise RqlRuntimeError, "#{dt} Unimplemented."
-      end
+    def self.dump_json(x)
+      JSON.generate(x, max_nesting: false)
     end
 
     def self.response_to_native(r, orig_term, opts)
       rt = Response::ResponseType
-      if r.backtrace
-        bt = r.backtrace.frames.map {|x|
-          x.type == Frame::FrameType::POS ? x.pos : x.opt
-        }
-      else
-        bt = []
-      end
-
       begin
-        case r.type
-        when rt::SUCCESS_ATOM then datum_to_native(r.response[0], opts)
-        when rt::SUCCESS_PARTIAL then r.response.map{|d| datum_to_native(d, opts)}
-        when rt::SUCCESS_SEQUENCE then r.response.map{|d| datum_to_native(d, opts)}
-        when rt::RUNTIME_ERROR then
-          raise RqlRuntimeError, "#{r.response[0].r_str}"
-        when rt::COMPILE_ERROR then # TODO: remove?
-          raise RqlCompileError, "#{r.response[0].r_str}"
-        when rt::CLIENT_ERROR then
-          raise RqlDriverError, "#{r.response[0].r_str}"
+        case r['t']
+        when rt::SUCCESS_ATOM     then r['r'][0]
+        when rt::SUCCESS_FEED     then r['r']
+        when rt::SUCCESS_PARTIAL  then r['r']
+        when rt::SUCCESS_SEQUENCE then r['r']
+        when rt::RUNTIME_ERROR    then raise RqlRuntimeError, r['r'][0]
+        when rt::COMPILE_ERROR    then raise RqlCompileError, r['r'][0]
+        when rt::CLIENT_ERROR     then raise RqlDriverError,  r['r'][0]
         else raise RqlRuntimeError, "Unexpected response: #{r.inspect}"
         end
       rescue RqlError => e
-        term = orig_term.deep_dup
-        term.bt_tag(bt)
-        raise e.class, "#{e.message}\nBacktrace:\n#{RPP.pp(term)}"
+        raise e.class, "#{e.message}\nBacktrace:\n#{RPP.pp(orig_term, r['b'])}"
       end
     end
-
-    def self.native_to_datum_term x
-      dt = Datum::DatumType
-      d = Datum.new
-      case x
-      when Fixnum     then d.type = dt::R_NUM;  d.r_num = x
-      when Float      then d.type = dt::R_NUM;  d.r_num = x
-      when Bignum     then d.type = dt::R_NUM;  d.r_num = x
-      when String     then d.type = dt::R_STR;  d.r_str = x
-      when Symbol     then d.type = dt::R_STR;  d.r_str = x.to_s
-      when TrueClass  then d.type = dt::R_BOOL; d.r_bool = x
-      when FalseClass then d.type = dt::R_BOOL; d.r_bool = x
-      when NilClass   then d.type = dt::R_NULL
-      else raise RqlRuntimeError, "UNREACHABLE"
-      end
-      t = Term.new
-      t.type = Term::TermType::DATUM
-      t.datum = d
-      return t
-    end
   end
 
   class RQL
-    def to_pb; @body; end
-
-    @@datum_types = [Fixnum, Float, Bignum, String, Symbol,
-                     TrueClass, FalseClass, NilClass]
-
-    def any_to_pb(x)
-      return x.to_pb if x.class == RQL
-      t = Term.new
-      t.type = Term::TermType::JSON
-      t.args = [Shim.native_to_datum_term(x.to_json(:max_nesting => 500))]
-      return t
-    end
-
-    def timezone_from_offset(offset)
-      raw_offset = offset.abs
-      raw_hours = raw_offset / 3600
-      raw_minutes = (raw_offset / 60) - (raw_hours * 60)
-      return (offset < 0 ? "-" : "+") + sprintf("%02d:%02d", raw_hours, raw_minutes);
+    def to_json(*a, &b)
+      @body.to_json(*a, &b)
     end
+    def to_pb; @body; end
 
-    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)
-      end
-
+    def self.safe_to_s(x)
       case x
-      when Array
-        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)}
-        return RQL.new(t, nil)
-      when Hash
-        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
-        }
-        t = Term.new
-        t.type = Term::TermType::MAKE_OBJ
-        t.optargs = kvs.map{|k,v|
-          ap = Term::AssocPair.new;
-          if k.class == Symbol || k.class == String
-            ap.key = k.to_s
-          else
-            raise RqlDriverError, "Object keys must be strings or symbols." +
-              "  (Got object `#{k.inspect}` of class `#{k.class}`.)"
-          end
-          ap.val = any_to_pb(v)
-          ap
-        }
-        return RQL.new(t, nil)
-      when Proc
-        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}"
+      when String then x
+      when Symbol then x.to_s
+      else raise RqlDriverError, 'Object keys must be strings or symbols.  '+
+          "(Got object `#{x.inspect}` of class `#{x.class}`.)"
       end
     end
 
-    def check_depth depth
-      raise RqlRuntimeError, "Maximum expression depth of 20 exceeded." if depth > 20
-    end
-
-    def reql_typify(tree, depth=0)
-      check_depth(depth)
-      case tree
-      when Array
-        return tree.map{|x| reql_typify(x, depth+1)}
-      when Hash
-        return Hash[tree.map{|k,v| [k, reql_typify(v, depth+1)]}]
-      when Time
-        return {
-          '$reql_type$' => 'TIME',
-          'epoch_time'  => tree.to_f,
-          'timezone'    => timezone_from_offset(tree.utc_offset)
-        }
-      else
-        return tree
+    def self.fast_expr(x, max_depth)
+      if max_depth == 0
+        raise RqlDriverError, "Maximum expression depth exceeded " +
+          "(you can override this with `r.expr(X, MAX_DEPTH)`)."
+      end
+      case x
+      when RQL then x
+      when Array then RQL.new([Term::TermType::MAKE_ARRAY,
+                               x.map{|y| fast_expr(y, max_depth-1)}])
+      when Hash then RQL.new(Hash[x.map{|k,v| [safe_to_s(k),
+                                               fast_expr(v, max_depth-1)]}])
+      when Proc then RQL.new.new_func(&x)
+      when String then RQL.new(x)
+      when Symbol then RQL.new(x)
+      when Numeric then RQL.new(x)
+      when FalseClass then RQL.new(x)
+      when TrueClass then RQL.new(x)
+      when NilClass then RQL.new(x)
+      when Time then
+        epoch_time = x.to_f
+        offset = x.utc_offset
+        raw_offset = offset.abs
+        raw_hours = raw_offset / 3600
+        raw_minutes = (raw_offset / 60) - (raw_hours * 60)
+        tz = (offset < 0 ? "-" : "+") + sprintf("%02d:%02d", raw_hours, raw_minutes);
+        RQL.new({ '$reql_type$' => 'TIME',
+                  'epoch_time'  => epoch_time,
+                  'timezone'    => tz })
+      else raise RqlDriverError, "r.expr can't handle #{x.inspect} of class #{x.class}."
       end
     end
 
-    def expr(x, opts={})
-      allow_json = opts[:allow_json]
-      unbound_if @body
-      res = fast_expr(reql_typify(x), allow_json)
-      return res if res.class == RQL
-      return RQL.new(any_to_pb(res), nil)
+    def expr(x, max_depth=20)
+      unbound_if(@body != RQL)
+      RQL.fast_expr(x, max_depth)
     end
-
     def coerce(other)
       [RQL.new.expr(other), self]
     end