bud 0.0.5 → 0.0.6

data/lib/bud/graphs.rb

@@ -5,7 +5,7 @@ require 'graphviz'
 class GraphGen #:nodoc: all
   attr_reader :nodes
 
-  def initialize(tableinfo, cycle, name, budtime, collapse=false, cardinalities={})
+  def initialize(tableinfo, builtin_tables, cycle, name, budtime, collapse=false, cardinalities={})
     @graph = GraphViz.new(:G, :type => :digraph, :label => "")
     @graph.node[:fontname] = "Times-Roman"
     @graph.node[:fontsize] = 18
@@ -15,9 +15,9 @@ class GraphGen #:nodoc: all
     @name = name
     @collapse = collapse
     @budtime = budtime
-    @internals = {'localtick' => 1, 'stdio' => 1}
+    @builtin_tables = builtin_tables
 
-    # map: table -> type
+    # map: table name -> type
     @tabinf = {}
     tableinfo.each do |ti|
       @tabinf[ti[0].to_s] = ti[1]
@@ -75,8 +75,7 @@ class GraphGen #:nodoc: all
       head = d[1]
       body = d[3]
 
-      # hack attack
-      if @internals[head] or @internals[body]
+      if @builtin_tables.has_key?(head.to_sym) or @builtin_tables.has_key?(body.to_sym)
         next
       end
 
@@ -182,11 +181,11 @@ class GraphGen #:nodoc: all
     @nodes["T"].penwidth = 3
 
     @tabinf.each_pair do |k, v|
-      unless @nodes[name_of(k.to_s)] or k.to_s =~ /_tbl/ or @internals[k.to_s] or (k.to_s =~ /^t_/ and @budtime != 0)
-        addonce(k.to_s, false)
+      unless @nodes[name_of(k)] or @builtin_tables[k.to_sym]
+        addonce(k, false)
       end
       if v == "Bud::BudPeriodic"
-        addedge("S", k.to_s, false, false, false)
+        addedge("S", k, false, false, false)
       end
     end
 
@@ -263,7 +262,7 @@ class SpaceTime
 
     squeues = {}
     queues.each_pair do |k, v|
-      squeues[k] = v.sort{|a, b| a <=> b}
+      squeues[k] = v.sort{|a, b| a.to_i <=> b.to_i}
     end
 
     # create the nodes and the timeline edges first.
@@ -271,8 +270,7 @@ class SpaceTime
       v.each_with_index do |item, i|
         label = "#{k}-#{item}"
         if @links
-          url = "DBM_#{k}_/tm_#{item}.svg"
-          #puts "URL is #{url}"
+          url = "DBM_#{k}/tm_#{item}.svg"
         end
         snd = @subs[k].add_node(label, {:label => item.to_s, :width => 0.1, :height => 0.1, :fontsize => 6, :pos => [1, i], :group => k, :URL => url})
 

data/lib/bud/joins.rb

@@ -30,11 +30,11 @@ module Bud
         memo[r.tabname] += 1
         memo
       end
-      counts.each do |name, cnt| 
+      counts.each do |name, cnt|
         raise Bud::CompileError, "#{cnt} instances of #{name} in rule; only one self-join currently allowed per rule" if cnt > 2
         @selfjoins << name if cnt == 2
       end
-      
+
 
       # recurse to form a tree of binary BudJoins
       @rels = [rellist[0]]
@@ -75,7 +75,7 @@ module Bud
       preds = []
       rels.each do |r|
         rels.each do |s|
-          matches = r.schema & s.schema
+          matches = r.cols & s.cols
           matches.each do |c|
             preds << [bud_instance.send(r.tabname).send(c), bud_instance.send(s.tabname).send(c)] unless r.tabname.to_s >= s.tabname.to_s
           end
@@ -90,7 +90,7 @@ module Bud
     public
     def flatten(*preds)
       setup_preds(preds)
-      flat_schema = @rels.map{|r| r.schema}.flatten(1)
+      flat_schema = @rels.map{|r| r.cols}.flatten(1)
       dupfree_schema = []
       # while loop here (inefficiently) ensures no collisions
       while dupfree_schema == [] or dupfree_schema.uniq.length < dupfree_schema.length
@@ -121,7 +121,8 @@ module Bud
     # map each (nested) item in the collection into a string, suitable for placement in stdio
     def inspected
       raise BudError, "join left unconverted to binary" if @rels.length > 2
-      self.map{|r1, r2| ["\[ #{r1.inspect} #{r2.inspect} \]"]}
+      tabnames = @origrels.map {|r| r.tabname.to_s}.join " * "
+      [["(#{tabnames}): [#{self.map{|r1, r2| "\n  (#{r1.inspect}, #{r2.inspect})"}}]"]]
     end
 
     public
@@ -168,7 +169,7 @@ module Bud
     end
 
     alias combos pairs
-    
+
     # the natural join: given a * expression over n collections, form all
     # combinations of items that have the same values in matching fields
     public
@@ -209,23 +210,32 @@ module Bud
       self.extend(Bud::BudOuterJoin)
       blk.nil? ? self : map(&blk)
     end
-    
+
     # AntiJoin
     # note: unlike other join methods (e.g. lefts) all we do with the return value
     # of block is check whether it's nil.  Putting "projection" logic in the block
     # has no effect on the output.
     public
     def anti(*preds, &blk)
+      return [] unless @bud_instance.stratum_first_iter
       @origpreds = preds
       # no projection involved here, so we can propagate the schema
-      @schema = rels[0].schema
+      @cols = @rels[0].cols
       setup_preds(preds)
       setup_state if self.class <= Bud::BudJoin
-      if @bud_instance.stratum_first_iter
-        @matches = map { |r, s| (blk.nil?) ? r : blk.call(r,s) }.compact
-        @rels[0].map {|r| (@matches.include? r) ? nil : r}.compact
+      if blk.nil?
+        @matches = map { |r, s| r }
       else
-        []
+        @matches = map { |r, s| r unless blk.call(r, s).nil? }.compact
+      end
+      # XXX: @matches is an Array, which makes include? O(n)
+      @rels[0].map {|r| (@matches.include? r) ? nil : r}
+    end
+
+    private
+    def check_join_pred(pred, join_rels)
+      unless join_rels.include? pred[0]
+        raise Bud::CompileError, "illegal predicate: collection #{pred[0]} is not being joined"
       end
     end
 
@@ -239,21 +249,20 @@ module Bud
       unless @rels[1].class <= Bud::BudJoin
         tabnames = @rels.map{ |r| r.tabname }
         allpreds.each do |p|
-          unless tabnames.include? p[0][0] and tabnames.include? p[1][0]
-            raise Bud::CompileError, "illegal predicate: collection #{} is not being joined"
-          end
+          check_join_pred(p[0], tabnames)
+          check_join_pred(p[1], tabnames)
         end
       end
       @hashpreds = allpreds.reject {|p| p[0][0] != @rels[0].tabname}
       @localpreds = @hashpreds
-      
+
       # only allow preds on the same table name if they're on a self-joined table
-      @localpreds.each do |p| 
+      @localpreds.each do |p|
         if p[0][0] == p[1][0] and not @selfjoins.include? p[0][0]
-          raise Bud::CompileError, "single-table predicate on #{p[0][0]} disallowed in joins" 
+          raise Bud::CompileError, "single-table predicate on #{p[0][0]} disallowed in joins"
         end
       end
-      
+
       @localpreds += allpreds.map do |p|
         p if p[0][0] == p[1][0] and (p[0][0] == @rels[0].tabname or p[0][0] == @rels[1].tabname)
       end.compact
@@ -385,7 +394,7 @@ module Bud
       name, offset = entry[0], entry[1]
 
       # determine which subtuple of the collection contains the table
-      # referenced in entry.  
+      # referenced in entry.
       subtuple = 0
       origrels[1..origrels.length].each_with_index do |t,i|
         if t.tabname == entry[0]

data/lib/bud/monkeypatch.rb

@@ -6,6 +6,12 @@ class Module
     mod, local_name = spec.first
     raise Bud::CompileError unless (mod.class <= Module and local_name.class <= Symbol)
 
+    # Attempting to import a module that has already included the Bud module
+    # results in problems (and is a bad idea anyway), so disallow it.
+    if mod.included_modules.include? Bud
+      raise Bud::CompileError, "cannot import #{mod} because it has already included Bud"
+    end
+
     # To correctly expand qualified references to an imported module, we keep a
     # table with the local bind names of all the modules imported by this
     # module. To handle nested references (a.b.c.d etc.), the import table for
@@ -41,7 +47,7 @@ class Module
       @block_id += 1
     else
       unless block_name.class <= Symbol
-        raise Bud::CompileError, "Bloom block names must be a symbol: #{block_name}"
+        raise Bud::CompileError, "bloom block names must be a symbol: #{block_name}"
       end
     end
 
@@ -53,7 +59,7 @@ class Module
     # Don't allow duplicate named bloom blocks to be defined within a single
     # module; this indicates a likely programmer error.
     if instance_methods(false).include? meth_name
-      raise Bud::CompileError, "Duplicate named bloom block: '#{block_name}' in #{self}"
+      raise Bud::CompileError, "duplicate named bloom block: '#{block_name}' in #{self}"
     end
     define_method(meth_name.to_sym, &block)
   end

data/lib/bud/rebl.rb

@@ -23,32 +23,32 @@ class ReblShell
   @@escape_char = '/'
   @@commands =
     {"tick" => [lambda {|lib,argv| lib.tick([Integer(argv[1]), 1].max)},
-                "tick [x]:\texecutes x (or 1) timesteps"],
+                "tick [x]\texecutes x (or 1) timesteps"],
 
     "run" => [lambda {|lib,_| lib.run},
-              "run:\ttick until quiescence, a breakpoint, or #{@@escape_char}stop"],
+              "run\ttick until quiescence, a breakpoint, or #{@@escape_char}stop"],
 
     "stop" => [lambda {|lib,_| lib.stop},
-               "stop:\tstop ticking"],
+               "stop\tstop ticking"],
 
     "lsrules" => [lambda {|lib,_| lib.rules.sort{|a,b| a[0] <=> b[0]}.each {|k,v| puts "#{k}: "+v}},
-                  "lsrules:\tlist rules"],
+                  "lsrules\tlist rules"],
 
     "rmrule" => [lambda {|lib,argv| lib.del_rule(Integer(argv[1]))},
-                 "rmrule x:\tremove rule number x"],
+                 "rmrule x\tremove rule number x"],
 
     "lscollections" => [lambda {|lib,_| lib.state.sort{|a,b| a[0] <=> b[0]}.each {|k,v| puts "#{k}: "+v}},
-                        "lscollections:\tlist collections"],
+                        "lscollections\tlist collections"],
 
     "dump" => [lambda {|lib,argv| lib.dump(argv[1])},
-               "dump c:\tdump contents of collection c"],
+               "dump c\tdump contents of collection c"],
 
-    "exit" => [lambda {|_,_| do_exit}, "exit:\texit rebl"],
+    "exit" => [lambda {|_,_| do_exit}, "exit\texit rebl"],
 
-    "quit" => [lambda {|_,_| do_exit}, "quit:\texit rebl"],
+    "quit" => [lambda {|_,_| do_exit}, "quit\texit rebl"],
 
     "help" => [lambda {|_,_| pretty_help},
-               "help:\tprint this help message"]}
+               "help\tprint this help message"]}
   @@abbrevs = @@commands.keys.abbrev
   @@exit_message = "Rebellion quashed."
 
@@ -151,7 +151,7 @@ class ReblShell
     cmd_list.each do |c|
       v = @@commands[c]
       puts @@escape_char +
-        v[1].gsub(/\t/, " "*(maxlen + 3 - v[1].split(':')[0].size))
+        v[1].gsub(/\t/, " "*(maxlen + 4 - v[1].split("\t")[0].size))
     end
     puts "\nbreakpoints:"
     puts "a breakpoint is a rule with the 'breakpoint' scratch on the left of "+
@@ -228,8 +228,20 @@ class LibRebl
 
   # Dumps the contents of a table at the current time.
   def dump(c)
-    tups = @rebl_class_inst.instance_eval("#{c}.inspected")
-    puts(tups.empty? ? "(empty)" : tups.sort.join("\n"))
+    if c.nil?
+      puts "Error: dump must be passed a collection name"
+    elsif not @rebl_class_inst.tables.has_key? c.to_sym
+      puts "Error: non-existent collection \"#{c}\""
+    else
+      tups = @rebl_class_inst.tables[c.to_sym].to_a.sort
+      if tups.empty?
+        puts "(empty)"
+      else
+        tups.each do |t|
+          puts t.inspect
+        end
+      end
+    end
   end
 
   # Declares a new collection.
@@ -246,6 +258,10 @@ class LibRebl
   # Deactivates a rule at the current time; any tuples derived by the rule at
   # a previous time are still available.
   def del_rule(rid)
+    unless @rules.has_key? rid
+      puts "No rule with ID #{rid}"
+      return
+    end
     @rules.delete(rid)
     reinstantiate
   end

data/lib/bud/rewrite.rb

@@ -1,5 +1,4 @@
 require 'rubygems'
-require 'ruby2ruby'
 
 class RuleRewriter < Ruby2Ruby # :nodoc: all
   attr_accessor :rule_indx, :rules, :depends
@@ -11,7 +10,8 @@ class RuleRewriter < Ruby2Ruby # :nodoc: all
       :== => 1, :+ => 1, :<= => 1, :- => 1, :< => 1, :> => 1,
       :* => 1, :pairs => 1, :matches => 1, :combos => 1, :flatten => 1,
       :lefts => 1, :rights => 1, :map => 1, :flat_map => 1, :pro => 1,
-      :schema => 1, :keys => 1, :values => 1, :payloads => 1, :~ => 1
+      :schema => 1, :keys => 1, :values => 1, :cols => 1, :key_cols => 1,
+      :val_cols => 1, :payloads => 1, :~ => 1
     }
     @temp_ops = {:-@ => 1, :~ => 1, :+@ => 1}
     @tables = {}
@@ -25,10 +25,8 @@ class RuleRewriter < Ruby2Ruby # :nodoc: all
 
   def call_is_attr_deref?(recv, op)
     if recv.first == :call and @bud_instance.tables.has_key? recv[2]
-      schema = @bud_instance.send(recv[2]).schema
-      if schema and schema.include? op
-        return true
-      end
+      cols = @bud_instance.tables[recv[2]].cols
+      return true if cols and cols.include? op
     end
     return false
   end
@@ -157,7 +155,7 @@ class AttrNameRewriter < SexpProcessor # :nodoc: all
       elsif exp[2] and exp[2][0] == :lasgn and @collnames.size > 1 and exp[1] # join iter with lefts/rights
         case exp[1][2]
         when :lefts
-          @iterhash[exp[2][1]] = @collnames[0] 
+          @iterhash[exp[2][1]] = @collnames[0]
         when :rights
           @iterhash[exp[2][1]] = @collnames[1]
         else
@@ -189,10 +187,10 @@ class AttrNameRewriter < SexpProcessor # :nodoc: all
     if recv and recv.class == Sexp and recv.first == :lvar and recv[1] and @iterhash[recv[1]]
       if @bud_instance.respond_to?(@iterhash[recv[1]])
         if @bud_instance.send(@iterhash[recv[1]]).class <= Bud::BudCollection
-          schema = @bud_instance.send(@iterhash[recv[1]]).schema
+          cols = @bud_instance.send(@iterhash[recv[1]]).cols
           if op != :[] and @bud_instance.send(@iterhash[recv[1]]).respond_to?(op)
             # if the op is an attribute name in the schema, col is its index
-            col = schema.index(op) unless schema.nil?
+            col = cols.index(op) unless cols.nil?
             unless col.nil?
               op = :[]
               args = s(:arglist, s(:lit, col))
@@ -348,7 +346,7 @@ class TempExpander < SexpProcessor # :nodoc: all
         end
 
         _, recv, meth, meth_args = n
-        if meth == @keyword and recv.nil?         
+        if meth == @keyword and recv.nil?
           block[i] = rewrite_me(n)
           @did_work = true
         end
@@ -366,9 +364,10 @@ class TempExpander < SexpProcessor # :nodoc: all
         _, lhs, op, rhs = meth_args.sexp_body.first
 
         old_rhs_body = rhs.sexp_body
-        rhs[1] = s(:iter)
-        rhs[1] += old_rhs_body
-        rhs[1] += iter_body[1..-1]
+        new_rhs_body = [:iter]
+        new_rhs_body += old_rhs_body
+        new_rhs_body += iter_body[1..-1]
+        rhs[1] = Sexp.from_array(new_rhs_body)
         return call_node
       end
     end
@@ -468,7 +467,7 @@ class WithExpander < TempExpander
     meth_name = Module.make_state_meth_name(klass).to_s + "__" + @keyword.to_s
     return s(:defn, meth_name.to_sym, s(:args), s(:scope, block))
   end
-  
+
   private
   def rewrite_me(exp)
     _, recv, meth, args = exp
@@ -490,10 +489,10 @@ class WithExpander < TempExpander
     @with_rules.push nest_block
     new_recv = s(:call, nil, tmp_name, s(:arglist))
     return s(:call, new_recv, nest_op, nest_args)
-  end  
-  
+  end
+
   undef get_state_meth
-  
+
   public
   def get_state_meth(klass)
     return if @tmp_tables.empty?
@@ -558,24 +557,24 @@ module ModuleRewriter # :nodoc: all
   # the import site. Note that additional rewrites are needed to ensure that
   # code in the import site that accesses module contents does the right thing;
   # see Bud#rewrite_local_methods.
-  
+
   @@with_id = 0 # upon initialize
   def self.with_id
     @@with_id
   end
-  
+
   def self.incr_with_id
     @@with_id += 1
   end
-  
+
   def self.do_import(import_site, mod, local_name)
-    # ast_process_withs modifies its argument as a side-effect 
+    # ast_process_withs modifies its argument as a side-effect
     # and returns a matching ast.
     # hence we run it before the other rewrites.
     ast = ast_process_withs(mod)
     ast = ast_flatten_nested_refs(ast, mod.bud_import_table)
     ast = ast_process_temps(ast, mod)
-    
+
     ast, new_mod_name = ast_rename_module(ast, import_site, mod, local_name)
     rename_tbl = {}
     ast = ast_rename_methods(ast, local_name, rename_tbl)
@@ -584,14 +583,14 @@ module ModuleRewriter # :nodoc: all
 
     str = Ruby2Ruby.new.process(ast)
     rv = import_site.module_eval str
-    raise Bud::BudError unless rv.nil?
+    raise Bud::CompileError unless rv.nil?
     return new_mod_name
   end
 
   def self.get_module_ast(mod)
     raw_ast = get_raw_parse_tree(mod)
     unless raw_ast.first == :module
-      raise Bud::BudError, "import must be used with a Module"
+      raise Bud::CompileError, "import must be used with a Module"
     end
 
     return Unifier.new.process(raw_ast)
@@ -668,16 +667,16 @@ module ModuleRewriter # :nodoc: all
     end
     return ast
   end
-  
+
   def self.ast_mangle_with(w,klass)
     r2r = Ruby2Ruby.new
-    
+
     while st = w.get_state_meth(klass)
       # generate the module
       tmpmod = Module.new
 
       # add a state block to define a temp for the collection name
-      state_src = r2r.process(st)        
+      state_src = r2r.process(st)
       tmpmod.module_eval(state_src)
 
       # add a bloom block
@@ -697,13 +696,13 @@ module ModuleRewriter # :nodoc: all
 
       # eval all that Ruby we generated and import new Module into our code
       tmpmod.module_eval(bloom_src)
-      modname = "with__"+ModuleRewriter.with_id.to_s
+      modname = "with__#{ModuleRewriter.with_id.to_s}"
       klass.import tmpmod => modname.to_sym
 
       ModuleRewriter.incr_with_id
     end
   end
-    
+
   def self.ast_process_withs(mod)
       # strategy to handle withs:
       # 1) run WithExpander#process to delete the "with" blocks and extract their contents
@@ -716,9 +715,9 @@ module ModuleRewriter # :nodoc: all
       ast = w.process(ast)
       mod_s, name_s, blocks = ast[0], ast[1], ast[2..-1]
       tag, name, args, scope = blocks[0]
-      
-      self.ast_mangle_with(w,mod) 
-      
+
+      self.ast_mangle_with(w, mod)
+
       retval = Unifier.new.process(self.get_raw_parse_tree(mod))
       return retval
       # return s(mod_s, name_s, *blocks)
@@ -730,7 +729,7 @@ module ModuleRewriter # :nodoc: all
   # "bootstrap", and "bloom" methods).
   def self.ast_rename_module(ast, importer, importee, local_name)
     mod_name = ast.sexp_body.first
-    raise Bud::BudError if mod_name.to_s != importee.to_s
+    raise Bud::CompileError if mod_name.to_s != importee.to_s
 
     # If the importer or importee modules are nested inside an outer module,
     # strip off the outer module name before using for name mangling purposes
@@ -752,7 +751,7 @@ module ModuleRewriter # :nodoc: all
   # given module's AST. Returns a table mapping old => new names.
   def self.ast_rename_state(ast, local_name, rename_tbl)
     # Find all the state blocks in the AST
-    raise Bud::BudError unless ast.sexp_type == :module
+    raise Bud::CompileError unless ast.sexp_type == :module
 
     ast.sexp_body.each do |b|
       next unless b.class <= Sexp
@@ -761,17 +760,17 @@ module ModuleRewriter # :nodoc: all
       def_name, args, scope = b.sexp_body
       next unless /^__state\d+__/.match def_name.to_s
 
-      raise Bud::BudError unless scope.sexp_type == :scope
+      raise Bud::CompileError unless scope.sexp_type == :scope
       state_block = scope.sexp_body.first
-      raise Bud::BudError unless state_block.sexp_type == :block
+      raise Bud::CompileError unless state_block.sexp_type == :block
       next unless state_block.sexp_body
 
       # Look for collection definition statements inside the block
       state_block.sexp_body.each do |e|
-        raise Bud::BudError unless e.sexp_type == :call
+        raise Bud::CompileError unless e.sexp_type == :call
 
         recv, meth_name, args = e.sexp_body
-        raise Bud::BudError unless args.sexp_type == :arglist
+        raise Bud::CompileError unless args.sexp_type == :arglist
 
         if meth_name == :interface
           tbl_name_node = args.sexp_body[1]
@@ -779,7 +778,9 @@ module ModuleRewriter # :nodoc: all
           tbl_name_node = args.sexp_body[0]
         end
 
-        raise Bud::BudError unless tbl_name_node.sexp_type == :lit
+        if tbl_name_node.nil? or tbl_name_node.sexp_type != :lit
+          raise Bud::CompileError, "syntax error in state block"
+        end
         tbl_name = tbl_name_node.sexp_body.first
 
         new_tbl_name = "#{local_name}__#{tbl_name}".to_sym