rethinkdb 1.2.6.1 → 1.4.0.0

data/lib/rethinkdb.rb

@@ -1,16 +1,77 @@
 # Copyright 2010-2012 RethinkDB, all rights reserved.
 require 'rubygems'
-require 'query_language.pb.rb'
+require 'ql2.pb.rb'
 require 'socket'
 require 'pp'
 
-load 'bt.rb'
-load 'utils.rb'
-load 'protob_compiler.rb'
-
+load 'exc.rb'
 load 'net.rb'
+load 'shim.rb'
+load 'func.rb'
+load 'rpp.rb'
+
+class Term
+  attr_accessor :context
+  attr_accessor :is_error
+
+  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)
+      args == [] ? RQL.new : RQL.new.expr(*args)
+    end
+  end
+
+  module Utils
+    def get_mname(i = 0)
+      caller[i]=~/`(.*?)'/
+      $1
+    end
+    def unbound_if (x, name = nil)
+      name = get_mname(1) if not name
+      raise NoMethodError, "undefined method `#{name}'" if x
+    end
+  end
+
+  class RQL
+    include Utils
+
+    attr_accessor :body, :bitop
+
+    def initialize(body = nil, bitop = nil)
+      @body = body
+      @bitop = bitop
+      @body.context = RPP.sanitize_context caller if @body
+    end
 
-load 'data_collectors.rb'
-load 'base_classes.rb'
-load 'query.rb'
-load 'rql.rb'
+    def pp
+      unbound_if !@body
+      RethinkDB::RPP.pp(@body)
+    end
+    def inspect
+      @body ? pp : super
+    end
+  end
+end

data/lib/rpp.rb

@@ -0,0 +1,191 @@
+require 'pp'
+require 'prettyprint'
+
+module RethinkDB
+  module RPP
+    def self.sanitize_context context
+      if __FILE__ =~ /^(.*\/)[^\/]+.rb$/
+        prefix = $1;
+        context.reject{|x| x =~ /^#{prefix}/}
+      else
+        context
+      end
+    end
+
+    def self.pp_int_optargs(q, optargs, pre_dot = false)
+      q.text("r(") if pre_dot
+      q.group(1, "{", "}") {
+        optargs.each_with_index {|optarg, i|
+          if i != 0
+            q.text(",")
+            q.breakable
+          end
+          q.text(":#{optarg.key} =>")
+          q.nest(2) {
+            q.breakable
+            pp_int(q, optarg.val)
+          }
+        }
+      }
+      q.text(")") if pre_dot
+    end
+
+    def self.pp_int_args(q, args, pre_dot = false)
+      q.text("r(") if pre_dot
+      q.group(1, "[", "]") {
+        args.each_with_index {|arg, i|
+          if i != 0
+            q.text(",")
+            q.breakable
+          end
+          pp_int(q, arg)
+        }
+      }
+      q.text(")") if pre_dot
+    end
+
+    def self.pp_int_datum(q, dat, pre_dot)
+      q.text("r(") if pre_dot
+      q.text(Shim.datum_to_native(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)
+        }
+        q.breakable('')
+      }
+    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
+    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)
+        q.text("\x7", 0) if term.is_error
+        return res
+      end
+
+      if term.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
+        q.text("r(") if pre_dot
+        q.text("lambda")
+        res = pp_int_func(q, term)
+        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
+      end
+
+      name = term.type.to_s.downcase
+      args = term.args.dup
+      optargs = term.optargs.dup
+
+      if can_prefix(name, args) && first_arg = args.shift
+        pp_int(q, first_arg, true)
+      else
+        q.text("r")
+      end
+      if name == "getattr"
+        argstart, argstop = "[", "]"
+      else
+        q.text(".")
+        q.text(name)
+        argstart, argstop = "(", ")"
+      end
+
+      func = args[-1] && args[-1].type == Term::TermType::FUNC && args.pop
+
+      if args != [] || optargs != []
+        q.group(0, argstart, argstop) {
+          pushed = nil
+          q.nest(2) {
+            args.each {|arg|
+              if !pushed
+                pushed = true
+                q.breakable('')
+              else
+                q.text(",")
+                q.breakable
+              end
+              pp_int(q, arg)
+            }
+            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
+            end
+          }
+          q.breakable('')
+        }
+      end
+
+      pp_int_func(q, func) if func
+      q.text("\x7", 0) if term.is_error
+    end
+
+    def self.pp term
+      begin
+        @@context = nil
+        q = PrettyPrint.new
+        pp_int(q, term, true)
+        q.flush
+
+        in_bt = false
+        q.output.split("\n").map {|line|
+          line = line.gsub(/^ */) {|x| x+"\x7"} if in_bt
+          arr = line.split("\x7")
+          if arr[1]
+            in_bt = !(arr[2] || (line[-1] == 0x7))
+            [arr.join(""), " "*arr[0].size + "^"*arr[1].size]
+          else
+            line
+          end
+        }.flatten.join("\n") +
+          (@@context ?
+           "\nErronious_Portion_Constructed:\n" +
+           "#{@@context.map{|x| "\tfrom "+x}.join("\n")}" +
+           "\nCalled:" : "")
+      rescue Exception => e
+        raise e
+        "AN ERROR OCCURED DURING PRETTY-PRINTING:\n#{e.inspect}\n" +
+          "FALLING BACK TO PROTOBUF PRETTY-PRINTER.\n#{@term.inspect}"
+      end
+    end
+  end
+end

data/lib/shim.rb

@@ -0,0 +1,101 @@
+module RethinkDB
+  module Shim
+    def self.datum_to_native d
+      raise RqlRuntimeError, "SHENANIGANS" if d.class != Datum
+      dt = Datum::DatumType
+      case d.type
+      when dt::R_NUM then 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}
+      when dt::R_OBJECT then Hash[d.r_object.map{|x| [x.key, datum_to_native(x.val)]}]
+      else raise RqlRuntimeError, "Unimplemented."
+      end
+    end
+
+    def self.response_to_native(r, orig_term)
+      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])
+        when rt::SUCCESS_PARTIAL then r.response.map{|d| datum_to_native(d)}
+        when rt::SUCCESS_SEQUENCE then r.response.map{|d| datum_to_native(d)}
+        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}"
+        else raise RqlRuntimeError, "Unexpected response: #{r.inspect}"
+        end
+      rescue RqlError => e
+        term = orig_term.dup
+        term.bt_tag(bt)
+        $t = term
+        raise e.class, "#{e.message}\nBacktrace:\n#{RPP.pp(term)}"
+      end
+    end
+
+    def self.native_to_datum_term x
+      dt = Datum::DatumType
+      d = Datum.new
+      case x.class.hash
+      when Fixnum.hash     then d.type = dt::R_NUM;  d.r_num = x
+      when Float.hash      then d.type = dt::R_NUM;  d.r_num = x
+      when Bignum.hash     then d.type = dt::R_NUM;  d.r_num = x
+      when String.hash     then d.type = dt::R_STR;  d.r_str = x
+      when Symbol.hash     then d.type = dt::R_STR;  d.r_str = x.to_s
+      when TrueClass.hash  then d.type = dt::R_BOOL; d.r_bool = x
+      when FalseClass.hash then d.type = dt::R_BOOL; d.r_bool = x
+      when NilClass.hash   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
+
+    def expr(x)
+      unbound_if @body
+      return x if x.class == RQL
+      datum_types = [Fixnum, Float, Bignum, String, Symbol, TrueClass, FalseClass, NilClass]
+      if datum_types.map{|y| y.hash}.include? x.class.hash
+        return RQL.new(Shim.native_to_datum_term(x))
+      end
+
+      t = Term.new
+      case x.class.hash
+      when Array.hash
+        t.type = Term::TermType::MAKE_ARRAY
+        t.args = x.map{|y| expr(y).to_pb}
+      when Hash.hash
+        t.type = Term::TermType::MAKE_OBJ
+        t.optargs = x.map{|k,v| ap = Term::AssocPair.new;
+          ap.key = k.to_s; ap.val = expr(v).to_pb; ap}
+      when Proc.hash
+        t = RQL.new.new_func(&x).to_pb
+      else raise RqlDriverError, "r.expr can't handle #{x.inspect} of type #{x.class}"
+      end
+
+      return RQL.new(t)
+    end
+
+    def coerce(other)
+      [RQL.new.expr(other), self]
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification 
 name: rethinkdb
 version: !ruby/object:Gem::Version 
-  hash: 85
+  hash: 127
   prerelease: 
   segments: 
   - 1
-  - 2
-  - 6
-  - 1
-  version: 1.2.6.1
+  - 4
+  - 0
+  - 0
+  version: 1.4.0.0
 platform: ruby
 authors: 
 - RethinkDB Inc.
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2013-01-15 00:00:00 Z
+date: 2013-03-15 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: json
@@ -55,21 +55,13 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
-- lib/tables.rb
-- lib/jsons.rb
-- lib/query.rb
-- lib/rethinkdb.rb
-- lib/bt.rb
-- lib/writes.rb
-- lib/rql.rb
-- lib/utils.rb
-- lib/protob_compiler.rb
+- lib/exc.rb
+- lib/func.rb
 - lib/net.rb
-- lib/query_language.pb.rb
-- lib/sequence.rb
-- lib/base_classes.rb
-- lib/streams.rb
-- lib/data_collectors.rb
+- lib/ql2.pb.rb
+- lib/rethinkdb.rb
+- lib/rpp.rb
+- lib/shim.rb
 homepage: http://rethinkdb.com
 licenses: 
 - Apache-2
@@ -99,7 +91,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 1.7.2
 signing_key: 
 specification_version: 3
 summary: This package provides the Ruby driver library for the RethinkDB database server.

data/lib/base_classes.rb

@@ -1,39 +0,0 @@
-# Copyright 2010-2012 RethinkDB, all rights reserved.
-#TODO: toplevel doc
-module RethinkDB
-  class RQL_Query; end
-  class Read_Query < RQL_Query # :nodoc:
-  end
-  class Write_Query < RQL_Query # :nodoc:
-  end
-  class Meta_Query < RQL_Query # :nodoc:
-  end
-
-  module Sequence; end
-  class JSON_Expression < Read_Query; include Sequence; end
-  class Single_Row_Selection < JSON_Expression; end
-  class Stream_Expression < Read_Query; include Sequence; end
-  class Multi_Row_Selection < Stream_Expression; end
-
-  class Database; end
-  class Table; end
-
-  class Connection; end
-  class Query_Results; include Enumerable; end
-
-  module RQL; end
-
-  # Shortcuts to easily build RQL queries.
-  module Shortcuts
-    # The only shortcut right now.  May be used as a wrapper to create
-    # RQL values or as a shortcut to access function in the RQL
-    # namespace.  For example, the following are equivalent:
-    #   r.add(1, 2)
-    #   RethinkDB::RQL.add(1, 2)
-    #   r(1) + r(2)
-    #   r(3)
-    def r(*args)
-      (args == [] ) ? RethinkDB::RQL : RQL.expr(*args)
-    end
-  end
-end