bud 0.0.8 → 0.1.0.pre1

data/lib/bud/joins.rb

@@ -1,3 +1,4 @@
+$EMPTY = []
 module Bud
   class BudJoin < BudCollection
     attr_accessor :rels, :origrels, :origpreds # :nodoc: all
@@ -106,7 +107,7 @@ module Bud
       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
+      while dupfree_schema == $EMPTY or dupfree_schema.uniq.length < dupfree_schema.length
         dupfree_schema = []
         flat_schema.reduce({}) do |memo, r|
           if r.to_s.include?("_") and ((r.to_s.rpartition("_")[2] =~ /^\d+$/) == 0)

data/lib/bud/meta_algebra.rb

@@ -1,6 +1,5 @@
 require 'rubygems'
 require 'bud'
-require 'bud/depanalysis'
 
 module MetaAlgebra
   state do
@@ -48,6 +47,7 @@ module MetaAlgebra
     #stdio <~ seq_lattice_closure{|c| ["SLC: #{c.inspect}"]}
     #stdio <~ jlr {|j| ["JLR: #{j.inspect}"]}
     #stdio <~ lub {|l| ["LUB #{l.inspect}, left class #{l.left.class}"]}
+    #stdio <~ clean_dep.inspected
   end
 
   bloom :lattice_rules do
@@ -92,10 +92,11 @@ module MetaAlgebra
   end
  
   bloom :make_paths do
-    rule_nm <= t_depends.reduce({}) do |memo, i|
+    rule_nm <= t_depends.reduce(Hash.new) do |memo, i|
       tag = get_tag(i.nm, i.op)
-      memo[i.rule_id] = tag if memo[i.rule_id].nil?
-      memo[i.rule_id] = tag if tag == :N or tag == :A
+      if memo[i.rule_id].nil? or memo[i.rule_id] == :M
+        memo[i.rule_id] = tag
+      end
       memo
     end
 

data/lib/bud/metrics.rb

@@ -1,5 +1,11 @@
-require 'bud/errors'
-require 'faster_csv'
+require "bud/errors"
+if RUBY_VERSION <= "1.9"
+  require 'faster_csv'
+  $mod = FasterCSV
+else
+  require 'csv'
+  $mod = CSV
+end
 
 # metrics are reported in a nested hash representing a collection of relational tables.
 # The metrics hash has the following form:
@@ -14,7 +20,7 @@ require 'faster_csv'
 def report_metrics 
   metrics.each do |k,v|
     if v.first
-      csvstr = FasterCSV.generate(:force_quotes=>true) do |csv|
+      csvstr = $mod.generate(:force_quotes=>true) do |csv|
         csv << [k.to_s] + v.first[0].keys + [:val]
         v.each do |row|
           csv << [nil] + row[0].values + [row[1]]

data/lib/bud/monkeypatch.rb

@@ -1,33 +1,129 @@
 # We monkeypatch Module to add support for Bloom's syntax additions: "state",
 # "bloom", and "bootstrap" blocks, plus the "import" statement.
+
+require 'bud/source'
+
+class Class
+  def modules
+    a = self.ancestors
+    a[1..a.index(superclass)-1]
+  end
+end
+
+# FIXME: Use a subclass of Struct.
+class Struct
+  def <=>(o)
+    if o.class == self.class
+      self.each_with_index do |e, i|
+        cmp = e <=> o[i]
+        return cmp if cmp != 0
+      end
+      return 0
+    elsif o.nil?
+      return -1
+    else
+      raise "Comparison (<=>) between #{o.class} and #{self.class} not implemented"
+    end
+  end
+
+  alias oldeq :==
+  def ==(o)
+    if o.class == self.class
+      return oldeq(o)
+    elsif o.class == Array
+      begin
+        self.each_with_index do |el, i|
+          if el != o[i]
+            return false
+          end
+        end
+        return true
+      rescue StandardError
+        return false
+      end
+    end
+    false
+  end
+
+  def to_msgpack(out='')
+    self.to_a.to_msgpack(out)
+  end
+
+  def inspect
+    self.to_a.inspect
+  end
+
+  alias :to_s :inspect
+end
+
+# XXX: TEMPORARY/UGLY hack to ensure that arrays and structs compare. This can be
+# removed once tests are rewritten.
+class Array
+  alias :oldeq :==
+  def ==(o)
+    if o.kind_of? Struct
+      o = (o.to_a)
+    end
+    self.oldeq(o)
+  end
+end
+
+
+$moduleWrapper = {} # module => wrapper class.  See import below.
 class Module
+  def modules
+    ancestors[1..-1]
+  end
+
   # import another module and assign to a qualifier symbol: <tt>import MyModule => :m</tt>
   def import(spec)
     raise Bud::CompileError unless (spec.class <= Hash and spec.length == 1)
     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"
+    # A statement like this:
+    #   import MyModule => :m
+    # is translated as follows. First, module MyModule is made instantiable by wrapping it in a class
+    #   class MyModule__wrap__
+    #     include Bud
+    #     include MyModule
+    #   end
+    #
+    # Then introduce a method "m", the import binding name, in the calling module/class
+    # (the one with the import statement). This returns an instance of the wrapped class.
+    #   inst = MyModule__wrap__.new
+    #   def m
+    #      inst
+    #   end
+
+    mod, local_name = spec.first
+
+    if self.instance_methods.include? local_name.to_s or self.instance_methods.include? local_name
+      raise Bud::CompileError, "#{local_name} is already taken."
+    else
+      src = %Q{
+        def #{local_name}
+          @#{local_name}
+        end
+        def #{local_name}=(val)
+          raise "Type Error: expecting an instance of #{mod}" unless val.kind_of? #{mod}
+          @#{local_name} = val
+        end
+      }
+      #puts src
+      self.class_eval src
     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
-    # module X points to X's own nested import table. If a single module
-    # attempts to import multiple sub-modules with the same local name, we merge
-    # the import tables of all the modules.
-    @bud_import_tbl ||= {}
-    prev_tbl = @bud_import_tbl[local_name]
-    child_tbl = NestedRefRewriter.build_import_table(mod)
-    @bud_import_tbl[local_name] = NestedRefRewriter.merge_import_table(prev_tbl, child_tbl)
+    import_tbl = self.bud_import_table
+    import_tbl[local_name] = mod
+  end
 
-    rewritten_mod_name = ModuleRewriter.do_import(self, mod, local_name)
-    self.module_eval "include #{rewritten_mod_name}"
+  def bud_import_table() #:nodoc: all
+    @bud_import_tbl ||= {}
+    @bud_import_tbl
   end
 
+
   # the block of Bloom collection declarations.  one per module.
   def state(&block)
     meth_name = Module.make_state_meth_name(self)
@@ -64,12 +160,22 @@ class Module
     if instance_methods(false).include? meth_name
       raise Bud::CompileError, "duplicate named bloom block: '#{block_name}' in #{self}"
     end
-    define_method(meth_name.to_sym, &block)
-  end
-
-  def bud_import_table() #:nodoc: all
-    @bud_import_tbl ||= {}
-    @bud_import_tbl
+    ast = Source.read_block(caller[0]) # pass in caller's location via backtrace
+    # ast corresponds only to the statements of the block. Wrap it in a method
+    # definition for backward compatibility for now.
+    # First wrap ast in a block if it is only a single statement
+    unless ast.nil?
+      ast = s(:block, ast) unless ast.sexp_type == :block
+      ast = s(:defn, meth_name.to_sym, s(:args), s(:scope, ast))
+      unless self.respond_to? :__bloom_asts__
+        def self.__bloom_asts__;
+          @__bloom_asts__ ||= {}
+          @__bloom_asts__
+        end
+      end
+      __bloom_asts__[meth_name] = ast
+      define_method(meth_name.to_sym, &block)
+    end
   end
 
   private
@@ -78,7 +184,9 @@ class Module
   # class/module Y, X's class name is the string "Y::X". We don't want to define
   # method names with semicolons in them, so just return "X" instead.
   def self.get_class_name(klass)
-    klass.name.split("::").last
+    (klass.name.nil? or klass.name == "") \
+      ? "Anon#{klass.object_id}" \
+      : klass.name.split("::").last
   end
 
   # State method blocks are named using an auto-incrementing counter. This is to

data/lib/bud/rebl.rb

@@ -3,11 +3,11 @@ require 'readline'
 require 'rubygems'
 require 'bud'
 require 'abbrev'
-
+require 'tempfile'
 TABLE_TYPES = ["table", "scratch", "channel", "loopback", "periodic", "sync", "store"]
 
 # The class to which rebl adds user-specified rules and declarations.
-class ReblClass
+class ReblBase
   include Bud
   attr_accessor:port, :ip
 
@@ -22,8 +22,8 @@ class ReblShell
   @@maxhistsize = 100
   @@escape_char = '/'
   @@commands =
-    {"tick" => [lambda {|lib,argv| lib.tick([Integer(argv[1]), 1].max)},
-                "tick [x]\texecutes x (or 1) timesteps"],
+    {"tick" => [lambda {|lib,argv| lib.tick(argv[1].nil? ? 1 : Integer(argv[1]))},
+                "tick [x]:\texecutes x (or 1) timesteps"],
 
     "run" => [lambda {|lib,_| lib.run},
               "run\ttick until quiescence, a breakpoint, or #{@@escape_char}stop"],
@@ -62,8 +62,9 @@ class ReblShell
     loop do
       begin
         rebl_loop(lib)
-      rescue Exception
-        puts "exception: #{$!}"
+      rescue Exception => e
+        puts "exception: #{e}"
+        #puts e.backtrace
       end
     end
   end
@@ -197,6 +198,7 @@ class LibRebl
   @@builtin_tables = [:stdio, :t_depends, :periodics_tbl, :t_cycle, :localtick,
                       :t_provides, :t_rules, :t_depends_tc, :t_stratum,
                       :rebl_breakpoint]
+  @@classid = 0
 
   def initialize(ip, port)
     @ip = ip
@@ -222,7 +224,7 @@ class LibRebl
   end
 
   # Ticks the bud instance a specified integer number of times.
-  def tick(x)
+  def tick(x=1)
     x.times {@rebl_class_inst.sync_do}
   end
 
@@ -234,13 +236,7 @@ class LibRebl
       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
+      puts(tups.empty? ? "(empty)" : tups.sort.map{|t| "#{t}"}.join("\n"))
     end
   end
 
@@ -278,22 +274,40 @@ class LibRebl
     end
   end
 
-  private
-  def reinstantiate
-    # New anonymous subclass.
-    @rebl_class = Class.new(ReblClass)
-
+  def mk_rebl_class
+    @@classid += 1
+    cls_name = "ReblClass#{@@classid}"
+
+    str = ""
+    str =<<-EOS
+      $BUD_SAFE=1
+      class #{cls_name} < ReblBase
+        include Bud
+      EOS
+    unless @state.empty?
+      str += "state do\n" + @state.values.join("\n") + "\nend\n"
+    end
+    unless @rules.empty?
+      str += "bloom :rebl_rules do\n" + @rules.sort.map {|_,r| r}.join("\n") + "\nend\n"
+    end
+    str += "\nend\n"
+    f = Tempfile.new("rebl")
+    f.write(str)
+    f.close
     begin
-      if not @rules.empty?
-        @rebl_class.class_eval("bloom :rebl_rules do\n" +
-                               @rules.sort.map {|_,r| r}.join("\n") + "\nend")
-      end
-      if not @state.empty?
-        @rebl_class.class_eval("state do\n" + @state.values.join("\n") + "\nend")
-      end
-    rescue Exception
+      load f.path
+      return eval cls_name  # return the class object
+    rescue
+      $stderr.puts "Unable to eval the following code:\n" + str
       raise
+    ensure
+      f.unlink
     end
+  end
+
+  private
+  def reinstantiate
+    @rebl_class = mk_rebl_class
 
     @old_inst = @rebl_class_inst
     @rebl_class_inst = @rebl_class.new(:signal_handling => :none, :ip => @ip,
@@ -314,7 +328,6 @@ class LibRebl
       @rebl_class_inst.channels.merge!(@old_inst.channels.reject do |k,v|
                                          @@builtin_tables.include? k
                                        end)
-      @rebl_class_inst.tc_tables.merge! @old_inst.tc_tables
       @rebl_class_inst.dbm_tables.merge! @old_inst.dbm_tables
       @rebl_class_inst.zk_tables.merge! @old_inst.zk_tables