bud 0.0.5 → 0.0.6

data/lib/bud/bud_meta.rb

@@ -148,8 +148,8 @@ class BudMeta #:nodoc: all
 
       # Check that LHS references a named collection
       return n if lhs.nil? or lhs.sexp_type != :call
-      lhs_name = lhs[2]
-      unless @bud_instance.tables.has_key? lhs_name.to_sym
+      lhs_name = lhs[2].to_sym
+      unless @bud_instance.tables.has_key? lhs_name
         return [n, "Table does not exist: '#{lhs_name}'"]
       end
 
@@ -182,11 +182,11 @@ class BudMeta #:nodoc: all
     strat.tick_internal
 
     # Copy computed data back into Bud runtime
-    strat.stratum.each {|s| @bud_instance.t_stratum << s}
-    @bud_instance.stratum_collection_map = strat.stratum.inject({}) do |memo, t|
-      memo[t[1]] ||= []
-      memo[t[1]] << t[0]
-      memo
+    @bud_instance.stratum_collection_map = []
+    strat.stratum.each do |s|
+      @bud_instance.t_stratum << s
+      @bud_instance.stratum_collection_map[s[1]] ||= []
+      @bud_instance.stratum_collection_map[s[1]] << s[0].to_sym
     end
     strat.depends_tc.each {|d| @bud_instance.t_depends_tc << d}
     strat.cycle.each {|c| @bud_instance.t_cycle << c}

data/lib/bud/bust/bust.rb

@@ -19,7 +19,7 @@ module Bust
     # copied from peter's code; this should probably be in the Bud runtime or in
     # some meta module
     @tables.each do |t|
-      t_table_schema << [t[0], t[1].schema.clone]
+      t_table_schema << [t[0], t[1].cols.clone]
       t_table_info << [t[0], t[1].class.to_s]
     end
 
@@ -77,7 +77,7 @@ module Bust
             # instantiate a new tuple
             tuple_to_insert = []
             @body.each do |k, v|
-              index = (eval "@bud." + table_name).schema.find_index(k.to_sym)
+              index = (eval "@bud." + table_name).cols.find_index(k.to_sym)
               for i in (tuple_to_insert.size..index)
                 tuple_to_insert << nil
               end

data/lib/bud/collections.rb

@@ -14,8 +14,10 @@ module Bud
   class BudCollection
     include Enumerable
 
-    attr_accessor :bud_instance, :locspec_idx # :nodoc: all
-    attr_reader :schema, :tabname # :nodoc: all
+    # This needs to be an accessor to allow REBL to update it after cloning a
+    # Bud instance.
+    attr_accessor :bud_instance # :nodoc: all
+    attr_reader :cols, :key_cols, :tabname # :nodoc: all
     attr_reader :storage, :delta, :new_delta, :pending # :nodoc: all
 
     def initialize(name, bud_instance, given_schema=nil, defer_schema=false) # :nodoc: all
@@ -35,16 +37,26 @@ module Bud
     private
     def init_schema(given_schema)
       given_schema ||= {[:key]=>[:val]}
+
+      # Check that no location specifiers appear in the schema. In the case of
+      # channels, the location specifier has already been stripped from the
+      # user-specified schema.
+      given_schema.each do |s|
+        if s.to_s.start_with? "@"
+          raise BudError, "illegal use of location specifier (@) in column #{s} of non-channel collection #{tabname}"
+        end
+      end
+
       @given_schema = given_schema
-      @schema, @key_cols = parse_schema(given_schema)
-      @key_colnums = key_cols.map {|k| schema.index(k)}
+      @cols, @key_cols = parse_schema(given_schema)
+      @key_colnums = key_cols.map {|k| @cols.index(k)}
       setup_accessors
     end
 
     # The user-specified schema might come in two forms: a hash of Array =>
-    # Array (key_cols => remaining columns), or simply an Array of columns (if no
-    # key_cols were specified). Return a pair: [list of columns in entire tuple,
-    # list of key columns]
+    # Array (key_cols => remaining columns), or simply an Array of columns (if
+    # no key_cols were specified). Return a pair: [list of (all) columns, list
+    # of key columns]
     private
     def parse_schema(given_schema)
       if given_schema.respond_to? :keys
@@ -56,17 +68,17 @@ module Bud
         val_cols = []
       end
 
-      schema = key_cols + val_cols
-      schema.each do |s|
-        if s.class != Symbol
-          raise BudError, "Invalid schema element \"#{s}\", type \"#{s.class}\""
+      cols = key_cols + val_cols
+      cols.each do |c|
+        if c.class != Symbol
+          raise BudError, "invalid schema element \"#{c}\", type \"#{c.class}\""
         end
       end
-      if schema.uniq.length < schema.length
+      if cols.uniq.length < cols.length
         raise BudError, "schema for #{tabname} contains duplicate names"
       end
 
-      return [schema, key_cols]
+      return [cols, key_cols]
     end
 
     public
@@ -74,16 +86,18 @@ module Bud
       self.class.new(tabname, bud_instance, @given_schema)
     end
 
-    # subset of the schema (i.e. an array of attribute names) that forms the key
+    # produces the schema in a format that is useful as the schema specification for another table
     public
-    def key_cols
-      @key_cols
+    def schema
+      return nil if @cols.nil?
+      return key_cols if val_cols.empty?
+      return { key_cols => val_cols }
     end
 
-    # subset of the schema (i.e. an array of attribute names) that is not in the key
+    # the columns of the collection's schema that are not part of the key
     public
     def val_cols # :nodoc: all
-      schema - key_cols
+      @cols - @key_cols
     end
 
     # define methods to turn 'table.col' into a [table,col] pair
@@ -91,7 +105,7 @@ module Bud
     #    j = join link, path, {link.to => path.from}
     private
     def setup_accessors
-      s = @schema
+      s = @cols
       s.each do |colname|
         reserved = eval "defined?(#{colname})"
         unless (reserved.nil? or
@@ -129,7 +143,7 @@ module Bud
     # generate a tuple with the schema of this collection and nil values in each attribute
     public
     def null_tuple
-      tuple_accessors(Array.new(@schema.length))
+      tuple_accessors(Array.new(@cols.length))
     end
 
     # project the collection to its key attributes
@@ -141,13 +155,13 @@ module Bud
     # project the collection to its non-key attributes
     public
     def values
-      self.map{|t| (self.key_cols.length..self.schema.length-1).map{|i| t[i]}}
+      self.map{|t| (self.key_cols.length..self.cols.length-1).map{|i| t[i]}}
     end
 
     # map each item in the collection into a string, suitable for placement in stdio
     public
     def inspected
-      self.map{|t| [t.inspect]}
+      [["#{@tabname}: [#{self.map{|t| "\n  (#{t.map{|v| v.inspect}.join ", "})"}}]"]]
     end
 
     # akin to map, but modified for efficiency in Bloom statements
@@ -184,7 +198,7 @@ module Bud
       bud_instance.metrics[:collections][{:addr=>addr, :tabname=>tabname, :strat_num=>strat_num, :rule_num=>rule_num}] ||= 0
       bud_instance.metrics[:collections][{:addr=>addr, :tabname=>tabname, :strat_num=>strat_num, :rule_num=>rule_num}] += 1
     end
-    
+
     private
     def each_from(bufs, &block) # :nodoc: all
       bufs.each do |b|
@@ -269,7 +283,7 @@ module Bud
     private
     def raise_pk_error(new_guy, old)
       keycols = @key_colnums.map{|i| old[i]}
-      raise KeyConstraintError, "Key conflict inserting #{new_guy.inspect} into \"#{tabname}\": existing tuple #{old.inspect}, key_cols = #{keycols.inspect}"
+      raise KeyConstraintError, "key conflict inserting #{new_guy.inspect} into \"#{tabname}\": existing tuple #{old.inspect}, key_cols = #{keycols.inspect}"
     end
 
     private
@@ -281,15 +295,15 @@ module Bud
         raise BudTypeError, "String value used as a fact inserted into \"#{tabname}\": #{o.inspect}"
       end
 
-      if o.length < schema.length then
+      if o.length < cols.length then
         # if this tuple has too few fields, pad with nil's
         old = o.clone
-        (o.length..schema.length-1).each{|i| o << nil}
+        (o.length..cols.length-1).each{|i| o << nil}
         # puts "in #{@tabname}, converted #{old.inspect} to #{o.inspect}"
-      elsif o.length > schema.length then
+      elsif o.length > cols.length then
         # if this tuple has more fields than usual, bundle up the
         # extras into an array
-        o = (0..(schema.length - 1)).map{|c| o[c]} << (schema.length..(o.length - 1)).map{|c| o[c]}
+        o = (0..(cols.length - 1)).map{|c| o[c]} << (cols.length..(o.length - 1)).map{|c| o[c]}
       end
       return o
     end
@@ -322,18 +336,18 @@ module Bud
     private
     def check_enumerable(o)
       unless o.nil? or o.class < Enumerable
-        raise BudTypeError, "Collection #{tabname} expected Enumerable value, not #{o.inspect} (class = #{o.class})"
+        raise BudTypeError, "collection #{tabname} expected Enumerable value, not #{o.inspect} (class = #{o.class})"
       end
     end
 
     # Assign self a schema, by hook or by crook.  If +o+ is schemaless *and*
-    # empty, will leave @schema as is.
+    # empty, will leave @cols as is.
     private
     def establish_schema(o)
       # use o's schema if available
       deduce_schema(o)
       # else use arity of first non-nil tuple of o
-      if @schema.nil?
+      if @cols.nil?
         o.each do |t|
           next if t.nil?
           fit_schema(t.size)
@@ -345,11 +359,11 @@ module Bud
     # Copy over the schema from +o+ if available
     private
     def deduce_schema(o)
-      if @schema.nil? and o.class <= Bud::BudCollection and not o.schema.nil?
+      if @cols.nil? and o.class <= Bud::BudCollection and not o.cols.nil?
         # must have been initialized with defer_schema==true.  take schema from rhs
-        init_schema(o.schema)
+        init_schema(o.cols)
       end
-      # if nothing available, leave @schema unchanged
+      # if nothing available, leave @cols unchanged
     end
 
     # manufacture schema of the form [:c0, :c1, ...] with width = +arity+
@@ -377,9 +391,9 @@ module Bud
     public
     def merge(o, buf=@new_delta) # :nodoc: all
       unless o.nil?
-        o = o.uniq.compact if o.respond_to?(:uniq)
+        o = o.uniq if o.respond_to?(:uniq)
         check_enumerable(o)
-        establish_schema(o) if @schema.nil?
+        establish_schema(o) if @cols.nil?
 
         # it's a pity that we are massaging the tuples that already exist in the head
         o.each do |t|
@@ -402,7 +416,7 @@ module Bud
     public
     def pending_merge(o) # :nodoc: all
       check_enumerable(o)
-      establish_schema(o) if @schema.nil?
+      establish_schema(o) if @cols.nil?
 
       o.each {|i| do_insert(i, @pending)}
       return self
@@ -412,7 +426,7 @@ module Bud
     superator "<+" do |o|
       pending_merge o
     end
-    
+
     public
     superator "<+-" do |o|
       self <+ o
@@ -422,12 +436,12 @@ module Bud
         end
       end
     end
-    
-    public 
+
+    public
     superator "<-+" do |o|
       self <+- o
     end
-    
+
     # Called at the end of each timestep: prepare the collection for the next
     # timestep.
     public
@@ -494,11 +508,11 @@ module Bud
           memo[pkey_cols][:agg], argflag = \
              agg.send(:trans, memo[pkey_cols][:agg], p[colnum])
           if argflag == :keep or agg.send(:tie, memo[pkey_cols][:agg], p[colnum])
-            memo[pkey_cols][:tups] << p 
+            memo[pkey_cols][:tups] << p
           elsif argflag == :replace
             memo[pkey_cols][:tups] = [p]
           elsif argflag.class <= Array and argflag[0] == :delete
-            memo[pkey_cols][:tups] -= argflag[1..-1] 
+            memo[pkey_cols][:tups] -= argflag[1..-1]
           end
         end
         memo
@@ -510,7 +524,7 @@ module Bud
       tups.each do |k,v|
         finalaggs[k] = agg.send(:final, v[:agg])
       end
-      
+
       # and winnow the tups to match
       finalaggs.each do |k,v|
         tups[k][:tups].each do |t|
@@ -566,14 +580,12 @@ module Bud
     def *(collection)
       join([self, collection])
     end
-    
+
     # AntiJoin
     public
-    def notin(coll,*preds, &blk)
-      @origpreds = preds
-      @schema = schema
-      return BudJoin.new([self,coll], @bud_instance).anti(*preds,&blk)
-    end    
+    def notin(coll, *preds, &blk)
+      return BudJoin.new([self, coll], @bud_instance).anti(*preds, &blk)
+    end
 
     # SQL-style grouping.  first argument is an array of attributes to group by.
     # Followed by a variable-length list of aggregates over attributes (e.g. +min(:x)+)
@@ -587,7 +599,7 @@ module Bud
         elsif k[2] and k[2].class == Symbol
           k[2]
         else
-          raise Bud::CompileError, "Invalid grouping key"
+          raise Bud::CompileError, "invalid grouping key"
         end
       end
       aggcolsdups = aggpairs.map{|ap| ap[0].class.name.split("::").last}
@@ -671,16 +683,16 @@ module Bud
       given_schema = Marshal.load(Marshal.dump(given_schema))
 
       unless @is_loopback
-        the_schema, the_key_cols = parse_schema(given_schema)
-        spec_count = the_schema.count {|s| s.to_s.start_with? "@"}
+        the_cols, the_key_cols = parse_schema(given_schema)
+        spec_count = the_cols.count {|c| c.to_s.start_with? "@"}
         if spec_count == 0
-          raise BudError, "Missing location specifier for channel '#{name}'"
+          raise BudError, "missing location specifier for channel '#{name}'"
         end
         if spec_count > 1
-          raise BudError, "Multiple location specifiers for channel '#{name}'"
+          raise BudError, "multiple location specifiers for channel '#{name}'"
         end
 
-        the_val_cols = the_schema - the_key_cols
+        the_val_cols = the_cols - the_key_cols
         @locspec_idx = remove_at_sign!(the_key_cols)
         if @locspec_idx.nil?
           val_idx = remove_at_sign!(the_val_cols)
@@ -713,7 +725,7 @@ module Bud
         lsplit[1] = lsplit[1].to_i
         return lsplit
       rescue Exception => e
-        raise BudError, "Illegal location specifier in tuple #{t.inspect} for channel \"#{tabname}\": #{e.to_s}"
+        raise BudError, "illegal location specifier in tuple #{t.inspect} for channel \"#{tabname}\": #{e.to_s}"
       end
     end
 
@@ -751,11 +763,11 @@ module Bud
     def payloads
       return self.pro if @is_loopback
 
-      if schema.size > 2
+      if cols.size > 2
         # bundle up each tuple's non-locspec fields into an array
         retval = case @locspec_idx
           when 0 then self.pro{|t| t[1..(t.size-1)]}
-          when (schema.size - 1) then self.pro{|t| t[0..(t.size-2)]}
+          when (cols.size - 1) then self.pro{|t| t[0..(t.size-2)]}
           else self.pro{|t| t[0..(@locspec_idx-1)] + t[@locspec_idx+1..(t.size-1)]}
         end
       else
@@ -770,13 +782,13 @@ module Bud
     end
 
     superator "<+" do |o|
-      raise BudError, "Illegal use of <+ with channel '#{@tabname}' on left"
+      raise BudError, "illegal use of <+ with channel '#{@tabname}' on left"
     end
 
     undef merge
 
     def <=(o)
-      raise BudError, "Illegal use of <= with channel '#{@tabname}' on left"
+      raise BudError, "illegal use of <= with channel '#{@tabname}' on left"
     end
   end
 
@@ -837,7 +849,7 @@ module Bud
 
     public
     def <=(o) #:nodoc: all
-      raise BudError, "Illegal use of <= with terminal '#{@tabname}' on left"
+      raise BudError, "illegal use of <= with terminal '#{@tabname}' on left"
     end
 
     superator "<~" do |o|
@@ -855,19 +867,19 @@ module Bud
 
   class BudPeriodic < BudCollection # :nodoc: all
     def <=(o)
-      raise BudError, "Illegal use of <= with periodic '#{tabname}' on left"
+      raise BudError, "illegal use of <= with periodic '#{tabname}' on left"
     end
 
     superator "<~" do |o|
-      raise BudError, "Illegal use of <~ with periodic '#{tabname}' on left"
+      raise BudError, "illegal use of <~ with periodic '#{tabname}' on left"
     end
 
     superator "<-" do |o|
-      raise BudError, "Illegal use of <- with periodic '#{tabname}' on left"
+      raise BudError, "illegal use of <- with periodic '#{tabname}' on left"
     end
 
     superator "<+" do |o|
-      raise BudError, "Illegal use of <+ with periodic '#{tabname}' on left"
+      raise BudError, "illegal use of <+ with periodic '#{tabname}' on left"
     end
   end
 
@@ -907,11 +919,11 @@ module Bud
 
   class BudReadOnly < BudScratch # :nodoc: all
     superator "<+" do |o|
-      raise CompileError, "Illegal use of <+ with read-only collection '#{@tabname}' on left"
+      raise CompileError, "illegal use of <+ with read-only collection '#{@tabname}' on left"
     end
     public
     def merge(o)  #:nodoc: all
-      raise CompileError, "Illegal use of <= with read-only collection '#{@tabname}' on left"
+      raise CompileError, "illegal use of <= with read-only collection '#{@tabname}' on left"
     end
   end
 

data/lib/bud/deploy/ec2deploy.rb

@@ -160,7 +160,7 @@ module EC2Deploy
               # Update the Bud gem
               channel = session.open_channel do |ch|
                 channel.request_pty do |_, success|
-                  raise "Couldn't open a PTY on #{t.node}" if !success
+                  raise "couldn't open a PTY on #{t.node}" if !success
                 end
                 channel.exec("sudo gem update --no-ri --no-rdoc bud")
               end