rethinkdb 1.6.0.0 → 1.7.0.0

data/lib/func.rb

@@ -37,6 +37,7 @@ module RethinkDB
       :js => :javascript,
       :type_of => :typeof
     }
+    @@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
@@ -54,7 +55,7 @@ module RethinkDB
       end
 
       m = @@rewrites[m] || m
-      termtype = Term::TermType.values[m.to_s.upcase.to_sym]
+      termtype = Term::TermType.const_get(m.to_s.upcase)
       unbound_if(!termtype, m)
 
       if (opt_offset = @@optarg_offsets[m])
@@ -73,11 +74,11 @@ module RethinkDB
 
       t = Term.new
       t.type = termtype
-      t.args = args.map{|x| RQL.new.expr(x).to_pb}
+      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).to_pb
+        ap.val = RQL.new.expr(v, :allow_json => @@allow_json[m]).to_pb
         ap
       }
       return RQL.new(t, bitop)
@@ -127,7 +128,7 @@ module RethinkDB
       if ind.class == Fixnum
         return nth(ind)
       elsif ind.class == Symbol || ind.class == String
-        return getattr(ind)
+        return get_field(ind)
       elsif ind.class == Range
         if ind.end == 0 && ind.exclude_end?
           raise ArgumentError, "Cannot slice to an excluded end of 0."

data/lib/net.rb

@@ -1,6 +1,7 @@
 # Copyright 2010-2012 RethinkDB, all rights reserved.
 require 'socket'
 require 'thread'
+require 'timeout'
 
 # $f = File.open("fuzz_seed.rb", "w")
 
@@ -213,12 +214,17 @@ module RethinkDB
 
     def start_listener
       class << @socket
-        def read_exn(len)
-          buf = read len
-          if !buf or buf.length != len
-            raise RqlRuntimeError, "Connection closed by server."
-          end
-          return buf
+        def maybe_timeout(sec=nil, &b)
+          sec ? timeout(sec, &b) : b.call
+        end
+        def read_exn(len, timeout_sec=nil)
+          maybe_timeout(timeout_sec) {
+            buf = read len
+            if !buf or buf.length != len
+              raise RqlRuntimeError, "Connection closed by server."
+            end
+            return buf
+          }
         end
       end
       @socket.write([@@magic_number].pack('L<'))
@@ -226,7 +232,7 @@ module RethinkDB
       @socket.write([@auth_key.size].pack('L<') + @auth_key)
       response = ""
       while response[-1..-1] != "\0"
-        response += @socket.read_exn(1)
+        response += @socket.read_exn(1, 20)
       end
       response = response[0...-1]
       if response != "SUCCESS"
@@ -249,7 +255,7 @@ module RethinkDB
           end
           #TODO: Recovery
           begin
-            protob = Response.new.parse_from_string(response)
+            protob = Response.parse(response)
           rescue
             raise RqlRuntimeError, "Bad Protobuf #{response}, server is buggy."
           end

data/lib/ql2.pb.rb

@@ -1,756 +1,231 @@
-### Generated by rprotoc. DO NOT EDIT!
-### <proto file: ../../src/rdb_protocol/ql2.proto>
-# ////////////////////////////////////////////////////////////////////////////////
-# //                            THE HIGH-LEVEL VIEW                             //
-# ////////////////////////////////////////////////////////////////////////////////
-# 
-# // Process: When you first open a connection, send the magic number
-# // for the version of the protobuf you're targetting (in the [Version]
-# // enum).  This should **NOT** be sent as a protobuf; just send the
-# // little-endian 32-bit integer over the wire raw.  This number should
-# // only be sent once per connection.
-# 
-# // The magic number shall be followed by an authorization key.  The
-# // first 4 bytes are the length of the key to be sent as a little-endian
-# // 32-bit integer, followed by the key string.  Even if there is no key,
-# // an empty string should be sent (length 0 and no data).  The server will
-# // then respond with a NULL-terminated string response.  "SUCCESS" indicates
-# // that the connection has been accepted. Any other response indicates an
-# // error, and the response string should describe the error.
-# 
-# // Next, for each query you want to send, construct a [Query] protobuf
-# // and serialize it to a binary blob.  Send the blob's size to the
-# // server encoded as a little-endian 32-bit integer, followed by the
-# // blob itself.  You will recieve a [Response] protobuf back preceded
-# // by its own size, once again encoded as a little-endian 32-bit
-# // integer.  You can see an example exchange below in **EXAMPLE**.
-# 
-# // A query consists of a [Term] to evaluate and a unique-per-connection
-# // [token].
-# 
-# // Tokens are used for two things:
-# // * Keeping track of which responses correspond to which queries.
-# // * Batched queries.  Some queries return lots of results, so we send back
-# //   batches of <1000, and you need to send a [CONTINUE] query with the same
-# //   token to get more results from the original query.
-# ////////////////////////////////////////////////////////////////////////////////
-# 
-# // This enum contains the magic numbers for your version.  See **THE HIGH-LEVEL
-# // VIEW** for what to do with it.
-# message VersionDummy { // We need to wrap it like this for some
-#                        // non-conforming protobuf libraries
-#     enum Version {
-#         V0_1 = 0x3f61ba36;
-#         V0_2 = 0x723081e1;
-#     }
-# }
-# 
-# // You send one of:
-# // * A [START] query with a [Term] to evaluate and a unique-per-connection token.
-# // * A [CONTINUE] query with the same token as a [START] query that returned
-# //   [SUCCESS_PARTIAL] in its [Response].
-# // * A [STOP] query with the same token as a [START] query that you want to stop.
-# message Query {
-#     enum QueryType {
-#         START    = 1; // Start a new query.
-#         CONTINUE = 2; // Continue a query that returned [SUCCESS_PARTIAL]
-#                       // (see [Response]).
-#         STOP     = 3; // Stop a query partway through executing.
-#     }
-#     optional QueryType type = 1;
-#     // A [Term] is how we represent the operations we want a query to perform.
-#     optional Term query = 2; // only present when [type] = [START]
-#     optional int64 token = 3;
-#     // This flag is ignored on the server.  `noreply` should be added
-#     // to `global_optargs` instead (the key "noreply" should map to
-#     // either true or false).
-#     optional bool OBSOLETE_noreply = 4 [default = false];
-# 
-#     message AssocPair {
-#         optional string key = 1;
-#         optional Term val = 2;
-#     }
-#     repeated AssocPair global_optargs = 6;
-# }
-# 
-# // A backtrace frame (see `backtrace` in Response below)
-# message Frame {
-#     enum FrameType {
-#         POS = 1; // Error occured in a positional argument.
-#         OPT = 2; // Error occured in an optional argument.
-#     }
-#     optional FrameType type = 1;
-#     optional int64 pos = 2; // The index of the positional argument.
-#     optional string opt = 3; // The name of the optional argument.
-# }
-# message Backtrace {
-#     repeated Frame frames = 1;
-# }
-# 
-# // You get back a response with the same [token] as your query.
-# message Response {
-#     enum ResponseType {
-#         // These response types indicate success.
-#         SUCCESS_ATOM     = 1; // Query returned a single RQL datatype.
-#         SUCCESS_SEQUENCE = 2; // Query returned a sequence of RQL datatypes.
-#         SUCCESS_PARTIAL  = 3; // Query returned a partial sequence of RQL
-#                               // datatypes.  If you send a [CONTINUE] query with
-#                               // the same token as this response, you will get
-#                               // more of the sequence.  Keep sending [CONTINUE]
-#                               // queries until you get back [SUCCESS_SEQUENCE].
-# 
-#         // These response types indicate failure.
-#         CLIENT_ERROR  = 16; // Means the client is buggy.  An example is if the
-#                             // client sends a malformed protobuf, or tries to
-#                             // send [CONTINUE] for an unknown token.
-#         COMPILE_ERROR = 17; // Means the query failed during parsing or type
-#                             // checking.  For example, if you pass too many
-#                             // arguments to a function.
-#         RUNTIME_ERROR = 18; // Means the query failed at runtime.  An example is
-#                             // if you add together two values from a table, but
-#                             // they turn out at runtime to be booleans rather
-#                             // than numbers.
-#     }
-#     optional ResponseType type = 1;
-#     optional int64 token = 2; // Indicates what [Query] this response corresponds to.
-# 
-#     // [response] contains 1 RQL datum if [type] is [SUCCESS_ATOM], or many RQL
-#     // data if [type] is [SUCCESS_SEQUENCE] or [SUCCESS_PARTIAL].  It contains 1
-#     // error message (of type [R_STR]) in all other cases.
-#     repeated Datum response = 3;
-# 
-#     // If [type] is [CLIENT_ERROR], [TYPE_ERROR], or [RUNTIME_ERROR], then a
-#     // backtrace will be provided.  The backtrace says where in the query the
-#     // error occured.  Ideally this information will be presented to the user as
-#     // a pretty-printed version of their query with the erroneous section
-#     // underlined.  A backtrace is a series of 0 or more [Frame]s, each of which
-#     // specifies either the index of a positional argument or the name of an
-#     // optional argument.  (Those words will make more sense if you look at the
-#     // [Term] message below.)
-# 
-#     optional Backtrace backtrace = 4; // Contains n [Frame]s when you get back an error.
-# }
-# 
-# // A [Datum] is a chunk of data that can be serialized to disk or returned to
-# // the user in a Response.  Currently we only support JSON types, but we may
-# // support other types in the future (e.g., a date type or an integer type).
-# message Datum {
-#     enum DatumType {
-#         R_NULL   = 1;
-#         R_BOOL   = 2;
-#         R_NUM    = 3; // a double
-#         R_STR    = 4;
-#         R_ARRAY  = 5;
-#         R_OBJECT = 6;
-#     }
-#     optional DatumType type = 1;
-#     optional bool r_bool = 2;
-#     optional double r_num = 3;
-#     optional string r_str = 4;
-# 
-#     repeated Datum r_array = 5;
-#     message AssocPair {
-#         optional string key = 1;
-#         optional Datum val = 2;
-#     }
-#     repeated AssocPair r_object = 6;
-# 
-#     extensions 10000 to 20000;
-# }
-# 
-# // A [Term] is either a piece of data (see **Datum** above), or an operator and
-# // its operands.  If you have a [Datum], it's stored in the member [datum].  If
-# // you have an operator, its positional arguments are stored in [args] and its
-# // optional arguments are stored in [optargs].
-# //
-# // A note about type signatures:
-# // We use the following notation to denote types:
-# //   arg1_type, arg2_type, argrest_type... -> result_type
-# // So, for example, if we have a function `avg` that takes any number of
-# // arguments and averages them, we might write:
-# //   NUMBER... -> NUMBER
-# // Or if we had a function that took one number modulo another:
-# //   NUMBER, NUMBER -> NUMBER
-# // Or a function that takes a table and a primary key of any Datum type, then
-# // retrieves the entry with that primary key:
-# //   Table, DATUM -> OBJECT
-# // Some arguments must be provided as literal values (and not the results of sub
-# // terms).  These are marked with a `!`.
-# // Optional arguments are specified within curly braces as argname `:` value
-# // type (e.x `{use_outdated:BOOL}`)
-# // Many RQL operations are polymorphic. For these, alterantive type signatures
-# // are separated by `|`.
-# //
-# // The RQL type hierarchy is as follows:
-# //   Top
-# //     DATUM
-# //       NULL
-# //       BOOL
-# //       NUMBER
-# //       STRING
-# //       OBJECT
-# //         SingleSelection
-# //       ARRAY
-# //     Sequence
-# //       ARRAY
-# //       Stream
-# //         StreamSelection
-# //           Table
-# //     Database
-# //     Function
-# //     Ordering - used only by ORDER_BY
-# //   Error
-# message Term {
-#     enum TermType {
-#         // A RQL datum, stored in `datum` below.
-#         DATUM = 1;
-# 
-#         MAKE_ARRAY = 2; // DATUM... -> ARRAY
-#         // Evaluate the terms in [optargs] and make an object
-#         MAKE_OBJ   = 3; // {...} -> OBJECT
-# 
-#         // * Compound types
-#         // Takes an integer representing a variable and returns the value stored
-#         // in that variable.  It's the responsibility of the client to translate
-#         // from their local representation of a variable to a unique integer for
-#         // that variable.  (We do it this way instead of letting clients provide
-#         // variable names as strings to discourage variable-capturing client
-#         // libraries, and because it's more efficient on the wire.)
-#         VAR          = 10; // !NUMBER -> DATUM
-#         // Takes some javascript code and executes it.
-#         JAVASCRIPT   = 11; // STRING {timeout: !NUMBER} -> DATUM |
-#                            // STRING {timeout: !NUMBER} -> Function(*)
-# 
-#         // Takes a string and throws an error with that message.
-#         // Inside of a `default` block, you can omit the first
-#         // argument to rethrow whatever error you catch (this is most
-#         // useful as an argument to the `default` filter optarg).
-#         ERROR        = 12; // STRING -> Error | -> Error
-#         // Takes nothing and returns a reference to the implicit variable.
-#         IMPLICIT_VAR = 13; // -> DATUM
-# 
-#         // * Data Operators
-#         // Returns a reference to a database.
-#         DB    = 14; // STRING -> Database
-#         // Returns a reference to a table.
-#         TABLE = 15; // Database, STRING, {use_outdated:BOOL} -> Table | STRING, {use_outdated:BOOL} -> Table
-#         // Gets a single element from a table by its primary or a secondary key.
-#         GET   = 16; // Table, STRING -> SingleSelection | Table, NUMBER -> SingleSelection |
-#                     // Table, STRING -> NULL            | Table, NUMBER -> NULL |
-#         GET_ALL = 78; // Table, JSON {index:!STRING} => ARRAY
-# 
-#         // Simple DATUM Ops
-#         EQ  = 17; // DATUM... -> BOOL
-#         NE  = 18; // DATUM... -> BOOL
-#         LT  = 19; // DATUM... -> BOOL
-#         LE  = 20; // DATUM... -> BOOL
-#         GT  = 21; // DATUM... -> BOOL
-#         GE  = 22; // DATUM... -> BOOL
-#         NOT = 23; // BOOL -> BOOL
-#         // ADD can either add two numbers or concatenate two arrays.
-#         ADD = 24; // NUMBER... -> NUMBER | STRING... -> STRING
-#         SUB = 25; // NUMBER... -> NUMBER
-#         MUL = 26; // NUMBER... -> NUMBER
-#         DIV = 27; // NUMBER... -> NUMBER
-#         MOD = 28; // NUMBER, NUMBER -> NUMBER
-# 
-#         // DATUM Array Ops
-#         // Append a single element to the end of an array (like `snoc`).
-#         APPEND = 29; // ARRAY, DATUM -> ARRAY
-#         // Prepend a single element to the end of an array (like `cons`).
-#         PREPEND = 80; // ARRAY, DATUM -> ARRAY
-#         //Remove the elements of one array from another array.
-#         DIFFERENCE = 95; // ARRAY, ARRAY -> ARRAY
-# 
-#         // DATUM Set Ops
-#         // Set ops work on arrays. They don't use actual sets and thus have
-#         // performance characteristics you would expect from arrays rather than
-#         // from sets. All set operations have the post condition that they
-#         // array they return contains no duplicate values.
-#         SET_INSERT = 88; // ARRAY, DATUM -> ARRAY
-#         SET_INTERSECTION = 89; // ARRAY, ARRAY -> ARRAY
-#         SET_UNION = 90; // ARRAY, ARRAY -> ARRAY
-#         SET_DIFFERENCE = 91; // ARRAY, ARRAY -> ARRAY
-# 
-#         SLICE  = 30; // Sequence, NUMBER, NUMBER -> Sequence
-#         SKIP  = 70; // Sequence, NUMBER -> Sequence
-#         LIMIT = 71; // Sequence, NUMBER -> Sequence
-#         INDEXES_OF = 87; // Sequence, DATUM -> Sequence | Sequence, Function(1) -> Sequence
-#         CONTAINS = 93; // Sequence, DATUM -> BOOL
-# 
-#         // Stream/Object Ops
-#         // Get a particular attribute out of an object, or map that over a
-#         // sequence.
-#         GETATTR  = 31; // OBJECT, STRING -> DATUM
-#         // Return an array containing the keys of the object.
-#         KEYS = 94; // OBJECT -> ARRAY
-#         // Check whether an object contains all the specified fields,
-#         // or filters a sequence so that all objects inside of it
-#         // contain all the specified fields.
-#         HAS_FIELDS = 32; // OBJECT, STRING... -> BOOL
-#         // x.with_fields(...) <=> x.has_fields(...).pluck(...)
-#         WITH_FIELDS = 96; // Sequence, STRING... -> Sequence
-#         // Get a subset of an object by selecting some attributes to preserve,
-#         // or map that over a sequence.  (Both pick and pluck, polymorphic.)
-#         PLUCK    = 33; // Sequence, STRING... -> Sequence | OBJECT, STRING... -> OBJECT
-#         // Get a subset of an object by selecting some attributes to discard, or
-#         // map that over a sequence.  (Both unpick and without, polymorphic.)
-#         WITHOUT  = 34; // Sequence, STRING... -> Sequence | OBJECT, STRING... -> OBJECT
-#         // Merge objects (right-preferential)
-#         MERGE    = 35; // OBJECT... -> OBJECT | Sequence -> Sequence
-# 
-#         // Sequence Ops
-#         // Get all elements of a sequence between two values.
-#         BETWEEN   = 36; // StreamSelection, DATUM, DATUM, {:index:!STRING} -> StreamSelection
-#         REDUCE    = 37; // Sequence, Function(2), {base:DATUM} -> DATUM
-#         MAP       = 38; // Sequence, Function(1) -> Sequence
-# 
-#         // Filter a sequence with either a function or a shortcut
-#         // object (see API docs for details).  The body of FILTER is
-#         // wrapped in an implicit `.default(false)`, and you can
-#         // change the default value by specifying the `default`
-#         // optarg.  If you make the default `r.error`, all errors
-#         // caught by `default` will be rethrown as if the `default`
-#         // did not exist.
-#         FILTER    = 39; // Sequence, Function(1), {default:DATUM} -> Sequence |
-#                         // Sequence, OBJECT, {default:DATUM} -> Sequence
-#         // Map a function over a sequence and then concatenate the results together.
-#         CONCATMAP = 40; // Sequence, Function(1) -> Sequence
-#         // Order a sequence based on one or more attributes.
-#         ORDERBY   = 41; // Sequence, (!STRING | Ordering)... -> Sequence
-#         // Get all distinct elements of a sequence (like `uniq`).
-#         DISTINCT  = 42; // Sequence -> Sequence
-#         // Count the number of elements in a sequence, or only the elements that match
-#         // a given filter.
-#         COUNT     = 43; // Sequence -> NUMBER | Sequence, DATUM -> NUMBER | Sequence, Function(1) -> NUMBER
-#         IS_EMPTY = 86; // Sequence -> BOOL
-#         // Take the union of multiple sequences (preserves duplicate elements! (use distinct)).
-#         UNION     = 44; // Sequence... -> Sequence
-#         // Get the Nth element of a sequence.
-#         NTH       = 45; // Sequence, NUMBER -> DATUM
-#         // Takes a sequence, and three functions:
-#         // - A function to group the sequence by.
-#         // - A function to map over the groups.
-#         // - A reduction to apply to each of the groups.
-#         GROUPED_MAP_REDUCE = 46; // Sequence, Function(1), Function(1), Function(2), {base:DATUM} -> ARRAY
-#         // Groups a sequence by one or more attributes, and then applies a reduction.
-#         // The third argument is a special object literal giving the kind of operation to be
-#         // performed and any necessary arguments.
-#         // At present, GROUPBY suports the following operations
-#         // * {'COUNT': <ignored>} - count the size of the group
-#         // * {'SUM': attr} - sum the values of the given attribute across the group
-#         // * {'AVG': attr} - average the values of the given attribute across the group
-#         GROUPBY            = 47; // Sequence, ARRAY, !GROUP_BY_OBJECT -> Sequence
-#         INNER_JOIN         = 48; // Sequence, Sequence, Function(2) -> Sequence
-#         OUTER_JOIN         = 49; // Sequence, Sequence, Function(2) -> Sequence
-#         // An inner-join that does an equality comparison on two attributes.
-#         EQ_JOIN            = 50; // Sequence, !STRING, Sequence, {index:!STRING} -> Sequence
-#         ZIP                = 72; // Sequence -> Sequence
-# 
-#         // Array Ops
-#         // Insert an element in to an array at a given index.
-#         INSERT_AT          = 82; // ARRAY, NUMBER, DATUM -> ARRAY
-#         // Remove an element at a given index from an array.
-#         DELETE_AT          = 83; // ARRAY, NUMBER -> ARRAY |
-#                                  // ARRAY, NUMBER, NUMBER -> ARRAY
-#         // Change the element at a given index of an array.
-#         CHANGE_AT          = 84; // ARRAY, NUMBER, DATUM -> ARRAY
-#         // Splice one array in to another array.
-#         SPLICE_AT          = 85; // ARRAY, NUMBER, ARRAY -> ARRAY
-# 
-#         // * Type Ops
-#         // Coerces a datum to a named type (e.g. "bool").
-#         // If you previously used `stream_to_array`, you should use this instead
-#         // with the type "array".
-#         COERCE_TO = 51; // Top, STRING -> Top
-#         // Returns the named type of a datum (e.g. TYPEOF(true) = "BOOL")
-#         TYPEOF = 52; // Top -> STRING
-# 
-#         // * Write Ops (the OBJECTs contain data about number of errors etc.)
-#         // Updates all the rows in a selection.  Calls its Function with the row
-#         // to be updated, and then merges the result of that call.
-#         UPDATE   = 53; // StreamSelection, Function(1), {non_atomic:BOOL} -> OBJECT |
-#                        // SingleSelection, Function(1), {non_atomic:BOOL} -> OBJECT |
-#                        // StreamSelection, OBJECT,      {non_atomic:BOOL} -> OBJECT |
-#                        // SingleSelection, OBJECT,      {non_atomic:BOOL} -> OBJECT
-#         // Deletes all the rows in a selection.
-#         DELETE   = 54; // StreamSelection -> OBJECT | SingleSelection -> OBJECT
-#         // Replaces all the rows in a selection.  Calls its Function with the row
-#         // to be replaced, and then discards it and stores the result of that
-#         // call.
-#         REPLACE  = 55; // StreamSelection, Function(1), {non_atomic:BOOL} -> OBJECT | SingleSelection, Function(1), {non_atomic:BOOL} -> OBJECT
-#         // Inserts into a table.  If `upsert` is true, overwrites entries with
-#         // the same primary key (otherwise errors).
-#         INSERT   = 56; // Table, OBJECT, {upsert:BOOL} -> OBJECT | Table, Sequence, {upsert:BOOL} -> OBJECT
-# 
-#         // * Administrative OPs
-#         // Creates a database with a particular name.
-#         DB_CREATE    = 57; // STRING -> OBJECT
-#         // Drops a database with a particular name.
-#         DB_DROP      = 58; // STRING -> OBJECT
-#         // Lists all the databases by name.  (Takes no arguments)
-#         DB_LIST      = 59; // -> ARRAY
-#         // Creates a table with a particular name in a particular
-#         // database.  (You may omit the first argument to use the
-#         // default database.)
-#         TABLE_CREATE = 60; // Database, STRING, {datacenter:STRING, primary_key:STRING, cache_size:NUMBER, hard_durability:BOOL} -> OBJECT
-#                            // STRING, {datacenter:STRING, primary_key:STRING, cache_size:NUMBER, hard_durability:BOOL} -> OBJECT
-#         // Drops a table with a particular name from a particular
-#         // database.  (You may omit the first argument to use the
-#         // default database.)
-#         TABLE_DROP   = 61; // Database, STRING -> OBJECT
-#                            // STRING -> OBJECT
-#         // Lists all the tables in a particular database.  (You may
-#         // omit the first argument to use the default database.)
-#         TABLE_LIST   = 62; // Database -> ARRAY
-#                            //  -> ARRAY
-# 
-#         // * Secondary indexes OPs
-#         // Creates a new secondary index with a particular name and definition.
-#         INDEX_CREATE = 75; // Table, STRING, Function(1) -> OBJECT
-#         // Drops a secondary index with a particular name from the specified table.
-#         INDEX_DROP   = 76; // Table, STRING -> OBJECT
-#         // Lists all secondary indexes on a particular table.
-#         INDEX_LIST   = 77; // Table -> ARRAY
-# 
-#         // * Control Operators
-#         // Calls a function on data
-#         FUNCALL  = 64; // Function(*), DATUM... -> DATUM
-#         // Executes its first argument, and returns its second argument if it
-#         // got [true] or its third argument if it got [false] (like an `if`
-#         // statement).
-#         BRANCH  = 65; // BOOL, Top, Top -> Top
-#         // Returns true if any of its arguments returns true (short-circuits).
-#         // (Like `or` in most languages.)
-#         ANY     = 66; // BOOL... -> BOOL
-#         // Returns true if all of its arguments return true (short-circuits).
-#         // (Like `and` in most languages.)
-#         ALL     = 67; // BOOL... -> BOOL
-#         // Calls its Function with each entry in the sequence
-#         // and executes the array of terms that Function returns.
-#         FOREACH = 68; // Sequence, Function(1) -> OBJECT
-# 
-# ////////////////////////////////////////////////////////////////////////////////
-# ////////// Special Terms
-# ////////////////////////////////////////////////////////////////////////////////
-# 
-#         // An anonymous function.  Takes an array of numbers representing
-#         // variables (see [VAR] above), and a [Term] to execute with those in
-#         // scope.  Returns a function that may be passed an array of arguments,
-#         // then executes the Term with those bound to the variable names.  The
-#         // user will never construct this directly.  We use it internally for
-#         // things like `map` which take a function.  The "arity" of a [Function] is
-#         // the number of arguments it takes.
-#         // For example, here's what `_X_.map{|x| x+2}` turns into:
-#         // Term {
-#         //   type = MAP;
-#         //   args = [_X_,
-#         //           Term {
-#         //             type = Function;
-#         //             args = [Term {
-#         //                       type = DATUM;
-#         //                       datum = Datum {
-#         //                         type = R_ARRAY;
-#         //                         r_array = [Datum { type = R_NUM; r_num = 1; }];
-#         //                       };
-#         //                     },
-#         //                     Term {
-#         //                       type = ADD;
-#         //                       args = [Term {
-#         //                                 type = VAR;
-#         //                                 args = [Term {
-#         //                                           type = DATUM;
-#         //                                           datum = Datum { type = R_NUM;
-#         //                                                           r_num = 1};
-#         //                                         }];
-#         //                               },
-#         //                               Term {
-#         //                                 type = DATUM;
-#         //                                 datum = Datum { type = R_NUM; r_num = 2; };
-#         //                               }];
-#         //                     }];
-#         //           }];
-#         FUNC = 69; // ARRAY, Top -> ARRAY -> Top
-# 
-#         // Indicates to ORDER_BY that this attribute is to be sorted in ascending order.
-#         ASC = 73; // !STRING -> Ordering
-#         // Indicates to ORDER_BY that this attribute is to be sorted in descending order.
-#         DESC = 74; // !STRING -> Ordering
-# 
-#         // Gets info about anything.  INFO is most commonly called on tables.
-#         INFO = 79; // Top -> OBJECT
-# 
-#         // `a.match(b)` returns a match object if the string `a`
-#         // matches the regular expression `b`.
-#         MATCH = 97; // STRING, STRING -> DATUM
-# 
-#         // Select a number of elements from sequence with uniform distribution.
-#         SAMPLE = 81; // Sequence, NUMBER -> Sequence
-# 
-#         // Evaluates its first argument.  If that argument returns
-#         // NULL or throws an error related to the absence of an
-#         // expected value (for instance, accessing a non-existent
-#         // field or adding NULL to an integer), DEFAULT will either
-#         // return its second argument or execute it if it's a
-#         // function.  If the second argument is a function, it will be
-#         // passed either the text of the error or NULL as its
-#         // argument.
-#         DEFAULT = 92; // Top, Top -> Top
-#     }
-#     optional TermType type = 1;
-# 
-#     // This is only used when type is DATUM.
-#     optional Datum datum = 2;
-# 
-#     repeated Term args = 3; // Holds the positional arguments of the query.
-#     message AssocPair {
-#         optional string key = 1;
-#         optional Term val = 2;
-#     }
-#     repeated AssocPair optargs = 4; // Holds the optional arguments of the query.
-#     // (Note that the order of the optional arguments doesn't matter; think of a
-#     // Hash.)
-# 
-#     extensions 10000 to 20000;
-# }
-# 
-# ////////////////////////////////////////////////////////////////////////////////
-# //                                  EXAMPLE                                   //
-# ////////////////////////////////////////////////////////////////////////////////
-# //   ```ruby
-# //   r.table('tbl', {:use_outdated => true}).insert([{:id => 0}, {:id => 1}])
-# //   ```
-# // Would turn into:
-# //   Term {
-# //     type = INSERT;
-# //     args = [Term {
-# //               type = TABLE;
-# //               args = [Term {
-# //                         type = DATUM;
-# //                         datum = Datum { type = R_STR; r_str = "tbl"; };
-# //                       }];
-# //               optargs = [["use_outdated",
-# //                           Term {
-# //                             type = DATUM;
-# //                             datum = Datum { type = R_BOOL; r_bool = true; };
-# //                           }]];
-# //             },
-# //             Term {
-# //               type = MAKE_ARRAY;
-# //               args = [Term {
-# //                         type = DATUM;
-# //                         datum = Datum { type = R_OBJECT; r_object = [["id", 0]]; };
-# //                       },
-# //                       Term {
-# //                         type = DATUM;
-# //                         datum = Datum { type = R_OBJECT; r_object = [["id", 1]]; };
-# //                       }];
-# //             }]
-# //   }
-# // And the server would reply:
-# //   Response {
-# //     type = SUCCESS_ATOM;
-# //     token = 1;
-# //     response = [Datum { type = R_OBJECT; r_object = [["inserted", 2]]; }];
-# //   }
-# // Or, if there were an error:
-# //   Response {
-# //     type = RUNTIME_ERROR;
-# //     token = 1;
-# //     response = [Datum { type = R_STR; r_str = "The table `tbl` doesn't exist!"; }];
-# //     backtrace = [Frame { type = POS; pos = 0; }, Frame { type = POS; pos = 0; }];
-# //   }
+#!/usr/bin/env ruby
+# Generated by the protocol buffer compiler. DO NOT EDIT!
 
-require 'protobuf/message/message'
-require 'protobuf/message/enum'
-require 'protobuf/message/service'
-require 'protobuf/message/extend'
+require 'protocol_buffers'
 
-class VersionDummy < ::Protobuf::Message
-  defined_in __FILE__
-  class Version < ::Protobuf::Enum
-    defined_in __FILE__
-    V0_1 = value(:V0_1, 1063369270)
-    V0_2 = value(:V0_2, 1915781601)
+# forward declarations
+class VersionDummy < ::ProtocolBuffers::Message; end
+class Query < ::ProtocolBuffers::Message; end
+class Frame < ::ProtocolBuffers::Message; end
+class Backtrace < ::ProtocolBuffers::Message; end
+class Response < ::ProtocolBuffers::Message; end
+class Datum < ::ProtocolBuffers::Message; end
+class Term < ::ProtocolBuffers::Message; end
+
+class VersionDummy < ::ProtocolBuffers::Message
+  # forward declarations
+
+  # enums
+  module Version
+    include ::ProtocolBuffers::Enum
+    V0_1 = 1063369270
+    V0_2 = 1915781601
   end
+
 end
-class Query < ::Protobuf::Message
-  defined_in __FILE__
-  class QueryType < ::Protobuf::Enum
-    defined_in __FILE__
-    START = value(:START, 1)
-    CONTINUE = value(:CONTINUE, 2)
-    STOP = value(:STOP, 3)
+
+class Query < ::ProtocolBuffers::Message
+  # forward declarations
+  class AssocPair < ::ProtocolBuffers::Message; end
+
+  # enums
+  module QueryType
+    include ::ProtocolBuffers::Enum
+    START = 1
+    CONTINUE = 2
+    STOP = 3
   end
-  optional :QueryType, :type, 1
-  optional :Term, :query, 2
-  optional :int64, :token, 3
-  optional :bool, :OBSOLETE_noreply, 4, :default => false
-  class AssocPair < ::Protobuf::Message
-    defined_in __FILE__
+
+  # nested messages
+  class AssocPair < ::ProtocolBuffers::Message
     optional :string, :key, 1
-    optional :Term, :val, 2
+    optional ::Term, :val, 2
   end
-  repeated :AssocPair, :global_optargs, 6
+
+  optional ::Query::QueryType, :type, 1
+  optional ::Term, :query, 2
+  optional :int64, :token, 3
+  optional :bool, :OBSOLETE_noreply, 4, :default => false
+  repeated ::Query::AssocPair, :global_optargs, 6
 end
-class Frame < ::Protobuf::Message
-  defined_in __FILE__
-  class FrameType < ::Protobuf::Enum
-    defined_in __FILE__
-    POS = value(:POS, 1)
-    OPT = value(:OPT, 2)
+
+class Frame < ::ProtocolBuffers::Message
+  # forward declarations
+
+  # enums
+  module FrameType
+    include ::ProtocolBuffers::Enum
+    POS = 1
+    OPT = 2
   end
-  optional :FrameType, :type, 1
+
+  optional ::Frame::FrameType, :type, 1
   optional :int64, :pos, 2
   optional :string, :opt, 3
 end
-class Backtrace < ::Protobuf::Message
-  defined_in __FILE__
-  repeated :Frame, :frames, 1
+
+class Backtrace < ::ProtocolBuffers::Message
+  repeated ::Frame, :frames, 1
 end
-class Response < ::Protobuf::Message
-  defined_in __FILE__
-  class ResponseType < ::Protobuf::Enum
-    defined_in __FILE__
-    SUCCESS_ATOM = value(:SUCCESS_ATOM, 1)
-    SUCCESS_SEQUENCE = value(:SUCCESS_SEQUENCE, 2)
-    SUCCESS_PARTIAL = value(:SUCCESS_PARTIAL, 3)
-    CLIENT_ERROR = value(:CLIENT_ERROR, 16)
-    COMPILE_ERROR = value(:COMPILE_ERROR, 17)
-    RUNTIME_ERROR = value(:RUNTIME_ERROR, 18)
+
+class Response < ::ProtocolBuffers::Message
+  # forward declarations
+
+  # enums
+  module ResponseType
+    include ::ProtocolBuffers::Enum
+    SUCCESS_ATOM = 1
+    SUCCESS_SEQUENCE = 2
+    SUCCESS_PARTIAL = 3
+    CLIENT_ERROR = 16
+    COMPILE_ERROR = 17
+    RUNTIME_ERROR = 18
   end
-  optional :ResponseType, :type, 1
+
+  optional ::Response::ResponseType, :type, 1
   optional :int64, :token, 2
-  repeated :Datum, :response, 3
-  optional :Backtrace, :backtrace, 4
+  repeated ::Datum, :response, 3
+  optional ::Backtrace, :backtrace, 4
 end
-class Datum < ::Protobuf::Message
-  defined_in __FILE__
-  class DatumType < ::Protobuf::Enum
-    defined_in __FILE__
-    R_NULL = value(:R_NULL, 1)
-    R_BOOL = value(:R_BOOL, 2)
-    R_NUM = value(:R_NUM, 3)
-    R_STR = value(:R_STR, 4)
-    R_ARRAY = value(:R_ARRAY, 5)
-    R_OBJECT = value(:R_OBJECT, 6)
+
+class Datum < ::ProtocolBuffers::Message
+  # forward declarations
+  class AssocPair < ::ProtocolBuffers::Message; end
+
+  # enums
+  module DatumType
+    include ::ProtocolBuffers::Enum
+    R_NULL = 1
+    R_BOOL = 2
+    R_NUM = 3
+    R_STR = 4
+    R_ARRAY = 5
+    R_OBJECT = 6
   end
-  optional :DatumType, :type, 1
+
+  # nested messages
+  class AssocPair < ::ProtocolBuffers::Message
+    optional :string, :key, 1
+    optional ::Datum, :val, 2
+  end
+
+  optional ::Datum::DatumType, :type, 1
   optional :bool, :r_bool, 2
   optional :double, :r_num, 3
   optional :string, :r_str, 4
-  repeated :Datum, :r_array, 5
-  class AssocPair < ::Protobuf::Message
-    defined_in __FILE__
-    optional :string, :key, 1
-    optional :Datum, :val, 2
-  end
-  repeated :AssocPair, :r_object, 6
-  extensions 10000..20000
+  repeated ::Datum, :r_array, 5
+  repeated ::Datum::AssocPair, :r_object, 6
 end
-class Term < ::Protobuf::Message
-  defined_in __FILE__
-  class TermType < ::Protobuf::Enum
-    defined_in __FILE__
-    DATUM = value(:DATUM, 1)
-    MAKE_ARRAY = value(:MAKE_ARRAY, 2)
-    MAKE_OBJ = value(:MAKE_OBJ, 3)
-    VAR = value(:VAR, 10)
-    JAVASCRIPT = value(:JAVASCRIPT, 11)
-    ERROR = value(:ERROR, 12)
-    IMPLICIT_VAR = value(:IMPLICIT_VAR, 13)
-    DB = value(:DB, 14)
-    TABLE = value(:TABLE, 15)
-    GET = value(:GET, 16)
-    GET_ALL = value(:GET_ALL, 78)
-    EQ = value(:EQ, 17)
-    NE = value(:NE, 18)
-    LT = value(:LT, 19)
-    LE = value(:LE, 20)
-    GT = value(:GT, 21)
-    GE = value(:GE, 22)
-    NOT = value(:NOT, 23)
-    ADD = value(:ADD, 24)
-    SUB = value(:SUB, 25)
-    MUL = value(:MUL, 26)
-    DIV = value(:DIV, 27)
-    MOD = value(:MOD, 28)
-    APPEND = value(:APPEND, 29)
-    PREPEND = value(:PREPEND, 80)
-    DIFFERENCE = value(:DIFFERENCE, 95)
-    SET_INSERT = value(:SET_INSERT, 88)
-    SET_INTERSECTION = value(:SET_INTERSECTION, 89)
-    SET_UNION = value(:SET_UNION, 90)
-    SET_DIFFERENCE = value(:SET_DIFFERENCE, 91)
-    SLICE = value(:SLICE, 30)
-    SKIP = value(:SKIP, 70)
-    LIMIT = value(:LIMIT, 71)
-    INDEXES_OF = value(:INDEXES_OF, 87)
-    CONTAINS = value(:CONTAINS, 93)
-    GETATTR = value(:GETATTR, 31)
-    KEYS = value(:KEYS, 94)
-    HAS_FIELDS = value(:HAS_FIELDS, 32)
-    WITH_FIELDS = value(:WITH_FIELDS, 96)
-    PLUCK = value(:PLUCK, 33)
-    WITHOUT = value(:WITHOUT, 34)
-    MERGE = value(:MERGE, 35)
-    BETWEEN = value(:BETWEEN, 36)
-    REDUCE = value(:REDUCE, 37)
-    MAP = value(:MAP, 38)
-    FILTER = value(:FILTER, 39)
-    CONCATMAP = value(:CONCATMAP, 40)
-    ORDERBY = value(:ORDERBY, 41)
-    DISTINCT = value(:DISTINCT, 42)
-    COUNT = value(:COUNT, 43)
-    IS_EMPTY = value(:IS_EMPTY, 86)
-    UNION = value(:UNION, 44)
-    NTH = value(:NTH, 45)
-    GROUPED_MAP_REDUCE = value(:GROUPED_MAP_REDUCE, 46)
-    GROUPBY = value(:GROUPBY, 47)
-    INNER_JOIN = value(:INNER_JOIN, 48)
-    OUTER_JOIN = value(:OUTER_JOIN, 49)
-    EQ_JOIN = value(:EQ_JOIN, 50)
-    ZIP = value(:ZIP, 72)
-    INSERT_AT = value(:INSERT_AT, 82)
-    DELETE_AT = value(:DELETE_AT, 83)
-    CHANGE_AT = value(:CHANGE_AT, 84)
-    SPLICE_AT = value(:SPLICE_AT, 85)
-    COERCE_TO = value(:COERCE_TO, 51)
-    TYPEOF = value(:TYPEOF, 52)
-    UPDATE = value(:UPDATE, 53)
-    DELETE = value(:DELETE, 54)
-    REPLACE = value(:REPLACE, 55)
-    INSERT = value(:INSERT, 56)
-    DB_CREATE = value(:DB_CREATE, 57)
-    DB_DROP = value(:DB_DROP, 58)
-    DB_LIST = value(:DB_LIST, 59)
-    TABLE_CREATE = value(:TABLE_CREATE, 60)
-    TABLE_DROP = value(:TABLE_DROP, 61)
-    TABLE_LIST = value(:TABLE_LIST, 62)
-    INDEX_CREATE = value(:INDEX_CREATE, 75)
-    INDEX_DROP = value(:INDEX_DROP, 76)
-    INDEX_LIST = value(:INDEX_LIST, 77)
-    FUNCALL = value(:FUNCALL, 64)
-    BRANCH = value(:BRANCH, 65)
-    ANY = value(:ANY, 66)
-    ALL = value(:ALL, 67)
-    FOREACH = value(:FOREACH, 68)
-    FUNC = value(:FUNC, 69)
-    ASC = value(:ASC, 73)
-    DESC = value(:DESC, 74)
-    INFO = value(:INFO, 79)
-    MATCH = value(:MATCH, 97)
-    SAMPLE = value(:SAMPLE, 81)
-    DEFAULT = value(:DEFAULT, 92)
+
+class Term < ::ProtocolBuffers::Message
+  # forward declarations
+  class AssocPair < ::ProtocolBuffers::Message; end
+
+  # enums
+  module TermType
+    include ::ProtocolBuffers::Enum
+    DATUM = 1
+    MAKE_ARRAY = 2
+    MAKE_OBJ = 3
+    VAR = 10
+    JAVASCRIPT = 11
+    ERROR = 12
+    IMPLICIT_VAR = 13
+    DB = 14
+    TABLE = 15
+    GET = 16
+    GET_ALL = 78
+    EQ = 17
+    NE = 18
+    LT = 19
+    LE = 20
+    GT = 21
+    GE = 22
+    NOT = 23
+    ADD = 24
+    SUB = 25
+    MUL = 26
+    DIV = 27
+    MOD = 28
+    APPEND = 29
+    PREPEND = 80
+    DIFFERENCE = 95
+    SET_INSERT = 88
+    SET_INTERSECTION = 89
+    SET_UNION = 90
+    SET_DIFFERENCE = 91
+    SLICE = 30
+    SKIP = 70
+    LIMIT = 71
+    INDEXES_OF = 87
+    CONTAINS = 93
+    GET_FIELD = 31
+    KEYS = 94
+    HAS_FIELDS = 32
+    WITH_FIELDS = 96
+    PLUCK = 33
+    WITHOUT = 34
+    MERGE = 35
+    BETWEEN = 36
+    REDUCE = 37
+    MAP = 38
+    FILTER = 39
+    CONCATMAP = 40
+    ORDERBY = 41
+    DISTINCT = 42
+    COUNT = 43
+    IS_EMPTY = 86
+    UNION = 44
+    NTH = 45
+    GROUPED_MAP_REDUCE = 46
+    GROUPBY = 47
+    INNER_JOIN = 48
+    OUTER_JOIN = 49
+    EQ_JOIN = 50
+    ZIP = 72
+    INSERT_AT = 82
+    DELETE_AT = 83
+    CHANGE_AT = 84
+    SPLICE_AT = 85
+    COERCE_TO = 51
+    TYPEOF = 52
+    UPDATE = 53
+    DELETE = 54
+    REPLACE = 55
+    INSERT = 56
+    DB_CREATE = 57
+    DB_DROP = 58
+    DB_LIST = 59
+    TABLE_CREATE = 60
+    TABLE_DROP = 61
+    TABLE_LIST = 62
+    INDEX_CREATE = 75
+    INDEX_DROP = 76
+    INDEX_LIST = 77
+    FUNCALL = 64
+    BRANCH = 65
+    ANY = 66
+    ALL = 67
+    FOREACH = 68
+    FUNC = 69
+    ASC = 73
+    DESC = 74
+    INFO = 79
+    MATCH = 97
+    SAMPLE = 81
+    DEFAULT = 92
+    JSON = 98
   end
-  optional :TermType, :type, 1
-  optional :Datum, :datum, 2
-  repeated :Term, :args, 3
-  class AssocPair < ::Protobuf::Message
-    defined_in __FILE__
+
+  # nested messages
+  class AssocPair < ::ProtocolBuffers::Message
     optional :string, :key, 1
-    optional :Term, :val, 2
+    optional ::Term, :val, 2
   end
-  repeated :AssocPair, :optargs, 4
-  extensions 10000..20000
-end
+
+  optional ::Term::TermType, :type, 1
+  optional ::Datum, :datum, 2
+  repeated ::Term, :args, 3
+  repeated ::Term::AssocPair, :optargs, 4
+end
+

data/lib/rethinkdb.rb

@@ -2,23 +2,6 @@
 require 'rubygems'
 require 'ql2.pb.rb'
 
-if 2**63 != 9223372036854775808
-  $stderr.puts "WARNING: Ruby believes 2**63 = #{2**63} rather than 9223372036854775808!"
-  $stderr.puts "Consider upgrading your verison of Ruby."
-  $stderr.puts "Hot-patching ruby_protobuf to compensate..."
-  rethinkdb_verbose, $VERBOSE = $VERBOSE, nil
-  module Protobuf
-    module Field
-      class VarintField < BaseField
-        INT64_MAX = 9223372036854775807
-        INT64_MIN = -9223372036854775808
-        UINT64_MAX = 18446744073709551615
-      end
-    end
-  end
-  $VERBOSE = rethinkdb_verbose
-end
-
 require 'socket'
 require 'pp'
 
@@ -78,10 +61,10 @@ module RethinkDB
 
     attr_accessor :body, :bitop
 
-    def initialize(body = nil, bitop = nil)
+    def initialize(body = nil, bitop = nil, context = nil)
       @body = body
       @bitop = bitop
-      @body.context = RPP.sanitize_context caller if @body
+      @body.context = (context || RPP.sanitize_context(caller)) if @body
     end
 
     def pp

data/lib/rpp.rb

@@ -3,6 +3,10 @@ require 'prettyprint'
 
 module RethinkDB
   module RPP
+    @@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;
@@ -103,7 +107,7 @@ module RethinkDB
         return res
       end
 
-      name = term.type.to_s.downcase
+      name = @@termtype_to_str[term.type].downcase
       args = term.args.dup
       optargs = term.optargs.dup
 

data/lib/shim.rb

@@ -1,3 +1,5 @@
+require 'json'
+
 module RethinkDB
   module Shim
     def self.datum_to_native d
@@ -69,40 +71,65 @@ module RethinkDB
   class RQL
     def to_pb; @body; end
 
-    def expr(x)
-      unbound_if @body
-      return x if x.class == RQL
-      datum_types = [Fixnum, Float, Bignum, String, Symbol,
+    @@datum_types = [Fixnum, Float, Bignum, String, Symbol,
                      TrueClass, FalseClass, NilClass]
 
-      if datum_types.include? x.class
-        return RQL.new(Shim.native_to_datum_term(x))
+    def any_to_pb(x, context)
+      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 fast_expr(x, context, 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)
       end
 
-      t = Term.new
       case x
       when Array
+        args = x.map{|y| fast_expr(y, context, allow_json)}
+        return x if allow_json && args.all?{|y| y.class != RQL}
+        t = Term.new
         t.type = Term::TermType::MAKE_ARRAY
-        t.args = x.map{|y| expr(y).to_pb}
+        t.args = args.map{|y| any_to_pb(y, context)}
+        return RQL.new(t, nil, context)
       when Hash
+        kvs = x.map{|k,v| [k, fast_expr(v, context, 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 = x.map{|k,v|
+        t.optargs = kvs.map{|k,v|
           ap = Term::AssocPair.new;
-          if [Symbol, String].include? k.class
+          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 = expr(v).to_pb
+          ap.val = any_to_pb(v, context)
           ap
         }
+        return RQL.new(t, nil, context)
       when Proc
-        t = RQL.new.new_func(&x).to_pb
+        t = RQL.new(nil, nil, context).new_func(&x).to_pb
+        return RQL.new(t, nil, context)
       else raise RqlDriverError, "r.expr can't handle #{x.inspect} of type #{x.class}"
       end
+    end
 
-      return RQL.new(t)
+    def expr(x, opts={})
+      allow_json = opts[:allow_json]
+      unbound_if @body
+      context = RPP.sanitize_context(caller)
+      res = fast_expr(x, context, allow_json)
+      return res if res.class == RQL
+      return RQL.new(any_to_pb(res, context), nil, context)
     end
 
     def coerce(other)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification 
 name: rethinkdb
 version: !ruby/object:Gem::Version 
-  hash: 111
+  hash: 103
   prerelease: 
   segments: 
   - 1
-  - 6
+  - 7
   - 0
   - 0
-  version: 1.6.0.0
+  version: 1.7.0.0
 platform: ruby
 authors: 
 - RethinkDB Inc.
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2013-06-13 00:00:00 Z
+date: 2013-07-03 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: json
@@ -33,7 +33,7 @@ dependencies:
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  name: ruby_protobuf
+  name: ruby-protocol-buffers
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
@@ -55,13 +55,13 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
-- lib/net.rb
 - lib/exc.rb
 - lib/ql2.pb.rb
+- lib/func.rb
+- lib/net.rb
 - lib/rethinkdb.rb
 - lib/rpp.rb
 - lib/shim.rb
-- lib/func.rb
 homepage: http://rethinkdb.com
 licenses: 
 - Apache-2