jumoku 0.2.0 → 0.2.1

data/vendor/git/plexus/vendor/priority-queue/test/priority_queue_test.rb

@@ -1,371 +0,0 @@
-#!/usr/bin/ruby
-
-# Priority Queue tests
-
-$:.unshift '../ext/priority_queue/CPriorityQueue'
-$:.unshift '../lib/'
-
-require 'test/unit'
-
-require 'priority_queue/ruby_priority_queue'
-require 'priority_queue/poor_priority_queue'
-begin
-  require 'priority_queue/CPriorityQueue' 
-rescue LoadError
-  require 'CPriorityQueue'
-end
-
-
-module PriorityQueueTest    
-  # Check that the order is maintained
-  def teardown
-    last = @q.min_priority
-    while priority = @q.delete_min_return_priority
-      assert_operator(last, :<=, priority)
-      last = priority
-    end
-  end
-
-  def test_length
-    20.times do | i |
-      assert_equal(i, @q.length)
-      @q[i] = i
-    end
-    10.times do | i |
-      assert_equal(20-i, @q.length)
-      @q.delete_min
-    end
-    10.times do | i |
-      assert_equal(10+i, @q.length)
-      @q[i] = i
-    end
-    @q.delete(5)
-    assert_equal(19, @q.length)
-  end
-
-  def test_merge
-    @q1 = @q.class.new
-    @q2 = @q.class.new
-
-    20.times do | i |
-      @q1[i] = i
-      @q2[i+20] = i+20
-    end
-  end
-
-  # Assure that delete min works
-  def test_delete_min
-    assert_equal(nil, @q.delete_min, "Empty queue should pop nil")
-    @q["n1"] = 0
-    assert_equal(["n1", 0], @q.delete_min)
-    @q["n1"] = 0
-    @q["n2"] = -1
-    assert_equal(["n2", -1], @q.delete_min)
-  end
-
-  def test_delete_min_return_key
-    assert_equal(nil, @q.delete_min_return_key, "Empty queue should pop nil")
-    @q["n1"] = 0
-    assert_equal("n1", @q.delete_min_return_key)
-    @q["n1"] = 0
-    @q["n2"] = -1
-    assert_equal("n2", @q.delete_min_return_key)
-  end
-
-  def test_delete_min_return_priority
-    assert_equal(nil, @q.delete_min_return_priority, "Empty queue should pop nil")
-    @q["n1"] = 0
-    assert_equal(0, @q.delete_min_return_priority)
-    @q["n1"] = 0
-    @q["n2"] = -1
-    assert_equal(-1, @q.delete_min_return_priority)
-  end
-
-  def test_has_key?
-    assert(!@q.has_key?(1))
-    @q[1] = 1
-    assert(@q.has_key?(1))
-  end
-
-  def test_empty?
-    assert_equal(true, @q.empty?, "Empty queue should return true on empty?")
-    @q["node1"] = 10
-    assert_equal(false, @q.empty?, "Filled queue should return false on empty?")
-  end
-
-  def test_push
-    20.times do | i |
-      @q.push i, i+10
-    end
-
-    20.times do | i |
-      @q.push i, i
-    end
-    
-    20.times do | i |
-      assert_equal([i, i], @q.delete_min)
-    end
-
-    assert_equal(nil, @q.delete_min)
-  end
-
-  def test_push_pop
-    20.times do | i |
-      @q.push i, i
-    end
-
-    20.times do | i |
-      assert_equal([i, i], @q.delete_min)
-    end
-
-    assert_equal(nil, @q.delete_min)
-  end
-
-  def test_push_decrease_pop
-    50.times do | i |
-      @q.push i, i
-    end
-
-    10.times do | i |
-      assert_equal([i, i], @q.delete_min)
-    end
-
-    10.times do | i |
-      @q[i+10] = i
-    end
-
-    10.times do | i |
-      assert_equal([i+10, i], @q.delete_min)
-    end
-
-    30.times do | i |
-      assert_equal([i+20, i+20], @q.delete_min)
-    end
-
-    assert_equal(nil, @q.delete_min)
-  end
-
-  def test_min_key
-    assert_equal(nil, @q.min_key)
-    @q["node1"] = 0
-    assert_equal("node1", @q.min_key)
-    @q["node2"] = 1
-    assert_equal("node1", @q.min_key)
-    @q["node3"] = -1
-    assert_equal("node3", @q.min_key)
-  end
-
-  def test_min_priority
-    assert_equal(nil, @q.min_priority)
-    @q["node1"] = 0
-    assert_equal(0, @q.min_priority)
-    @q["node2"] = 1
-    assert_equal(0, @q.min_priority)
-    @q["node3"] = -1
-    assert_equal(-1, @q.min_priority)
-  end
-
-  def test_access
-    assert_equal(0, @q["node1"] = 0)
-    assert_equal(["node1", 0], @q.min)
-    assert_equal(1, @q["node2"] = 1)
-    assert_equal(1, @q["node2"])
-    assert_equal("node1", @q.min_key)
-    assert_equal(2, @q["node3"] = 2)
-    assert_equal(2, @q["node3"])
-    assert_equal("node1", @q.min_key)
-    assert_equal(-1, @q["node3"] = -1)
-    assert_equal(-1, @q["node3"])
-    assert_equal("node3", @q.min_key)
-  end
-
-  def test_min
-    assert_equal(nil, @q.min)
-    @q["node1"] = 10
-    assert_equal(["node1", 10], @q.min)
-    @q["node2"] = 5
-    assert_equal(["node2", 5], @q.min)
-  end
-
-  def test_decrease_priority
-
-    20.times do | i |
-      @q.push i, i / 20.0
-    end
-
-    assert_equal([0, 0], @q.delete_min)
-
-    @q[10] = -1
-    @q[11] = -0.5
-
-    [10, 11, (1..9).to_a, (12..19).to_a, nil].flatten.each do | shall |
-      key, priority = *@q.delete_min
-      assert_equal(shall, key)
-    end
-  end
-
-  def test_increase_priority
-    20.times do | i |
-      @q[i] = i
-    end
-    @q[10] = 5
-    assert_equal([0,0], @q.delete_min)
-    assert_equal(10, @q[10] = 10)
-    assert_equal(20, @q[11] = 20)
-    assert_equal([1,1], @q.delete_min)
-  end
-
-  def test_delete
-    @q[1] = 1
-    @q[2] = 2
-    @q[3] = 3
-    assert_equal(1, @q[1])
-    assert_equal([1,1], @q.min)
-    assert_equal([1,1], @q.delete(1))
-    assert_equal(nil, @q[1])
-    assert_equal([2,2], @q.min)
-    assert_equal(nil, @q.delete(1))
-  end
-
-  def test_example_1
-    assert_equal(0, @q["node1"] = 0)
-    assert_equal(1, @q["node2"] = 1)
-    assert_equal("node1", @q.min_key)
-    assert_equal(0, @q[@q.min_key])
-    assert_equal(0, @q.min_priority)
-
-    @q["node2"] = -1
-    assert_equal(["node2", -1], @q.delete_min)
-    assert_equal(nil, @q["node2"])
-    @q["node3"] = 1
-
-    assert_equal(["node3", 1], @q.delete("node3"))
-    assert_equal(nil, @q.delete("node2"))
-  end
-
-  def test_dup
-    ('a'..'z').each do | n |
-      @q[n] = n[0]
-    end
-    qq = @q.dup
-    until @q.empty?
-      assert_equal(@q.delete_min, qq.delete_min)
-    end
-  end
-
-  def test_each
-    ('a'..'z').each do | n |
-      @q[n] = n[0]
-    end
-    queue = ('a'..'z').inject([]) { | r, n | r << [n, n[0]] }
-    assert_equal(queue.sort, @q.to_a.sort)
-  end
-
-  extend self
-end
-
-class CPriorityQueueTest < Test::Unit::TestCase
-  include PriorityQueueTest
-
-  def setup
-    @q = CPriorityQueue.new
-  end
-
-  def test_to_dot    
-    5.times do | i |
-      @q.push "N#{i}", i
-    end
-    @q.delete_min
-    assert_equal(
-    ['digraph fibonacci_heap {',
-    '  NODE [label="N1 (1)",shape=box];',
-    '    NODE [label="N3 (3)",shape=box];',
-    '      NODE [label="N4 (4)",shape=box];',
-    '    NODE -> NODE;',
-    '  NODE -> NODE;',
-    '    NODE [label="N2 (2)",shape=box];',
-    '  NODE -> NODE;',
-    '}',''].join("\n"),  @q.to_dot.gsub(/NODE[0-9]*/, 'NODE'))
-  end
-
-end
-
-class PoorPriorityQueueTest < Test::Unit::TestCase
-  include PriorityQueueTest
-
-  def setup
-    @q = PoorPriorityQueue.new
-  end
-
-end
-
-class RubyPriorityQueueTest < Test::Unit::TestCase
-  include PriorityQueueTest
-
-  def setup
-    @q = RubyPriorityQueue.new
-  end
-
-  def test_private_link_nodes
-    q = RubyPriorityQueue.new
-    q[0] = 0
-    q[1] = 1
-    tc = self
-    q.instance_eval do
-      n0 = @nodes[0]
-      n1 = @nodes[1]
-      n0.right = n0.left = n0
-      n1.right = n1.left = n1
-      tc.assert_equal(n0, link_nodes(n0, n1))
-      tc.assert_equal(n0.child, n1)
-      tc.assert_equal(n1.child, nil)
-      tc.assert_equal(n0.left, n0)
-      tc.assert_equal(n1.left, n1)
-      tc.assert_equal(n0.right, n0)
-      tc.assert_equal(n1.right, n1)
-    end
-    q = RubyPriorityQueue.new
-    q[0] = 0
-    q[1] = 1
-    q.instance_eval do
-      n0 = @nodes[0]
-      n1 = @nodes[1]
-      n0.right = n0.left = n0
-      n1.right = n1.left = n1
-      tc.assert_equal(n0, link_nodes(n1, n0))
-      tc.assert_equal(n0.child, n1)
-      tc.assert_equal(n1.child, nil)
-      tc.assert_equal(n0.left, n0)
-      tc.assert_equal(n1.left, n1)
-      tc.assert_equal(n0.right, n0)
-      tc.assert_equal(n1.right, n1)
-    end
-  end
-
-
-  def test_private_delete_first
-    q = RubyPriorityQueue.new
-    q[0] = 0
-    q[1] = 1
-    q[2] = 2
-    tc = self
-    q.instance_eval do
-      2.times do
-	r = @rootlist
-	tc.assert_equal(r, delete_first)
-	tc.assert_equal(r.right, r)
-	tc.assert_equal(r.left, r)
-	tc.assert_not_equal(r, @rootlist.left)
-	tc.assert_not_equal(r, @rootlist.right)
-      end
-      r = @rootlist
-      tc.assert_equal(r, delete_first)
-      tc.assert_equal(r.right, r)
-      tc.assert_equal(r.left, r)
-      tc.assert_equal(nil, @rootlist)
-
-      tc.assert_equal(nil, delete_first)
-    end
-  end
-end
-

data/vendor/git/plexus/vendor/rdot.rb

@@ -1,360 +0,0 @@
-#--
-# Copyright (c) 2007 Shawn Garbett (minor changes)
-# Copyright (c) 2005 wsdng
-# 
-# Redistribution and use in source and binary forms, with or without modification,
-# are permitted provided that the following conditions are met:
-# 
-#     * Redistributions of source code must retain the above copyright notice(s),
-#       this list of conditions and the following disclaimer.
-#     * Redistributions in binary form must reproduce the above copyright notice,
-#       this list of conditions and the following disclaimer in the documentation
-#       and/or other materials provided with the distribution.
-#     * Neither the name of the Shawn Garbett nor the names of its contributors
-#       may be used to endorse or promote products derived from this software
-#       without specific prior written permission.
-# 
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
-# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-#++
-
-# rdot.rb
-# 
-# $Id: rdot.rb,v 1.4 2005/03/26 15:06:36 wsdng Exp $
-#
-# This is a modified version of dot.rb from Dave Thomas's rdoc project.  I [Horst Duchene]
-# renamed it to rdot.rb to avoid collision with an installed rdoc/dot.
-#
-# It also supports undirected edges.
-
-class Hash
-  def stringify_keys
-    inject({}) {|options, (key, value)| options[key.to_s] = value; options}
-  end
-end unless Hash.respond_to? :stringify_keys
-
-module DOT
-    
-  # These glogal vars are used to make nice graph source.
-
-  $tab  = '    '
-  $tab2 = $tab * 2
-    
-  # if we don't like 4 spaces, we can change it any time
-
-  def change_tab (t)
-    $tab  = t
-    $tab2 = t * 2
-  end
-    
-  # options for node declaration
-
-  NODE_OPTS = [
-    # attributes due to
-    # http://www.graphviz.org/Documentation/dotguide.pdf
-    # March, 26, 2005
-    'bottomlabel', # auxiliary label for nodes of shape M*
-    'color', # default: black; node shape color
-    'comment', # any string (format-dependent)
-    'distortion', # default: 0.0; node distortion for shape=polygon
-    'fillcolor', # default: lightgrey/black; node fill color
-    'fixedsize', # default: false; label text has no affect on node size
-    'fontcolor', # default: black; type face color
-    'fontname', # default: Times-Roman; font family
-    'fontsize', #default: 14; point size of label
-    'group', # name of node�s group
-    'height', # default: .5; height in inches
-    'label', # default: node name; any string
-    'layer', # default: overlay range; all, id or id:id
-    'orientation', # dafault: 0.0; node rotation angle
-    'peripheries', # shape-dependent number of node boundaries
-    'regular', # default:  false; force polygon to be regular
-    'shape', # default: ellipse; node shape; see Section 2.1 and Appendix E
-    'shapefile', # external EPSF or SVG custom shape file
-    'sides', # default: 4; number of sides for shape=polygon
-    'skew' , # default: 0.0; skewing of node for shape=polygon
-    'style', # graphics options, e.g. bold, dotted, filled; cf. Section 2.3
-    'toplabel', # auxiliary label for nodes of shape M*
-    'URL', # URL associated with node (format-dependent)
-    'width', # default: .75; width in inches
-    'z', #default: 0.0; z coordinate for VRML output
-
-    # maintained for backward compatibility or rdot internal
-    'bgcolor',
-    'rank'
-  ]
-    
-  # options for edge declaration
-
-  EDGE_OPTS = [
-    'arrowhead', # default: normal; style of arrowhead at head end
-    'arrowsize', # default: 1.0; scaling factor for arrowheads
-    'arrowtail', # default: normal; style of arrowhead at tail end
-    'color', # default: black; edge stroke color
-    'comment', # any string (format-dependent)
-    'constraint', # default: true use edge to affect node ranking
-    'decorate', # if set, draws a line connecting labels with their edges
-    'dir', # default: forward; forward, back, both, or none
-    'fontcolor', # default: black type face color
-    'fontname', # default: Times-Roman; font family
-    'fontsize', # default: 14; point size of label
-    'headlabel', # label placed near head of edge
-    'headport', # n,ne,e,se,s,sw,w,nw
-    'headURL', # URL attached to head label if output format is ismap
-    'label', # edge label
-    'labelangle', # default: -25.0; angle in degrees which head or tail label is rotated off edge
-    'labeldistance', # default: 1.0; scaling factor for distance of head or tail label from node
-    'labelfloat', # default: false; lessen constraints on edge label placement
-    'labelfontcolor', # default: black; type face color for head and tail labels
-    'labelfontname', # default: Times-Roman; font family for head and tail labels
-    'labelfontsize', # default: 14 point size for head and tail labels
-    'layer', # default: overlay range; all, id or id:id
-    'lhead', # name of cluster to use as head of edge
-    'ltail', # name of cluster to use as tail of edge
-    'minlen', # default: 1 minimum rank distance between head and tail
-    'samehead', # tag for head node; edge heads with the same tag are merged onto the same port
-    'sametail', # tag for tail node; edge tails with the same tag are merged onto the same port
-    'style', # graphics options, e.g. bold, dotted, filled; cf. Section 2.3
-    'taillabel', # label placed near tail of edge
-    'tailport', # n,ne,e,se,s,sw,w,nw
-    'tailURL', # URL attached to tail label if output format is ismap
-    'weight', # default: 1; integer cost of stretching an edge
-
-    # maintained for backward compatibility or rdot internal
-    'id'
-  ]
-    
-  # options for graph declaration
-
-  GRAPH_OPTS = [
-    'bgcolor',
-    'center', 'clusterrank', 'color', 'concentrate',
-    'fontcolor', 'fontname', 'fontsize',
-    'label', 'layerseq',
-    'margin', 'mclimit',
-    'nodesep', 'nslimit',
-    'ordering', 'orientation',
-    'page',
-    'rank', 'rankdir', 'ranksep', 'ratio',
-    'size'
-  ]
-    
-  # a root class for any element in dot notation
-
-  class DOTSimpleElement
-
-    attr_accessor :name
-
-    def initialize (params = {})
-      @label = params['name'] ? params['name'] : ''
-    end
-
-    def to_s
-      @name
-    end
-  end
-    
-  # an element that has options ( node, edge, or graph )
-
-  class DOTElement < DOTSimpleElement
-
-    # attr_reader :parent
-    attr_accessor :name, :options
-
-    def initialize (params = {}, option_list = [])
-      super(params)
-      @name   = params['name']   ? params['name']   : nil 
-      @parent = params['parent'] ? params['parent'] : nil
-      @options = {}
-      p = params.stringify_keys
-      option_list.each {|i| @options[i] = p[i] if p[i] }
-      @options['label'] ||= @name if @name != 'node'
-    end
-        
-    def each_option
-      @options.each{ |i| yield i }
-    end
-
-    def each_option_pair
-      @options.each_pair{ |key, val| yield key, val }
-    end
-
-    #def parent=( thing )
-    #    @parent.delete( self ) if defined?( @parent ) and @parent
-    #    @parent = thing
-    #end
-
-  end
-    
-    
-  # This is used when we build nodes that have shape=record
-  # ports don't have options :)
-
-  class DOTPort < DOTSimpleElement
-
-    attr_accessor :label
-        
-    def initialize (params = {})
-      super(params)
-      @name = params['label'] ? params['label'] : ''
-    end
-
-    def to_s
-      ( @name && @name != "" ? "<#{@name}>" : "" ) + "#{@label}"
-    end
-  end
-    
-  # node element
-
-  class DOTNode < DOTElement
-
-    @ports
-
-    def initialize (params = {}, option_list = NODE_OPTS)
-      super(params, option_list)
-      @ports = params['ports'] ? params['ports'] : []
-    end
-
-    def each_port
-      @ports.each { |i| yield i }
-    end
-
-    def << (thing)
-      @ports << thing
-    end
-
-    def push (thing)
-      @ports.push(thing)
-    end
-
-    def pop
-      @ports.pop
-    end
-
-    def to_s (t = '')
-
-      # This code is totally incomprehensible; it needs to be replaced!
-
-      label = @options['shape'] != 'record' && @ports.length == 0 ?
-                @options['label'] ? 
-                    t + $tab + "label = \"#{@options['label']}\"\n" :
-                    '' :
-                t + $tab + 'label = "' + " \\\n" +
-                t + $tab2 + "#{@options['label']}| \\\n" +
-                @ports.collect{ |i|
-                    t + $tab2 + i.to_s
-                }.join( "| \\\n" ) + " \\\n" +
-                t + $tab + '"' + "\n"
-            
-            t + "#{@name} [\n" +
-            @options.to_a.collect{ |i|
-                i[1] && i[0] != 'label' ? 
-                    t + $tab + "#{i[0]} = #{i[1]}" : nil
-            }.compact.join( ",\n" ) + ( label != '' ? ",\n" : "\n" ) + 
-            label +
-            t + "]\n" 
-      end
-
-  end		# class DOTNode
-
-  # A subgraph element is the same to graph, but has another header in dot
-  # notation.
-
-  class DOTSubgraph < DOTElement
-
-    @nodes
-    @dot_string
-
-    def initialize (params = {}, option_list = GRAPH_OPTS)
-      super(params, option_list)
-      @nodes      = params['nodes'] ? params['nodes'] : []
-      @dot_string = 'subgraph'
-    end
-
-    def each_node
-      @nodes.each{ |i| yield i }
-    end
-
-    def << (thing)
-      @nodes << thing
-    end
-       
-    def push (thing)
-      @nodes.push( thing )
-    end
-
-    def pop
-      @nodes.pop
-    end
-
-    def to_s (t = '')
-      hdr = t + "#{@dot_string} #{@name} {\n"
-
-      options = @options.to_a.collect{ |name, val|
-        val && name != 'label' ? 
-          t + $tab + "#{name} = #{val}" : 
-          name ? t + $tab + "#{name} = \"#{val}\"" : nil
-      }.compact.join( "\n" ) + "\n"
-
-      nodes = @nodes.collect{ |i|
-        i.to_s( t + $tab )
-      }.join( "\n" ) + "\n" 
-      hdr + options + nodes + t + "}\n"
-    end
-
-  end		# class DOTSubgraph
-
-  # This is a graph.
-
-  class DOTDigraph < DOTSubgraph
-
-    def initialize (params = {}, option_list = GRAPH_OPTS)
-      super(params, option_list)
-      @dot_string = 'digraph'
-    end
-
-  end		# class DOTDigraph
-
-  # This is an edge.
-
-  class DOTArc < DOTElement
-
-    attr_accessor :from, :to
-
-    def initialize (params = {}, option_list = EDGE_OPTS)
-      super(params, option_list)
-      @from = params['from'] ? params['from'] : nil
-      @to   = params['to'] ? params['to'] : nil
-    end
-       
-    def edge_link
-      '--'
-    end
-
-    def to_s (t = '')
-      t + "#{@from} #{edge_link} #{to} [\n" +
-          @options.to_a.collect{ |i|
-            i[1] && i[0] != 'label' ? 
-              t + $tab + "#{i[0]} = #{i[1]}" : 
-              i[1] ? t + $tab + "#{i[0]} = \"#{i[1]}\"" : nil
-          }.compact.join( "\n" ) + "\n" + t + "]\n"
-    end
-
-  end		# class DOTArc
-          
-  class DOTDirectedArc < DOTArc
-
-    def edge_link
-      '->'
-    end
-
-  end                           # class DOTDirectedArc
-end                             # module DOT