rethinkdb 1.2.6.1 → 1.4.0.0

data/lib/bt.rb

@@ -1,148 +0,0 @@
-# Copyright 2010-2012 RethinkDB, all rights reserved.
-module RethinkDB
-  module BT_Mixin
-    attr_accessor :highlight, :line
-
-    def sanitize_context(context)
-      if __FILE__ =~ /^(.*\/)[^\/]+.rb$/
-        prefix = $1;
-        context.reject{|x| x =~ /^#{prefix}/}
-      else
-        context
-      end
-    end
-
-    def format_highlights(str)
-      str.chars.map{|x| x == "\000" ? "^" : " "}.join.rstrip
-    end
-
-    def force_raise(query, debug=false)
-      obj = query.run
-      #maybe_reformat_err(query, obj);
-      PP.pp obj if debug
-      if obj.class == Query_Results
-        obj = obj.to_a
-      elsif obj.class == Hash
-        raise RuntimeError,obj['first_error'] if obj['first_error']
-      end
-      obj
-    end
-
-    def maybe_reformat_err(query, obj)
-      if obj.class == Hash && (err = obj['first_error'])
-        obj['first_error'] = format_err(query, err)
-      end
-    end
-
-    def format_err(query, err)
-      parts = err.split("\nBacktrace:\n")
-      errline = parts[0] || ""
-      bt = (parts[1] && parts[1].split("\n")) || []
-      errline+"\n"+query.print_backtrace(bt)
-    end
-
-    def set(sym,val)
-      @map = {} if not @map
-      res, @map[sym] = @map[sym], val
-      return res
-    end
-    def consume sym
-      @map = {} if not @map
-      res, @map[sym] = @map[sym], nil
-      return res.nil? ? 0 : res
-    end
-    def expand arg
-      case arg
-      when 'attr'           then []
-      when 'attrname'       then []
-      when 'base'           then [1+consume(:reduce)]
-      when 'body'           then [4+consume(:reduce)]
-      when 'datacenter'     then []
-      when 'db_name'        then []
-      when 'expr'           then [2]
-      when 'false'          then [3]
-      when 'group_mapping'  then [1, 1, 1]
-      when 'key'            then [3]
-      when 'keyname'        then []
-      when 'lowerbound'     then [1, 2]
-      when 'mapping'        then [1, 2]
-      when 'modify_map'     then [2, 1]
-      when 'order_by'       then []
-      when 'point_map'      then [4, 1]
-      when 'predicate'      then [1, 2]
-      when 'reduce'         then [1]
-      when 'reduction'      then set(:reduce, -1); [1, 3]
-      when 'stream'         then [1]
-      when 'table_name'     then []
-      when 'table_ref'      then []
-      when 'test'           then [1]
-      when 'true'           then [2]
-      when 'upperbound'     then [1, 3]
-      when 'value_mapping'  then [1, 2, 1]
-      when 'view'           then [1]
-      when /arg:([0-9]+)/   then [2, $1.to_i]
-      when /attrs:([0-9]+)/ then []
-      when /elem:([0-9]+)/  then [$1.to_i+1]
-      when /bind:(.+)$/     then [1, $1]
-      when /key:(.+)$/      then [1..-1, $1]
-      when /query:([0-9]+)/ then [3, $1.to_i]
-      when /term:([0-9]+)/  then [2, $1.to_i]
-      else  [:error]
-      end
-    end
-
-    def recur(arr, lst, val)
-      if lst[0].class == String
-        entry = arr[0..-1].find{|x| x[0].to_s == lst[0]}
-        raise RuntimeError if not entry
-        mark(entry[1], lst[1..-1], val)
-      elsif lst[0].class == Fixnum || lst[0].class == Range
-        mark(arr[lst[0]], lst[1..-1], val) if lst != []
-      else
-        raise RuntimeError
-      end
-    end
-    def mark(query, lst, val)
-      #PP.pp [lst, query.class, query]
-      if query.class == Array
-        recur(query, lst, val) if lst != []
-      elsif query.kind_of? RQL_Query
-        if lst == []
-          @line = sanitize_context(query.context)[0]
-          val,query.marked = query.marked, val
-          val
-        else
-          recur(query.body, lst, val)
-        end
-      else raise RuntimeError
-      end
-    end
-
-    def with_marked_error(query, bt)
-      @map = {}
-      bt = bt.map{|x| expand x}.flatten
-      raise RuntimeError if bt.any?{|x| x == :error}
-      old = mark(query, bt, :error)
-      res = yield
-      mark(query, bt, old)
-      return res
-    end
-
-    def with_highlight
-      @highlight = true
-      str = yield
-      @highlight = false
-      str.chars.map{|x| x == "\000" ? "^" : " "}.join.rstrip
-    end
-
-    def alt_inspect(query, &block)
-      class << query
-        attr_accessor :str_block
-        def inspect; real_inspect({:str => @str_block.call(self)}); end
-      end
-      query.str_block = block
-      query
-    end
-  end
-  module BT; extend BT_Mixin; end
-end

data/lib/data_collectors.rb

@@ -1,35 +0,0 @@
-# Copyright 2010-2012 RethinkDB, all rights reserved.
-module RethinkDB
-  # Data collectors are ways of aggregating data (for use with
-  # Sequence#groupby).  You can define your own; all they are is a hash
-  # containing a <b>+mapping+</b> to be applied to row, a
-  # <b>+base+</b>/<b>+reduction+</b> to reduce over the mappings, and an
-  # optional <b>+finalizer+</b> to call on the output of the reduction.  You can
-  # expand the builtin data collectors below for examples.
-  #
-  # All of the builtin collectors can also be accessed using the <b>+r+</b>
-  # shortcut (like <b>+r.sum+</b>).
-  module Data_Collectors
-    # Count the number of rows in each group.
-    def self.count
-      { :mapping => lambda{|row| 1},
-        :base => 0,
-        :reduction => lambda{|acc, val| acc + val} }
-    end
-
-    # Sum a particular attribute of the rows in each group.
-    def self.sum(attr)
-      { :mapping => lambda{|row| row[attr]},
-        :base => 0,
-        :reduction => lambda{|acc, val| acc + val} }
-    end
-
-    # Average a particular attribute of the rows in each group.
-    def self.avg(attr)
-      { :mapping => lambda{|row| [row[attr], 1]},
-        :base => [0, 0],
-        :reduction => lambda{|acc, val| [acc[0] + val[0], acc[1] + val[1]]},
-        :finalizer => lambda{|res| res[0] / res[1]} }
-    end
-  end
-end

data/lib/jsons.rb

@@ -1,140 +0,0 @@
-# Copyright 2010-2012 RethinkDB, all rights reserved.
-module RethinkDB
-  # A query returning a JSON expression.  Most of the functions that you
-  # can run on a JSON object are found in RethinkDB::RQL and accessed
-  # with the <b>+r+</b> shortcut.  For convenience, may of the
-  # functions in Rethinkdb::RQL can be run as if they were instance
-  # methods of JSON_Expression.  For example, the following are
-  # equivalent:
-  #   r.add(1, 2)
-  #   r(1).add(2)
-  #   r(3)
-  #
-  # Running a JSON_Expression query will return a literal Ruby
-  # representation of the resulting JSON, rather than a stream or a
-  # string.  For example, the following are equivalent:
-  #   r.add(1,2).run
-  #   3
-  # As are:
-  #   r({:a => 1, :b => 2}).pick(:a).run
-  #   {'a' => 1}
-  # (Note that the symbol keys were coerced into string keys in the
-  # object.  JSON doesn't distinguish between symbols and strings.)
-  class JSON_Expression
-    # If <b>+ind+</b> is a symbol or a string, gets the corresponding
-    # attribute of an object.  For example, the following are equivalent:
-    #   r({:id => 1})[:id]
-    #   r({:id => 1})['id']
-    #   r(1)
-    # Otherwise, if <b>+ind+</b> is a number or a range, invokes RethinkDB::Sequence#[]
-    def [](ind)
-      if ind.class == Symbol || ind.class == String
-        BT.alt_inspect(JSON_Expression.new [:call, [:getattr, ind], [self]]) {
-          "#{self.inspect}[#{ind.inspect}]"
-        }
-      else
-        super
-      end
-    end
-
-    # Append a single element to an array.  The following are equivalent:
-    #   r([1,2,3,4])
-    #   r([1,2,3]).append(4)
-    def append(el)
-      JSON_Expression.new [:call, [:arrayappend], [self, S.r(el)]]
-    end
-
-    # Get an attribute of a JSON object (the same as
-    # JSON_Expression#[]).  The following are equivalent.
-    #   r({:id => 1}).getattr(:id)
-    #   r({:id => 1})[:id]
-    #   r(1)
-    def getattr(attrname)
-      JSON_Expression.new [:call, [:getattr, attrname], [self]]
-    end
-
-    # Check whether a JSON object has all of the particular attributes.  The
-    # following are equivalent:
-    #   r({:id => 1, :val => 2}).contains(:id, :val)
-    #   r(true)
-    def contains(*attrnames)
-      if attrnames.length == 1
-        JSON_Expression.new [:call, [:contains, attrnames[0]], [self]]
-      else
-        self.contains(attrnames[0]) & self.contains(*attrnames[1..-1])
-      end
-    end
-
-    # Construct a JSON object that has a subset of the attributes of
-    # another JSON object by specifying which to keep.  The following are equivalent:
-    #   r({:a => 1, :b => 2, :c => 3}).pick(:a, :c)
-    #   r({:a => 1, :c => 3})
-    def pick(*attrnames)
-      JSON_Expression.new [:call, [:pick, *attrnames], [self]]
-    end
-
-    # Construct a JSON object that has a subset of the attributes of
-    # another JSON object by specifying which to drop.  The following are equivalent:
-    #   r({:a => 1, :b => 2, :c => 3}).without(:a, :c)
-    #   r({:b => 2})
-    def unpick(*attrnames)
-      JSON_Expression.new [:call, [:unpick, *attrnames], [self]]
-    end
-
-    # Convert from an array to a stream.  While most sequence functions are polymorphic
-    # and handle both arrays and streams, when arrays or streams need to be
-    # combined (e.g. via <b>+union+</b>) you need to explicitly convert between
-    # the types.  This is mostly for safety, but also because which type you're
-    # working with affects error handling.  The following are equivalent:
-    #   r([1,2,3]).arraytostream
-    #   r([1,2,3]).to_stream
-    def array_to_stream(); Stream_Expression.new [:call, [:array_to_stream], [self]]; end
-
-    # Prefix numeric -.  The following are equivalent:
-    #   -r(1)
-    #   r(-1)
-    def -@; JSON_Expression.new [:call, [:subtract], [self]]; end
-    # Prefix numeric +.  The following are equivalent:
-    #   +r(-1)
-    #   r(-1)
-    def +@; JSON_Expression.new [:call, [:add], [self]]; end
-  end
-
-  # A query representing a variable.  Produced by e.g. RQL::letvar.  This
-  # is its own class because it needs to behave correctly when spliced
-  # into a string (see RQL::js).
-  class Var_Expression < JSON_Expression
-    # Convert from an RQL query representing a variable to the name of that
-    # variable.  Used e.g. in constructing javascript functions.
-    def to_s
-      if @body.class == Array and @body[0] == :var
-      then @body[1]
-      else raise TypeError, 'Can only call to_s on RQL_Queries representing variables.'
-      end
-    end
-  end
-
-  # Like Multi_Row_Selection, but for a single row.  E.g.:
-  #   table.get(0)
-  # yields a Single_Row_Selection
-  class Single_Row_Selection < JSON_Expression
-    # Analagous to Multi_Row_Selection#update
-    def update(variant=nil)
-      S.with_var {|vname,v|
-        Write_Query.new [:pointupdate, *(@body[1..-1] + [[vname, S.r(yield(v))]])]
-      }.apply_variant(variant)
-    end
-
-    # Analagous to Multi_Row_Selection#mutate
-    def replace(variant=nil)
-      S.with_var {|vname,v|
-        Write_Query.new [:pointreplace, *(@body[1..-1] + [[vname, S.r(yield(v))]])]
-      }.apply_variant(variant)
-    end
-
-    # Analagous to Multi_Row_Selection#delete
-    def delete
-      Write_Query.new [:pointdelete, *(@body[1..-1])]
-    end
-  end
-end

data/lib/protob_compiler.rb

@@ -1,137 +0,0 @@
-# Copyright 2010-2012 RethinkDB, all rights reserved.
-module RethinkDB
-  module RQL_Protob_Mixin
-    include P_Mixin
-    @@token = 0 # We need a new token every time we compile a query
-    @@backtrace = []
-
-    # Right now the only special case is :compare, but in general we might have
-    # terms that don't follow the conventions and we need a place to store that.
-    def handle_special_cases(message, query_type, query_args)
-      #PP.pp ["special_case", message, query_type, query_args]
-      case query_type
-      when :compare then
-        message.comparison = enum_type(Builtin::Comparison, *query_args)
-        throw :unknown_comparator_error if not message.comparison
-        return true
-      else return false
-      end
-    end
-
-################################################################################
-    # I apologize for the code after this.  I was originally doing something
-    # clever to generate the S-expressions, so they don't always match the
-    # protobufs perfectly, and the complexity necessary to handle that got
-    # pushed down into protobuf compilation.  Later the cleverness went away,
-    # but I left the code below intact rather than refactoring for two reasons:
-    #   1) It's fragile and took about a day to get right, so refactoring it
-    #      probably isn't free.
-    #   2) We are probably going to have to change protobuf implementations for
-    #      speed reasons anyway, at which point this will have to be rewritten,
-    #      and rewriting it twice doesn't make sense
-################################################################################
-
-    # Compile an RQL query into a protobuf.
-    def comp(message_class, args, repeating=false)
-      # H4x to make the backtraces print right until we fix the protobuf.
-      message_class = S.rewrite(message_class);
-      #PP.pp(["A", message_class, args, repeating]) #DEBUG
-
-      # Handle special cases of arguments:
-      #   * When we're compiling a repeating term, in which case we want to
-      #     compile the elements of [args] rather than [args] itself.
-      #   * Objects, which correspond to optional argument specifications.
-      #   * Empty arguments
-      return args.map {|arg| comp(message_class, arg)} if repeating
-      args = args[0] if args.class == Array and args[0].class == Hash
-      raise TypeError,"Can't build #{message_class} from #{args.inspect}." if args == []
-
-      # Handle terminal parts of the protobuf, where we have to actually pack values.
-      if message_class.kind_of? Symbol
-        # It's easier for the user if we allow both atoms and 1-element lists
-        args = [args] if args.class != Array
-        if args.length != 1
-        then raise TypeError,"Can't build #{message_class} from #{args.inspect}." end
-        # Coercing symbols into strings makes our attribute notation more consistent
-        args[0] = args[0].to_s if args[0].class == Symbol
-        return args[0]
-      end
-
-      # Handle nonterminal parts of the protobuf, where we have to descend
-      message = message_class.new
-      if (message_type_class = C.class_types[message_class])
-        query_type = S.rewrite(args[0]) # Our first argument is the type of our variant.
-        message.type = enum_type(message_type_class, query_type)
-        raise TypeError,"No type '#{query_type}' for '#{message_class}'."if !message.type
-
-        if args.length == 1 # Our variant takes no arguments of its own.
-          return message
-        else # Compile our variant's arguments.
-          query_args = args[1..-1]
-          query_args = [query_args] if C.trampolines.include? query_type
-          return message if handle_special_cases(message, query_type, query_args)
-
-          # The general, non-special case.
-          query_type = C.query_rewrites[query_type] || query_type
-          field_metadata = message_class.fields.select{|x,y| y.name==query_type}.to_a[0]
-          if not field_metadata
-          then raise ArgumentError,"No field '#{query_type}' in '#{message_class}'." end
-          field = field_metadata[1]
-          message_set(message, query_type,
-                      comp(field.type, query_args,field.rule==:repeated))
-        end
-      # Handle cases where we aren't constructing a toplevel variant type.
-      elsif args.class == Array
-        # Handle the case where we're constructinga the fields in order.
-        args = args.map{|x| x == nil ? RQL.expr(x) : x}
-        fields = message.fields.sort_by {|kv| kv[0]}
-        fields.zip(args).each {|_params|;field = _params[0][1];arg = _params[1]
-          if arg == S.skip
-            if field.rule != :optional
-              raise RuntimeError, "Cannot skip non-optional rule."
-            end
-          else
-            message_set(message, field.name,
-                        comp(field.type, arg, field.rule==:repeated)) if arg != nil
-          end
-        }
-      else
-        # Handle the case where the user provided neither an Array nor a Hash,
-        # in which case they probably provided an Atom that we should treat as a
-        # single argument (allowing this makes the interface cleaner).
-        message = comp(message_class, [args], repeating)
-      end
-      return message
-    rescue => e # Add our own, semantic backtrace to exceptions
-      new_msg = repeating ? e.message :
-        e.message + "\n...when compiling #{message_class} with:\n#{args.pretty_inspect}"
-      raise e.class, new_msg
-    end
-
-    def handle_special_query_cases(sexp)
-      if C.nonatomic_variants.include?(sexp[0])
-        sexp[0] = sexp[0].to_s.split('_')[0].to_sym
-        res = query(sexp)
-        res.write_query.atomic = false
-        return res
-      end
-      return nil
-    end
-
-    # Construct a protobuf query from an RQL query by inferring the query type.
-    def query(sexp)
-      raise TypeError, "Cannot build query from #{sexp.inspect}" if sexp.class != Array
-      if (m = handle_special_query_cases(sexp))
-      then q = m
-      elsif enum_type(WriteQuery::WriteQueryType, S.rewrite(sexp[0]))
-      then q = comp(Query, [:write, *sexp])
-      elsif enum_type(MetaQuery::MetaQueryType, sexp[0])
-      then q = comp(Query, [:meta, *sexp])
-      else q = comp(Query, [:read, sexp])
-      end
-      q.token = (@@token += 1)
-      return q
-    end
-  end
-  module RQL_Protob; extend RQL_Protob_Mixin; end
-end