rethinkdb 1.5.0.0 → 1.6.0.0

data/lib/func.rb

@@ -7,14 +7,23 @@ module RethinkDB
       RQL.new.func(args, body)
     end
 
-    @@special_optargs = {
-      :replace => :non_atomic, :update => :non_atomic, :insert => :upsert
-    }
-    @@opt_off = {
+    # Offsets of the "optarg" optional arguments hash in respective
+    # methods.  Some methods change this depending on whether they're
+    # passed a block -- they take a hash specifying the offset for
+    # each circumstance, instead of an integer.  -1 can be supplied to
+    # mean the "last" argument -- whatever argument is specified will
+    # 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.
+    @@optarg_offsets = {
+      :replace => {:with_block => 0, :without => 1},
+      :update => {:with_block => 0, :without => 1},
+      :insert => 1,
+      :delete => -1,
       :reduce => -1, :between => -1, :grouped_map_reduce => -1,
       :table => -1, :table_create => -1,
       :get_all => -1, :eq_join => -1,
-      :javascript => -1
+      :javascript => -1, :filter => {:with_block => 0, :without => 1}
     }
     @@rewrites = {
       :< => :lt, :<= => :le, :> => :gt, :>= => :ge,
@@ -48,11 +57,15 @@ module RethinkDB
       termtype = Term::TermType.values[m.to_s.upcase.to_sym]
       unbound_if(!termtype, m)
 
-      if (opt_name = @@special_optargs[m])
-        a = optarg_jiggle(a, opt_name)
-        opt_offset = -1
-      end
-      if (opt_offset ||= @@opt_off[m])
+      if (opt_offset = @@optarg_offsets[m])
+        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
 
@@ -76,15 +89,6 @@ module RethinkDB
     end
     def groupby(*a, &b); group_by(*a, &b); end
 
-    def optarg_jiggle(args, optarg)
-      if (ind = args.map{|x| x.class == Symbol ? x : nil}.index(optarg))
-        args << {args.delete_at(ind) => true}
-      else
-        args << {}
-      end
-      return args
-    end
-
     def connect(*args)
       unbound_if @body
       Connection.new(*args)

data/lib/net.rb

@@ -75,17 +75,26 @@ module RethinkDB
   end
 
   class Connection
+    def auto_reconnect(x=true)
+      @auto_reconnect = x
+      self
+    end
     def repl; RQL.set_default_conn self; end
 
-    def initialize(host='localhost', port=28015, default_db=nil)
+    def initialize(opts={})
       begin
         @abort_module = ::IRB
       rescue NameError => e
         @abort_module = Faux_Abort
       end
+
+      opts = {:host => opts} if opts.class == String
+      @host = opts[:host] || "localhost"
+      @port = opts[:port] || 28015
+      default_db = opts[:db]
+      @auth_key = opts[:auth_key] || ""
+
       @@last = self
-      @host = host
-      @port = port
       @default_opts = default_db ? {:db => RQL.new.db(default_db)} : {}
       @conn_id = 0
       reconnect
@@ -98,6 +107,7 @@ module RethinkDB
       noreply ? nil : wait(q.token)
     end
     def run(msg, opts)
+      reconnect if @auto_reconnect && (!@socket || !@listener)
       raise RuntimeError, "Error: Connection Closed." if !@socket || !@listener
       q = Query.new
       q.type = Query::QueryType::START
@@ -135,9 +145,9 @@ module RethinkDB
     end
 
     def dispatch msg
-      PP.pp msg if $DEBUG
+      # PP.pp msg if $DEBUG
       payload = msg.serialize_to_string
-      #File.open('sexp_payloads.txt', 'a') {|f| f.write(payload.inspect+"\n")}
+      # File.open('sexp_payloads.txt', 'a') {|f| f.write(payload.inspect+"\n")}
       send([payload.length].pack('L<') + payload)
       return msg.token
     end
@@ -172,7 +182,7 @@ module RethinkDB
     end
 
     @@last = nil
-    @@magic_number = 0x3f61ba36
+    @@magic_number = VersionDummy::Version::V0_2
 
     def debug_socket; @socket; end
 
@@ -212,6 +222,17 @@ module RethinkDB
         end
       end
       @socket.write([@@magic_number].pack('L<'))
+
+      @socket.write([@auth_key.size].pack('L<') + @auth_key)
+      response = ""
+      while response[-1..-1] != "\0"
+        response += @socket.read_exn(1)
+      end
+      response = response[0...-1]
+      if response != "SUCCESS"
+        raise RqlRuntimeError,"Server dropped connection with message: \"#{response}\""
+      end
+
       @listener.terminate if @listener
       @listener = Thread.new do
         loop do

data/lib/ql2.pb.rb

@@ -10,6 +10,14 @@
 # // 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
@@ -33,6 +41,7 @@
 #                        // non-conforming protobuf libraries
 #     enum Version {
 #         V0_1 = 0x3f61ba36;
+#         V0_2 = 0x723081e1;
 #     }
 # }
 # 
@@ -211,8 +220,12 @@
 #         // 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.
-#         ERROR        = 12; // STRING -> Error
+#         // 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
 # 
@@ -244,17 +257,39 @@
 #         // 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
-#         // Check whether an object contains all of a set of attributes, or map
-#         // that over a sequence.
-#         CONTAINS = 32; // OBJECT, STRING... -> BOOL
+#         // 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
@@ -269,15 +304,26 @@
 #         BETWEEN   = 36; // StreamSelection, DATUM, DATUM, {:index:!STRING} -> StreamSelection
 #         REDUCE    = 37; // Sequence, Function(2), {base:DATUM} -> DATUM
 #         MAP       = 38; // Sequence, Function(1) -> Sequence
-#         FILTER    = 39; // Sequence, Function(1) -> Sequence | Sequence, OBJECT -> 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.
-#         COUNT     = 43; // Sequence -> NUMBER
+#         // 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.
@@ -286,7 +332,7 @@
 #         // - 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} -> Sequence
+#         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.
@@ -301,6 +347,16 @@
 #         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").
@@ -423,6 +479,23 @@
 # 
 #         // 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;
 # 
@@ -498,6 +571,7 @@ class VersionDummy < ::Protobuf::Message
   class Version < ::Protobuf::Enum
     defined_in __FILE__
     V0_1 = value(:V0_1, 1063369270)
+    V0_2 = value(:V0_2, 1915781601)
   end
 end
 class Query < ::Protobuf::Message
@@ -602,11 +676,21 @@ class Term < ::Protobuf::Message
     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)
-    CONTAINS = value(:CONTAINS, 32)
+    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)
@@ -618,6 +702,7 @@ class Term < ::Protobuf::Message
     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)
@@ -626,6 +711,10 @@ class Term < ::Protobuf::Message
     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)
@@ -650,6 +739,9 @@ class Term < ::Protobuf::Message
     ASC = value(:ASC, 73)
     DESC = value(:DESC, 74)
     INFO = value(:INFO, 79)
+    MATCH = value(:MATCH, 97)
+    SAMPLE = value(:SAMPLE, 81)
+    DEFAULT = value(:DEFAULT, 92)
   end
   optional :TermType, :type, 1
   optional :Datum, :datum, 2

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification 
 name: rethinkdb
 version: !ruby/object:Gem::Version 
-  hash: 119
+  hash: 111
   prerelease: 
   segments: 
   - 1
-  - 5
+  - 6
   - 0
   - 0
-  version: 1.5.0.0
+  version: 1.6.0.0
 platform: ruby
 authors: 
 - RethinkDB Inc.
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2013-05-16 00:00:00 Z
+date: 2013-06-13 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: json
@@ -55,13 +55,13 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
+- lib/net.rb
 - lib/exc.rb
 - lib/ql2.pb.rb
 - lib/rethinkdb.rb
 - lib/rpp.rb
 - lib/shim.rb
 - lib/func.rb
-- lib/net.rb
 homepage: http://rethinkdb.com
 licenses: 
 - Apache-2
@@ -91,7 +91,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.7.2
+rubygems_version: 1.8.15
 signing_key: 
 specification_version: 3
 summary: This package provides the Ruby driver library for the RethinkDB database server.