wukong 3.0.0.pre → 3.0.0.pre2

data/old/examples/stats/binning_percentile_estimator.rb

@@ -1,140 +0,0 @@
-#!/usr/bin/env ruby
-require 'rubygems'
-require 'wukong/script'
-require 'wukong/streamer/count_keys'
-
-#
-# Ch3ck out dis moist azz code bitches!!
-#
-#
-
-#
-# Do nothing more than bin users here, arbitrary and probably bad
-#
-class Mapper < Wukong::Streamer::RecordStreamer
-  def process rank, followers
-    followers = followers.to_i
-    if followers > 100
-      yield [9,rank]
-    elsif followers > 75
-      yield [8,rank]
-    elsif followers > 50
-      yield [7,rank]
-    elsif followers > 25
-      yield [6,rank]
-    elsif followers > 15
-      yield [5,rank]
-    elsif followers > 10
-      yield [4,rank]
-    elsif followers > 5
-      yield [3,rank]
-    elsif followers > 4
-      yield [2,rank]
-    elsif followers > 1
-      yield [1,rank]
-    else
-      yield [0,rank]
-    end
-  end
-end
-
-
-#
-# Calculate percentile rank for every pr value in a given follower bracket
-#
-class Reducer < Wukong::Streamer::AccumulatingReducer
-  attr_accessor :count_bin
-  def start! bin, rank
-    self.count_bin            ||= {}
-    self.count_bin[bin]       ||= {}
-  end
-
-  def accumulate bin, rank
-    rank = (rank.to_f*10.0).round.to_f/10.0
-    self.count_bin[bin][rank] ||= 0
-    self.count_bin[bin][rank] += 1
-  end
-
-  def finalize
-    count_bin[key] = generate_all_pairs(key).inject({}){|h,pair| h[pair.first] = pair.last; h}
-    yield [key, count_bin[key].values.sort.join(",")]
-  end
-
-  #
-  # Write the final table to disk as a ruby hash
-  #
-  def after_stream
-    table = File.open("trstrank_table.rb", 'w')
-    table << "TRSTRANK_TABLE = " << count_bin.inspect
-    table.close
-  end
-
-  #
-  # Return percentile of a given trstrank for a given follower bracket
-  #
-  def percentile bin, rank
-    ((count_less_than(bin,rank) + 0.5*frequency_of(bin,rank))/ total_num(bin) )*100.0
-  end
-
-  #
-  # Return the count of values less than rank
-  #
-  def count_less_than bin, rank
-    count_bin[bin].keys.inject(0){|count,key| count += count_bin[bin][key] if key.to_f < rank; count}
-  end
-
-  #
-  # Return the count of rank
-  #
-  def frequency_of bin, rank
-    count_bin[bin].keys.inject(0){|count,key| count += count_bin[bin][key] if key.to_f == rank; count}
-  end
-
-  #
-  # Return the total number in sample
-  #
-  def total_num bin
-    count_bin[bin].values.inject(0){|count,v| count += v; count}
-  end
-
-  #
-  # Generate a list of all pairs {trstrank => percentile}, interpolate when necessary
-  #
-  def generate_all_pairs bin
-    h = {}
-    count_bin[bin].keys.each do |rank|
-      h[rank.to_f] = percentile(bin, rank.to_f)
-    end
-    h[0.0]  ||= 0.0
-    h[10.0] ||= 100.0
-    arr      = h.to_a.sort!{|x,y| x.first <=> y.first}
-    list     = arr.zip(arr[1..-1])
-    big_list = []
-    big_list << [0.0,0.0]
-    list.each do |pairs|
-      interpolate(pairs.first, pairs.last, 0.1).each{|pair| big_list << pair}
-    end
-    big_list.uniq.sort{|x,y| x.first <=> y.first}
-  end
-
-
-  #
-  # Nothing to see here, move along
-  #
-  def interpolate pair1, pair2, dx
-    return [pair1] if pair2.blank?
-    m   = (pair2.last - pair1.last)/(pair2.first - pair1.first) # slope
-    b   = pair2.last - m*pair2.first                            # y intercept
-    num = ((pair2.first - pair1.first)/dx).abs.round            # number of points to interpolate
-    points = []
-    num.times do |i|
-      x = pair1.first + (i+1).to_f*dx
-      y = m*x + b
-      points << [x,y]
-    end
-    points                                                       # return an array of pairs
-  end
-
-end
-
-Wukong::Script.new(Mapper,Reducer).run

data/old/examples/stats/data/avg_value_frequency.tsv

@@ -1,3 +0,0 @@
-1	15	30	25
-2	10	10	20
-3	50	30	30

data/old/examples/stats/rank_and_bin.rb

@@ -1,173 +0,0 @@
-#!/usr/bin/env ruby
-require 'rubygems'
-require 'wukong/script'
-require 'wukong/streamer/rank_and_bin_reducer'
-
-#
-# This example uses the classes from http://github.com/mrflip/twitter_friends
-# (That's sloppy, and I apologize. I'm building this script for that, but it
-# seems broadly useful and I'm not maintaining two copies. Once this script is
-# more worky we'll make it standalone.  Anyway you should get the picture.)
-#
-$: << File.dirname(__FILE__)+'/../../projects/twitter_friends/lib'
-require 'twitter_friends';
-require 'twitter_friends/struct_model' ; include TwitterFriends::StructModel
-
-
-#
-# attrs to bin
-#
-BINNABLE_ATTRS = {
-  :twitter_user => [
-    [:followers_count,  :fo   ],
-    [:friends_count,    :fr   ],
-    [:statuses_count,   :st   ],
-    [:favourites_count, :fv   ],
-    [:created_at,       :crat ]
-    ]
-
-}
-RESOURCE_ALIASES = {
-  :twitter_user  => :u,
-  :user_metrics  => :um,
-}
-#
-# KLUDGE This is not DRY at all but  let's get it working first
-#
-BinUserMetrics = TypedStruct.new(
-  [:id, Integer],
-  *BINNABLE_ATTRS[:user_metrics].map{|attr, attr_abbr| [attr_abbr, Integer] }
-  )
-BINNED_RESOURCE_ALIASES = {
-  :u   => BinTwitterUser,
-}
-
-module RankAndBinAttrs
-  class ExplodeResourceMapper < Wukong::Streamer::StructStreamer
-    def get_and_format_attr thing, attr
-      val = thing.send(attr)
-      case thing.members_types[attr].to_s.to_sym
-      when :Integer     then "%010d"   % val.to_i
-      when :Float       then "%020.7f" % val.to_f
-      when :Bignum      then "%020d"   % val.to_i
-      else
-        raise [val, thing.members_types[attr].to_s.to_sym].inspect
-      end
-    end
-
-    #
-    # The data expansion of this mapper is large enough that it makes sense to
-    # be a little responsible with what we emit.  We'll use the RESOURCE_ALIASES
-    # and BINNABLE_ATTRS hashes, above, to dump a more parsimonious
-    # representation.
-    #
-    def process thing, *args, &block
-      attr_abbrs = BINNABLE_ATTRS[thing.class.resource_name]
-      return unless attr_abbrs
-      attr_abbrs.each do |attr, abbr|
-        yield [
-          RESOURCE_ALIASES[thing.class.resource_name],
-          abbr,
-          get_and_format_attr(thing, attr),
-          thing.id.to_i
-        ]
-      end
-    end
-  end
-
-  class BinAttrReducer < Wukong::Streamer::RankAndBinReducer
-    attr_accessor :last_rsrc_attr
-    #
-    # Note that we might get several different resources at the same reducer
-    #
-    def get_key rsrc, attr, val, *args
-      if [rsrc, attr] != self.last_rsrc_attr
-        # Note: since each partition has the same cardinality, we don't need to
-        # fiddle around with the bin_size, etc -- just reset the order
-        # parameters' state.
-        reset_order_params!
-        self.last_rsrc_attr = [rsrc, attr]
-      end
-      val
-    end
-
-    #
-    # Note well -- we are rearranging the field order to
-    #
-    #   resource_abbr id  attr_abbr  bin
-    #
-    # for proper sorting to the re-assembler
-    #
-    def emit record
-      rsrc, attr, val, id, numbering, rank, bin = record
-      super [rsrc, id, attr, bin]
-    end
-  end
-
-  class ReassembleObjectReducer < Wukong::Streamer::AccumulatingReducer
-    attr_accessor :thing
-    def klass_from_abbr rsrc_abbr
-      BINNED_RESOURCE_ALIASES[rsrc_abbr.to_sym]
-    end
-    def get_key rsrc_abbr, id, *args
-      [rsrc_abbr, id.to_i]
-    end
-
-    def start! rsrc_abbr, id, *args
-      klass = klass_from_abbr(rsrc_abbr)
-      self.thing = klass.new id.to_i
-    end
-
-    def accumulate rsrc, id, attr, bin
-      thing.send("#{attr}=", bin)
-    end
-
-    def finalize
-      yield thing
-    end
-  end
-
-  #
-  # Two-phase script
-  #
-  # FIXME -- We need a runner class to manage this.
-  #
-  class Script < Wukong::Script
-    attr_accessor :phase
-    # KLUDGE !!
-    def initialize
-      case
-      when ARGV.detect{|arg| arg =~ /--phase=1/}
-        # Phase 1 -- Steal underpants.  Also, disassemble each object, and find
-        # the bin for each binnable attribute's value
-        self.phase = 1
-        self.mapper_klass, self.reducer_klass = [ExplodeResourceMapper, BinAttrReducer]
-      when ARGV.detect{|arg| arg =~ /--phase=2/}
-        # Phase 2 -- ????
-        raise "Phase 2 : ????"
-      when ARGV.detect{|arg| arg =~ /--phase=3/}
-        # Phase 3 -- profit. In this case, put records back together.
-        self.phase = 3
-        self.mapper_klass, self.reducer_klass = [nil, ReassembleObjectReducer]
-      else
-        raise "Please run me with a --phase= option"
-      end
-      super mapper_klass, reducer_klass
-    end
-
-    def default_options
-      extra_options =
-        case self.phase
-        # partition on [rsrc, attr]; sort on [rsrc, attr, val]
-        when 1  then { :sort_fields => 3, :partition_fields => 2 }
-        # sort on [rsrc, id]
-        when 3  then { :sort_fields => 2 }
-        else { }
-        end
-      super.merge extra_options
-    end
-  end
-
-  # execute script
-  Script.new.run
-end

data/old/examples/stupidly_simple_filter.rb

@@ -1,40 +0,0 @@
-#!/usr/bin/env ruby
-require 'rubygems'
-require 'wukong/script'
-
-# Run as (local mode)
-#
-#   ./examples/stupidly_simple_filter.rb --run=local input.tsv output.tsv
-#
-# for hadoop mode,
-#
-#   ./examples/stupidly_simple_filter.rb --run=hadoop input.tsv output.tsv
-#
-# For debugging, run
-#
-#   cat input.tsv | ./examples/stupidly_simple_filter.rb --map input.tsv | more
-#
-
-class Mapper < LineStreamer
-  include Filter
-  MATCHER = %r{(ford|mercury|saab|mazda|isuzu)}
-
-  #
-  # A very simple mapper -- looks for a regex match in one field,
-  # and emits the whole record if the field matches
-  #
-  #
-  # Given a series of records like:
-  #
-  #    tweet  123456789   20100102030405     @frank: I'm having a bacon sandwich
-  #    tweet  123456789   20100102030405     @jerry, I'm having your baby
-  #
-  # emits only the lines matching that regex
-  #
-  def emit? line
-    MATCHER.match line
-  end
-end
-
-# Execute the script
-Wukong.run(Mapper)

data/old/examples/word_count.rb

@@ -1,75 +0,0 @@
-#!/usr/bin/env ruby
-require 'rubygems'
-require 'wukong/script'
-
-module WordCount
-  class Mapper < Wukong::Streamer::LineStreamer
-    #
-    # Split a string into its constituent words.
-    #
-    # This is pretty simpleminded:
-    # * downcase the word
-    # * Split at any non-alphanumeric boundary, including '_'
-    # * However, preserve the special cases of 's, 'd or 't at the end of a
-    #   word.
-    #
-    #   tokenize("Ability is a poor man's wealth #johnwoodenquote")
-    #   # => ["ability", "is", "a", "poor", "man's", "wealth", "johnwoodenquote"]
-    #
-    def tokenize str
-      return [] if str.blank?
-      str = str.downcase;
-      # kill off all punctuation except [stuff]'s or [stuff]'t
-      # this includes hyphens (words are split)
-      str = str.
-        gsub(/[^a-zA-Z0-9\']+/, ' ').
-        gsub(/(\w)\'([stdm]|re|ve|ll)\b/, '\1!\2').gsub(/\'/, ' ').gsub(/!/, "'")
-      # Busticate at whitespace
-      words = str.split(/\s+/)
-      words.reject!{|w| w.length < 3 }
-      words
-    end
-
-    #
-    # Emit each word in each line.
-    #
-    def process line
-      tokenize(line).each{|word| yield [word, 1] }
-    end
-  end
-
-  #
-  # You can stack up all the values in a list then sum them at once.
-  #
-  # This isn't good style, as it means the whole list is held in memory
-  #
-  class Reducer1 < Wukong::Streamer::ListReducer
-    def finalize
-      yield [ values.map(&:last).map(&:to_i).inject(0){|x,tot| x+tot }, key ]
-    end
-  end
-
-  #
-  # A bit kinder to your memory manager: accumulate the sum record-by-record:
-  #
-  class Reducer2 < Wukong::Streamer::AccumulatingReducer
-    def start!(*args)      @key_count =  0 end
-    def accumulate(*args)  @key_count += 1 end
-    def finalize
-      yield [ @key_count, key ]
-    end
-  end
-
-  #
-  # ... easiest of all, though: this is common enough that it's already included
-  #
-  require 'wukong/streamer/count_keys'
-  class Reducer3 < Wukong::Streamer::CountKeys
-  end
-end
-
-# Execute the script
-Wukong.run(
-  WordCount::Mapper,
-  WordCount::Reducer2
-  )

data/old/graph/graphviz_builder.rb

@@ -1,580 +0,0 @@
-#!/usr/local/bin/ruby -w
-
-require "enumerator"
-
-##
-# Graph models directed graphs and subgraphs and outputs in graphviz's
-# dot format.
-
-module Hanuman
-
-  class GraphvizBuilder
-    VERSION = "2.5.0" # :nodoc:
-
-    LIGHT_COLORS = %w(gray lightblue lightcyan lightgray lightpink
-                    lightslategray lightsteelblue white)
-
-    # WTF -- can't be %w() because of a bug in rcov
-    BOLD_COLORS = [:black, :brown, :mediumblue, :blueviolet,
-      :orange, :magenta, :darkgreen, :maroon,
-      :violetred, :purple, :greenyellow, :deeppink,
-      :midnightblue, :firebrick, :darkturquoise,
-      :mediumspringgreen, :chartreuse, :navy,
-      :lightseagreen, :chocolate, :lawngreen, :green,
-      :indigo, :darkgoldenrod, :darkviolet, :red,
-      :springgreen, :saddlebrown, :mediumvioletred,
-      :goldenrod, :tomato, :cyan, :forestgreen,
-      :darkorchid, :crimson, :coral, :deepskyblue,
-      :seagreen, :peru, :turquoise, :orangered,
-      :dodgerblue, :sienna, :limegreen, :royalblue,
-      :darkorange, :blue]
-
-    ##
-    # Defines the brewer color schemes and the maximum number of colors
-    # in each set.
-
-    COLOR_SCHEME_MAX = {
-      :accent   => 8,  :blues    => 9,  :brbg     => 11, :bugn     => 9,
-      :dark2    => 8,  :gnbu     => 9,  :greens   => 9,  :greys    => 9,
-      :oranges  => 9,  :orrd     => 9,  :paired   => 12, :pastel1  => 9,
-      :pastel2  => 8,  :piyg     => 11, :prgn     => 11, :pubu     => 9,
-      :pubugn   => 9,  :puor     => 11, :purd     => 9,  :purples  => 9,
-      :rdbu     => 11, :rdgy     => 11, :rdylbu   => 11, :rdylgn   => 11,
-      :reds     => 9,  :set1     => 9,  :set2     => 8,  :set3     => 12,
-      :spectral => 11, :ylgn     => 9,  :ylgnbu   => 9,  :ylorbr   => 9,
-      :ylorrd   => 9
-    }
-
-    SHAPES = %w[
-      Mcircle Mdiamond Msquare box box3d circle component
-      diamond doublecircle doubleoctagon egg ellipse folder
-      hexagon house invhouse invtrapezium invtriangle none
-      note octagon parallelogram pentagon plaintext point
-      polygon rect rectangle septagon square tab trapezium
-      triangle tripleoctagon
-    ].map(&:to_sym)
-
-    STYLES = %w(dashed dotted solid invis bold filled diagonals rounded).map(&:to_sym)
-
-    ARROW_RE = /(?:o?[lr]?(?:box|crow|diamond|dot|inv|none|normal|tee|vee)){1,4}/
-
-    ARROWS = %w(box crow diamond dot inv none normal tee vee).map(&:to_sym)
-
-    STYLES.each do |name|
-      define_method(name) { style name }
-    end
-
-    (BOLD_COLORS + LIGHT_COLORS).each do |name|
-      define_method(name) { color name }
-    end
-
-    SHAPES.each do |name|
-      method_name = name.downcase.to_s.sub(/none/, 'shape_none')
-      define_method(method_name) { shape name }
-    end
-
-    ARROWS.each do |name|
-      method_name = {
-        :none    => "none_arrow",
-        :box     => "box_arrow",
-        :diamond => "diamond_arrow",
-      }[name] || name
-
-      define_method(method_name) { arrowhead name }
-    end
-
-    ENGINES = %w[ circo dot fdp neato osage sfdp twopi ].map(&:to_sym)
-
-    ##
-    # A parent graph, if any. Only used for subgraphs.
-
-    attr_accessor :graph
-
-    ##
-    # The name of the graph. Optional for graphs and subgraphs. Prefix
-    # the name of a subgraph with "cluster" for subgraph that is boxed.
-
-    attr_accessor :name
-
-    ##
-    # Global attributes for edges in this graph.
-
-    attr_reader :edge_attribs
-
-    ##
-    # The hash of hashes of edges in this graph. Use #[] or #node to create edges.
-
-    attr_reader :edges
-
-    ##
-    # Global attributes for this graph.
-
-    attr_reader :graph_attribs
-
-    ##
-    # Global attributes for nodes in this graph.
-
-    attr_reader :node_attribs
-
-    ##
-    # The hash of nodes in this graph. Use #[] or #node to create nodes.
-
-    attr_reader :nodes
-
-    ##
-    # An array of subgraphs.
-
-    attr_reader :subgraphs
-
-    ##
-    # Creates a new graph object. Optional name and parent graph are
-    # available. Also takes an optional block for DSL-like use.
-
-    def initialize name = nil, graph = nil, &block
-      @name  = name.to_sym
-      @graph = graph
-      graph << self if graph
-      @nodes  = Hash.new { |h,k| h[k] = Node.new self, k }
-      @edges  = Hash.new { |h,k|
-        h[k] = Hash.new { |h2, k2| h2[k2] = Edge.new self, self[k], self[k2] }
-      }
-      @graph_attribs = []
-      @node_attribs  = []
-      @edge_attribs  = []
-      @subgraphs     = []
-
-      engine(:dot)
-
-      self.scheme = graph.scheme if graph
-      node_attribs << scheme if scheme
-      configurate(&block) if block
-    end
-
-    def depth
-      graph.nil? ? 0 : graph.depth + 1
-    end
-
-    def configurate(&block)
-      (block.arity == 0) ? instance_eval(&block) : block.call(self)
-      self
-    end
-
-    def engine(engine_name=nil)
-      return @engine unless engine_name
-      raise ArgumentError, "Don't have engine #{engine_name} listed -- should be one of #{ENGINES}" unless ENGINES.include?(engine_name.to_sym)
-      @engine = engine_name
-    end
-
-    ##
-    # Push a subgraph into the current graph. Sets the subgraph's graph to self.
-
-    def << subgraph
-      subgraphs << subgraph
-      subgraph.graph = self
-    end
-
-    ##
-    # Access a node by name
-
-    def [] name
-      nodes[name]
-    end
-
-    def arrowhead shape
-      raise ArgumentError, "Bad arrow shape: #{shape}" unless shape =~ ARROW_RE
-      Attribute.new "arrowhead = #{shape}"
-    end
-
-    def arrowtail shape
-      raise ArgumentError, "Bad arrow shape: #{shape}" unless shape =~ ARROW_RE
-      Attribute.new "arrowtail = #{shape}"
-    end
-
-    def arrowsize size
-      Attribute.new "arrowsize = #{size}"
-    end
-
-    ##
-    # A convenience method to set the global node attributes to use boxes.
-
-    def boxes
-      node_attribs << shape(:box)
-    end
-
-    ##
-    # Shortcut method to create a new color Attribute instance.
-
-    def color color
-      Attribute.new "color = #{color}"
-    end
-
-    ##
-    # Shortcut method to create a new colorscheme Attribute instance. If
-    # passed +n+, +name+ must match one of the brewer color scheme names
-    # and it will generate accessors for each fillcolor as well as push
-    # the colorscheme onto the node_attribs.
-
-    attr_accessor :scheme
-
-    def colorscheme name, n = nil
-      self.scheme = Attribute.new "colorscheme = #{name}#{n}"
-      max = COLOR_SCHEME_MAX[name.to_sym]
-
-      node_attribs << scheme if max
-
-      scheme
-    end
-
-    (1..COLOR_SCHEME_MAX.values.max).map { |m|
-      define_method "c#{m}" do
-        GraphvizBuilder::Attribute.new("fillcolor = #{m}")
-      end
-    }
-
-    ##
-    # Define one or more edges.
-    #
-    #   edge :a, :b, :c, ...
-    #
-    # is equivalent to:
-    #
-    #   edge :a, :b
-    #   edge :b, :c
-    #   ...
-
-    def edge(*names)
-      last = nil
-      names.each_cons(2) do |from, to|
-        last = self[from][to]
-      end
-      last
-    end
-
-    ##
-    # Creates a new Graph whose edges point the other direction.
-
-    def invert(new_name=nil)
-      result = self.class.new(new_name || "#{name}_inverted")
-      edges.each do |from, h|
-        h.each do |to, edge|
-          result[to][from]
-        end
-      end
-      result
-    end
-
-    ##
-    # Shortcut method to create a new fillcolor Attribute instance.
-
-    def fillcolor n
-      Attribute.new "fillcolor = #{n}"
-    end
-
-    ##
-    # Shortcut method to create a new font Attribute instance. You can
-    # pass in both the name and an optional font size.
-
-    def font name
-      Attribute.new "fontname = #{name.inspect}"
-    end
-
-    def fontsize size
-      Attribute.new "fontsize = #{size}"
-    end
-
-    ##
-    # Shortcut method to set the graph's label. Usually used with subgraphs.
-
-    def label name
-      graph_attribs << %Q{label = "#{name.to_s.gsub(/\n/, '\n')}"} # ""
-    end
-
-    ##
-    # Access a node by name, supplying an optional label
-
-    def node name, label = nil
-      n = nodes[name]
-      n.label label if label
-      n
-    end
-
-    ##
-    # Shortcut method to specify the orientation of the graph. Defaults
-    # to the graphviz default "TB".
-
-    def orient dir = :TB
-      graph_attribs << "rankdir = #{dir}"
-    end
-
-    ##
-    # Shortcut method to specify the orientation of the graph. Defaults to :LR.
-
-    def rotate dir = :LR
-      orient dir
-    end
-
-    ##
-    # Saves out both a dot file to path and an image for the specified type.
-    # Specify type as nil to skip exporting an image.
-
-    def save(path, type=nil)
-      File.open "#{path}.dot", "w" do |f|
-        f.puts self.to_s
-      end
-      system "#{engine} -T#{type} #{path}.dot > #{path}.#{type}" if type
-    end
-
-    ##
-    # Shortcut method to create a new shape Attribute instance.
-
-    def shape shape
-      Attribute.new "shape = #{shape}"
-    end
-
-    ##
-    # Shortcut method to create a new style Attribute instance.
-
-    def style name
-      Attribute.new "style = #{name}"
-    end
-
-    ##
-    # Shortcut method to create a subgraph in the current graph. Use
-    # with the top-level +digraph+ method in block form for a graph DSL.
-
-    def subgraph name = nil, &block
-      GraphvizBuilder.new name, self, &block
-    end
-
-    ##
-    # Shortcut method to create a clustered subgraph in the current
-    # graph. Use with the top-level +digraph+ method in block form for a
-    # graph DSL.
-
-    def cluster name, &block
-      subgraph "cluster_#{name}", &block
-    end
-
-    ##
-    # Outputs a graphviz graph.
-
-    def to_s
-      result = []
-
-      type = graph ? "subgraph " : "digraph "
-      type << "\"#{name}\"" if name and !name.empty?
-      result << "#{type} {"
-
-      graph_attribs.each do |line|
-        result << "  #{line};"
-      end
-
-      unless node_attribs.empty? then
-        result << "  node [ #{node_attribs.join(", ")} ];"
-      end
-
-      unless edge_attribs.empty? then
-        result << "  edge [ #{edge_attribs.join(", ")} ];"
-      end
-
-      subgraphs.each do |line|
-        result << "  #{line.to_s.rstrip};"
-      end
-
-      nodes.each do |name, node|
-        result << "  #{node.to_s.rstrip};" if graph or node.attributes? or node.orphan?
-      end
-
-      edges.each do |from, deps|
-        deps.each do |to, edge|
-          result << "  #{edge.to_s.rstrip};"
-        end
-      end
-
-      result << "}"
-      result.join "\n#{"  "*self.depth}"
-    end
-
-    ##
-    # An attribute for a graph, node, or edge. Really just a composable
-    # string (via #+) with a convenience method #<< that allows you to
-    # "paint" nodes and edges with this attribute.
-
-    class Attribute < Struct.new :attr
-      ##
-      # "Paint" graphs, nodes, and edges with this attribute.
-      #
-      #   red << node1 << node2 << node3
-      #
-      # is the same as:
-      #
-      #   node1.attributes << red
-      #   node2.attributes << red
-      #   node3.attributes << red
-
-      def << thing
-        thing.attributes << self
-        thing.attributes.uniq!
-        self
-      end
-
-      ##
-      # Returns the attribute in string form.
-
-      alias :to_s :attr
-
-      ##
-      # Compose a new attribute from two existing attributes:
-      #
-      #   bad_nodes = red + filled + diamond
-
-      def + style
-        c = CompoundAttribute.new
-        c.push self
-        c.push style
-        c
-      end
-    end
-
-    class CompoundAttribute < Attribute
-      def initialize attr = []
-        super
-      end
-
-      def push attrib
-        attr.push attrib
-      end
-
-      def << thing
-        attr.each do |subattr|
-          subattr << thing # allows for recursive compound attributes
-        end
-        self
-      end
-
-      def to_s
-        attr.join ", "
-      end
-    end
-
-    class Thingy < Struct.new :graph, :attributes
-      def initialize graph
-        super graph, []
-      end
-
-      def quote(str)
-        %Q{"#{str}"}
-      end
-
-      def pad_with_attributes(text)
-        width = 40 - (2 * graph.depth)
-        if self.attributes? then
-          "%-#{width}s [ %s ]" % [text, attributes.join(',')]
-        else
-          text
-        end
-      end
-
-      def initialize_copy other # :nodoc:
-        super
-        self.attributes = other.attributes.dup
-      end
-
-      ##
-      # Shortcut method to set the label attribute.
-
-      def label name
-        attributes.reject! { |s| s =~ /^label =/ }
-        attributes << "label = \"#{name.to_s.gsub(/\n/, '\n')}\""
-        self
-      end
-
-      ##
-      # Does this thing have attributes?
-
-      def attributes?
-        not self.attributes.empty?
-      end
-    end
-
-    ##
-    # An edge in a graph.
-
-    class Edge < Thingy
-
-      attr_accessor :from, :to, :from_slot, :to_slot
-
-      ##
-      # Create a new edge in +graph+ from +from+ to +to+.
-
-      def initialize graph, from, to, from_slot=nil, to_slot=nil
-        super graph
-        self.from      = from
-        self.to        = to
-        self.from_slot = from_slot
-        self.to_slot   = to_slot
-      end
-
-      ##
-      # Returns the edge in dot syntax.
-
-      def to_s
-        from_name = quote(from.name)
-        to_name   = quote(to.name)
-        fromto = "%-18s -> %s" % [from_name, to_name]
-        pad_with_attributes(fromto)
-      end
-    end
-
-    ##
-    # Nodes in the graph.
-
-    class Node < Thingy
-
-      attr_accessor :name
-
-      def connected?
-        edges = graph.edges
-
-        edges.include?(name) or edges.any? { |from, deps| deps.include? name }
-      end
-
-      def orphan?
-        not connected?
-      end
-
-      ##
-      # Create a new Node. Takes a parent graph and a name.
-
-      def initialize graph, name
-        super graph
-        self.name = name
-      end
-
-      ##
-      # Create a new node with +name+ and an edge between them pointing
-      # from self to the new node.
-
-      def >> name
-        self[name] # creates node and edge
-        self
-      end
-
-      alias :"<<" :">>"
-
-      ##
-      # Returns the edge between self and +dep_name+.
-
-      def [] dep_name
-        graph.edges[name][dep_name]
-      end
-
-      ##
-      # Returns the node in dot syntax.
-
-      def to_s
-        pad_with_attributes(quote(name))
-      end
-    end
-  end
-end