bud 0.9.7 → 0.9.8

checksums.yaml

@@ -1,7 +1,15 @@
 ---
-SHA1:
-  metadata.gz: 3d9ec3dd7f92dded5c77e541617853e0954fccaf
-  data.tar.gz: 37c31e760cbfe5305ebb73d3ff6e2417e499022d
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    OTgyYTM2NWZkYmJlNjI4ODhkNWE3MGMwYmM0ZTFkYjFjMjQxYzdhOA==
+  data.tar.gz: !binary |-
+    ZDI1ZDMzNWJiYTgzOGFhOTYxMmEyMjM4NjdmZDM5ZjFhYTBkYjg0Zg==
 SHA512:
-  metadata.gz: a9fe2678a4aa143ebfa6ae677426bc60593550bda6209edc056855a6bca1b4f7ee5b4fc99e773d74679ca57fc615da7128e6db4622c855d45fda60e138bb78de
-  data.tar.gz: 240d532afbe76c4a7740f65276e7d0bb405b52661e8dde63fc42e54a5d40deb6d23c0bea1ef7d4a9e0e0e060c837533a0e3202c3ab41f33779861df6db673509
+  metadata.gz: !binary |-
+    MTlhYWYxMTAyZDVhZWU4OTRmYjIwYjU5NzRlYzY1NDdmYzk3MWJjYTY1MDMw
+    OGRlYjNlMzc4MDZkOWZmOTdhZjRmNDYwMmYyYzk1MDU2NmUyNjdkMGU5NjBj
+    ZjY4NzYwYjU3MzBlOTlmZjUyMTgwMGEyYjdmNmNlZGMwNmU4MTU=
+  data.tar.gz: !binary |-
+    MmJkNjZhNzNlMzdhOGJjZDk0ZWRiMWY2MTk2MWY4OWQ1MGI2NzA2NTMxZDk0
+    NTdjODdiMDg1MGY3ZTQ3YTBjZmU2ODE4NjYwMTY0NzRiNmRlMDI2YzYzZmZh
+    MGVkZWVmZDk5NDllMDFhYTMyMTg3YTUzZGE0NWVhYzgxNGVjYjc=

data/History.txt

@@ -1,3 +1,21 @@
+== 0.9.8 / ???
+
+* Fix bug in the stratification algorithm
+* Fix bug with insertions into stdio inside bootstrap blocks
+* Improve error message when <~ applied to a collection type that doesn't
+  support it (#316)
+* Fix rescan logic for Zookeeper-backed collections (#317)
+* Fix rescan logic for chained negation operators in a single rule
+* Support + operator for concatenating tuples
+* More consistent behavior for #==, #eql?, and #hash methods on Bud tuple
+  objects (TupleStruct)
+* Fix intermittent EM::ConnectionNotBound exceptions during the Bud shutdown
+  sequence
+* Improve stratification algorithm to be slightly more aggressive; that is, we
+  can place certain rules in an earlier strata than we were previously
+  (partially fixes #277)
+* Add Rakefile to simplify common development operations (Joel VanderWerf, #324)
+
 == 0.9.7 / 2013-04-22
 
 * Avoid raising an exception when Bud is used with Ruby 2.0. There isn't

data/Rakefile

@@ -0,0 +1,91 @@
+require 'rake'
+require 'rake/testtask'
+
+PRJ = "bud"
+
+def version
+  @version ||= begin
+    $LOAD_PATH.unshift 'lib'
+    require 'bud/version'
+    warn "Bud::VERSION not a string" unless Bud::VERSION.kind_of? String
+    Bud::VERSION
+  end
+end
+
+def tag
+  @tag ||= "v#{version}"
+end
+
+desc "Run all tests"
+task :test => "test:unit"
+
+TESTS = FileList["test/tc_*.rb"]
+SLOW_TESTS = %w{ test/tc_execmodes.rb }
+
+namespace :test do
+  desc "Run unit tests"
+  Rake::TestTask.new :unit do |t|
+    t.libs << "lib"
+    t.ruby_opts = %w{ -C test }
+    t.test_files = TESTS.sub('test/', '')
+      ### it would be better to make each tc_*.rb not depend on pwd
+  end
+
+  desc "Run quick unit tests"
+  Rake::TestTask.new :quick do |t|
+    t.libs << "lib"
+    t.ruby_opts = %w{ -C test }
+    t.test_files = TESTS.exclude(*SLOW_TESTS).sub('test/', '')
+  end
+
+  desc "Run quick non-zk unit tests"
+  Rake::TestTask.new :quick_no_zk do |t|
+    t.libs << "lib"
+    t.ruby_opts = %w{ -C test }
+    t.test_files = TESTS.
+      exclude('test/tc_zookeeper.rb').
+      exclude(*SLOW_TESTS).
+      sub('test/', '')
+  end
+end
+
+desc "Commit, tag, and push repo; build and push gem"
+task :release => "release:is_new_version" do
+  require 'tempfile'
+  
+  sh "gem build #{PRJ}.gemspec"
+
+  file = Tempfile.new "template"
+  begin
+    file.puts "release #{version}"
+    file.close
+    sh "git commit --allow-empty -a -v -t #{file.path}"
+  ensure
+    file.close unless file.closed?
+    file.unlink
+  end
+
+  sh "git tag #{tag}"
+  sh "git push"
+  sh "git push --tags"
+  
+  sh "gem push #{tag}.gem"
+end
+
+namespace :release do
+  desc "Diff to latest release"
+  task :diff do
+    latest = `git describe --abbrev=0 --tags --match 'v*'`.chomp
+    sh "git diff #{latest}"
+  end
+
+  desc "Log to latest release"
+  task :log do
+    latest = `git describe --abbrev=0 --tags --match 'v*'`.chomp
+    sh "git log #{latest}.."
+  end
+
+  task :is_new_version do
+    abort "#{tag} exists; update version!" unless `git tag -l #{tag}`.empty?
+  end
+end

data/bin/budplot

@@ -21,6 +21,10 @@ def make_instance(mods)
   # If we're given a single identifier that names a class, just return an
   # instance of that class. Otherwise, define a bogus class that includes all
   # the module names specified by the user and return an instance.
+  tmpserver = TCPServer.new('127.0.0.1', 0) # get a free port
+  default_params = {:dbm_dir => "/tmp/budplot_dbm_" + SecureRandom.uuid.to_s, :port => tmpserver.addr[1]}
+
+
   mods.each do |m|
     unless is_constant? m
       puts "Error: unable to find definition for module or class \"#{m}\""
@@ -30,7 +34,7 @@ def make_instance(mods)
     mod_klass = eval m
     if mod_klass.class == Class
       if mods.length == 1
-        return mod_klass.new
+        return mod_klass.new(default_params)
       else
         puts "Error: cannot intermix class \"#{mod_klass}\" with modules"
         exit
@@ -50,7 +54,7 @@ def make_instance(mods)
               ]
   class_def = def_lines.flatten.join("\n")
   eval(class_def)
-  f =FooBar.new
+  f = FooBar.new(default_params)
   3.times{ f.tick }
   f
 end
@@ -220,6 +224,7 @@ end
 modules = []
 ARGV.each do |arg|
   if File.exists? arg
+    arg = File.expand_path arg
     require arg
   else
     modules << arg

data/docs/README.md

@@ -6,28 +6,19 @@ Welcome to the documentation for *Bud*, a prototype of Bloom under development.
 The documents here are organized to be read in any order, but you might like to
 try the following:
 
-* [intro.md][intro]: A brief introduction to Bud and Bloom.
-* [getstarted.md][getstarted]: A quickstart to teach you basic Bloom
+* [intro](intro.md): A brief introduction to Bud and Bloom.
+* [getstarted](getstarted.md): A quickstart to teach you basic Bloom
   concepts, the use of `rebl` interactive terminal, and the embedding of Bloom
   code in Ruby via the `Bud` module.
-* [operational.md][operational]: An operational view of Bloom, to provide
+* [operational](operational.md): An operational view of Bloom, to provide
   a more detailed model of how Bloom code is evaluated by Bud.
-* [cheat.md][cheat]: A concise "cheat sheet" to remind you about Bloom syntax.
-* [modules.md][modules]: An overview of Bloom's modularity features.
-* [ruby\_hooks.md][ruby_hooks]: Bud module methods that allow you to
+* [cheat](cheat.md): Full documentation of the language constructs in a concise "cheat sheet" style.
+* [modules](modules.md): An overview of Bloom's modularity features.
+* [ruby_hooks](ruby\_hooks.md): Bud module methods that allow you to
   interact with the Bud evaluator from other Ruby threads.
-* [visualizations.md][visualizations]: Overview of the `budvis` and
+* [visualizations](visualizations.md): Overview of the `budvis` and
   `budplot` tools for visualizing Bloom program analyses.
-* [bfs.md][bfs]: A walkthrough of the Bloom distributed filesystem.
-
-[intro]:          /docs/intro.md
-[getstarted]:     /docs/getstarted.md
-[operational]:    /docs/operational.md
-[cheat]:          /docs/cheat.md
-[modules]:        /docs/modules.md
-[ruby_hooks]:     /docs/ruby_hooks.md
-[visualizations]: /docs/visualizations.md
-[bfs]:            /docs/bfs.md
+* [bfs](bfs.md): A walkthrough of the Bloom distributed filesystem.
 
 In addition, the [bud-sandbox](http://github.com/bloom-lang/bud-sandbox) GitHub
 repository contains lots of useful libraries and example programs built using

data/docs/cheat.md

@@ -194,7 +194,7 @@ implicit map:
     end
 
 ## BudCollection-Specific Methods ##
-`bc.schema`: returns the schema of `bc` (Hash of key column names => non-key column names). Note that for channels, this omits the location specifier (<tt>@</tt>).<br>
+`bc.schema`: returns the schema of `bc` (Hash of key column names => non-key column names; if no non-key columns, just an Array of key column names). Note that for channels, this omits the location specifier (<tt>@</tt>).<br>
 
 `bc.cols`: returns the column names in `bc` as an Array<br>
 

data/docs/getstarted.md

@@ -66,9 +66,11 @@ Second, note that our Bud program's one statement merges the values on its right
 ### Tables and Scratches ###
 Before we dive into writing server code, let's try a slightly more involved single-timestep example.  Start up rebl again, and paste in the following:
 
-    table :clouds
-    clouds <= [[1, "Cirrus"], [2, "Cumulus"]]
-    stdio <~ clouds.inspected
+``` ruby
+table :clouds
+clouds <= [[1, "Cirrus"], [2, "Cumulus"]]
+stdio <~ clouds.inspected
+```
     
 Now tick your rebl, but don't quit yet.  
 
@@ -128,8 +130,10 @@ Now that we've seen a bit of Bloom, we're ready to write our first interesting s
 
 Even though we're getting ahead of ourselves, let's have a peek at the Bloom statements that implement the server in `examples/chat/chat_server.rb`:
 
-    nodelist <= connect { |c| [c.client, c.nick] }
-    mcast <~ (mcast * nodelist).pairs { |m,n| [n.key, m.val] }
+``` ruby
+nodelist <= connect { |c| [c.client, c.nick] }
+mcast <~ (mcast * nodelist).pairs { |m,n| [n.key, m.val] }
+```
 
 That's it!  There is one statement for each of the two sentences describing the behavior of the "basic idea" above.  We'll go through these two statements in more detail shortly.  But it's nice to see right away how concisely and naturally a Bloom program can fit our intuitive description of a distributed service.
 
@@ -137,14 +141,16 @@ That's it!  There is one statement for each of the two sentences describing the
 
 Now that we've satisfied our need to peek, let's take this a bit more methodically.  First we need declarations for the various Bloom collections we'll be using.  We put the declarations that are common to both client and server into file `examples/chat/chat_protocol.rb`:
 
-    module ChatProtocol
-      state do
-        channel :connect, [:@addr, :client] => [:nick]
-        channel :mcast
-      end
-      
-      DEFAULT_ADDR = "localhost:12345"
-    end
+``` ruby
+module ChatProtocol
+  state do
+    channel :connect, [:@addr, :client] => [:nick]
+    channel :mcast
+  end
+  
+  DEFAULT_ADDR = "localhost:12345"
+end
+```
 
 This defines a [Ruby mixin module](http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html) called `ChatProtocol` that has a couple special Bloom features:
 
@@ -156,33 +162,34 @@ This defines a [Ruby mixin module](http://www.ruby-doc.org/docs/ProgrammingRuby/
 
 Given this protocol (and the Ruby constant at the bottom), we're now ready to examine `examples/chat/chat_server.rb` in more detail:
 
-    require 'rubygems'
-    require 'bud'
-    require 'chat_protocol'
-
-    class ChatServer
-      include Bud
-      include ChatProtocol
-
-      state { table :nodelist }
+``` ruby
+require 'rubygems'
+require 'bud'
+require_relative 'chat_protocol'
 
-      bloom do
-        nodelist <= connect { |c| [c.client, c.nick] }
-        mcast <~ (mcast * nodelist).pairs { |m,n| [n.key, m.val] }
-      end
-    end
-
-    if ARGV.first
-      addr = ARGV.first
-    else
-      addr = ChatProtocol::DEFAULT_ADDR
-    end
+class ChatServer
+  include Bud
+  include ChatProtocol
 
-    ip, port = addr.split(":")
-    puts "Server address: #{ip}:#{port}"
-    program = ChatServer.new(:ip => ip, :port => port.to_i)
-    program.run
+  state { table :nodelist }
 
+  bloom do
+    nodelist <= connect { |c| [c.client, c.nick] }
+    mcast <~ (mcast * nodelist).pairs { |m,n| [n.key, m.val] }
+  end
+end
+
+if ARGV.first
+  addr = ARGV.first
+else
+  addr = ChatProtocol::DEFAULT_ADDR
+end
+
+ip, port = addr.split(":")
+puts "Server address: #{ip}:#{port}"
+program = ChatServer.new(:ip => ip, :port => port.to_i)
+program.run_fg
+```
     
 The first few lines get the appropriate Ruby classes and modules loaded via `require`.  We then define the ChatServer class which mixes in the `Bud` module and the ChatProtocol module we looked at above.  Then we have another `state` block that declares one additional collection, the `nodelist` table.  
 
@@ -190,14 +197,18 @@ With those preliminaries aside, we have our first `bloom` block, which is how Bl
 
 The first is pretty simple: 
 
-     nodelist <= connect { |c| [c.client, c.nick] }
+``` ruby
+nodelist <= connect { |c| [c.client, c.nick] }
+```
 
 This says that whenever messages arrive on the channel named "connect", the client address and user-provided nickname should be instantaneously merged into the table "nodelist", which will store them persistently.  Note that nodelist has a \[key/val\] pair structure, so it is suitable for storing pairs of (IP address, nickname).
 
 The next Bloom statement is more complex.  Remember the description in the "basic idea" at the beginning of this section: the server needs to accept inbound chat messages from clients and forward them to other clients.  
 
-    mcast <~ (mcast * nodelist).pairs { |m,n| [n.key, m.val] }
-    
+``` ruby
+mcast <~ (mcast * nodelist).pairs { |m,n| [n.key, m.val] }
+```
+
 The first thing to note is the lhs and operator in this statement.  We are merging items (asynchronously, of course!) into the mcast channel, where they will be sent to their eventual destination.  
 
 The rhs is our first introduction to the `*` operator of Bloom collections, and the `pairs` method after it.  You can think of the `*` operator as "all-pairs": it produces a Bloom collection containing all pairs of mcast and nodelist items.  The `pairs` method iterates through these pairs, passing them through a code block via the block arguments `m` and `n`. Finally, for each such pair the block produces an item containing the `key` attribute of the nodelist item, and the `val` attribute of the mcast item.  This is structured as a proper \[address, val\] entry to be merged back into the mcast channel.  Putting this together, this statement *multicasts inbound payloads on the mcast channel to all nodes in the chat*.
@@ -205,7 +216,7 @@ The rhs is our first introduction to the `*` operator of Bloom collections, and
 The remaining lines of plain Ruby simply instantiate and run the ChatServer class (which includes the `Bud` module) using an ip and port given on the command line (or the default from ChatProtocol.rb).
 
 #### `*`'s and Clouds ####
-You can think of out use of the `*` operator in the rhs of the second statement in a few different ways:
+You can think of our use of the `*` operator on the rhs of the second statement in a few different ways:
 
 * If you're familiar with event-loop programming, this implements an *event handler* for messages on the mcast channel: whenever an mcast message arrives, this handler performs lookups in the nodelist table to form new messages.  (It is easy to add "filters" to these handlers as arguments to `pairs`.)  The resulting messages are dispatched via the mcast channel accordingly.  This is a very common pattern in Bloom programs: handling channel messages via lookups in a table.
 
@@ -218,49 +229,51 @@ Given our understanding of the server, the client should be pretty simple.  It n
 
 And here's the code:
 
-    require 'rubygems'
-    require 'bud'
-    require 'chat_protocol'
-
-    class ChatClient
-      include Bud
-      include ChatProtocol
-
-      def initialize(nick, server, opts={})
-        @nick = nick
-        @server = server
-        super opts
-      end
-
-      bootstrap do
-        connect <~ [[@server, ip_port, @nick]]
-      end
-
-      bloom do
-        mcast <~ stdio do |s|
-          [@server, [ip_port, @nick, Time.new.strftime("%I:%M.%S"), s.line]]
-        end
-
-        stdio <~ mcast { |m| [pretty_print(m.val)] }
-      end
-
-      # format chat messages with timestamp on the right of the screen
-      def pretty_print(val)
-        str = val[1].to_s + ": " + (val[3].to_s || '')
-        pad = "(" + val[2].to_s + ")"
-        return str + " "*[66 - str.length,2].max + pad
-      end
-    end
+``` ruby
+require 'rubygems'
+require 'bud'
+require_relative 'chat_protocol'
+
+class ChatClient
+  include Bud
+  include ChatProtocol
 
-    if ARGV.length == 2
-      server = ARGV[1]
-    else
-      server = ChatProtocol::DEFAULT_ADDR
+  def initialize(nick, server, opts={})
+    @nick = nick
+    @server = server
+    super opts
+  end
+
+  bootstrap do
+    connect <~ [[@server, ip_port, @nick]]
+  end
+
+  bloom do
+    mcast <~ stdio do |s|
+      [@server, [ip_port, @nick, Time.new.strftime("%I:%M.%S"), s.line]]
     end
 
-    puts "Server address: #{server}"
-    program = ChatClient.new(ARGV[0], server, :read_stdin => true)
-    program.run_fg
+    stdio <~ mcast { |m| [pretty_print(m.val)] }
+  end
+
+  # format chat messages with timestamp on the right of the screen
+  def pretty_print(val)
+    str = val[1].to_s + ": " + (val[3].to_s || '')
+    pad = "(" + val[2].to_s + ")"
+    return str + " "*[66 - str.length,2].max + pad
+  end
+end
+
+if ARGV.length == 2
+  server = ARGV[1]
+else
+  server = ChatProtocol::DEFAULT_ADDR
+end
+
+puts "Server address: #{server}"
+program = ChatClient.new(ARGV[0], server, :stdin => $stdin)
+program.run_fg
+```
 
 The ChatClient class has a typical Ruby `initialize` method that sets up two local instance variables: one for this client's nickname, and another for the 'IP:port' address string for the server.  It then calls the initializer of the Bud superclass passing along a hash of options.
 
@@ -293,4 +306,4 @@ In this section we saw a number of features that we missed in our earlier single
 * **the * operator and pairs method**: the way to combine items from multiple collections.
 
 # The Big Picture and the Details #
-Now that you've seen some working Bloom code, hopefully you're ready to delve deeper.  The [README](README.md) provides links to places you can go for more information.  Have fun and [stay in touch](http://groups.google.com/group/bloom-lang)!
+Now that you've seen some working Bloom code, hopefully you're ready to delve deeper.  The [README](README.md) provides links to places you can go for more information.  Have fun and [stay in touch](http://groups.google.com/group/bloom-lang)!