jumoku 0.1.1 → 0.1.2

data/vendor/git/graphy/CREDITS.md

@@ -0,0 +1,31 @@
+Credits
+=======
+
+From GRATR
+----------
+
+Shawn Garbett provided the following credits in GRATR:
+
+Many thanks to Robert Feldt which also worked on a graph library
+(http://rockit.sf.net/subprojects/graphr) who pointed me to BGL and many other
+graph resources. Manuel Simoni found a subtle bug in a preliminary version
+announced at http://rubygarden.com/ruby?RubyAlgorithmPackage/Graph.
+
+Robert kindly allowed to integrate his work on graphr, which I did not yet
+succeed. Especially his work to output graphs for
+GraphViz[http://www.research.att.com/sw/tools/graphviz/download.html] is much
+more elaborated than the minimal support in dot.rb.
+
+Jeremy Siek one of the authors of the nice book "The Boost Graph Library (BGL)"
+(http://www.boost.org/libs/graph/doc) kindly allowed to use the
+BGL documentation as a _cheap_ reference for GRATR. He and Robert also gave
+feedback and many ideas for GRATR.
+
+Dave Thomas for RDoc[http://rdoc.sourceforge.net] which generated what you read
+and Matz for Ruby. Dave included in the latest version of RDoc (alpha9) the
+module dot/dot.rb which I use instead of Roberts module to visualize graphs
+(see gratr/dot.rb).
+
+Horst Duchene for RGL which provided the basis for this library and his vision.
+
+Rick Bradley who reworked the library and added many graph theoretic constructs.

data/vendor/git/graphy/LICENSE

@@ -0,0 +1,35 @@
+Copyright (c) 2009 Bruce Williams
+
+Copyright (c) 2007,2006 Shawn Patrick Garbett
+
+Copyright (c) 2002,2004,2005 by Horst Duchene
+
+Copyright (c) 2000,2001  Jeremy Siek, Indiana University (jsiek@osl.iu.edu) 
+
+All rights reserved.
+
+Jeremy Siek was one of the principal developers of the Boost Graph library.
+Since this work is derivative, his name is included in the copyright list.
+
+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 Bruce Williams 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.

data/vendor/git/graphy/README.md

@@ -0,0 +1,186 @@
+# Graphy. A framework for graph theory, graph data structures and associated algorithms.
+
+Graph algorithms currently provided are:
+
+* Topological Sort
+* Strongly Connected Components 
+* Transitive Closure
+* Rural Chinese Postman
+* Biconnected
+
+These are based on more general algorithm patterns:
+
+* Breadth First Search 
+* Depth First Search 
+* A* Search
+* Floyd-Warshall
+* Best First Search
+* Djikstra's Algorithm
+* Lexicographic Search
+
+## A quick Tour
+
+### Arcs
+
+There are two vertices bound classes, `Graphy::Arc` and `Graphy::Edge`. The
+former defines directional edges, the latter undirected edges.
+
+### Vertices
+
+Vertices can be any `Object`.
+
+### Graph Types
+
+There are a number of different graph types, each of which provide
+different features and constraints:
+
+`Graphy::Digraph` and its alias `Graphy::DirectedGraph`:
+
+* Single directed edges (arcs) between vertices
+* Loops are forbidden
+
+`Graphy::DirectedPseudoGraph`:
+
+* Multiple directed edges (arcs) between vertices
+* Loops are forbidden
+
+`Graphy::DirectedMultiGraph`:
+
+* Multiple directed edges (arcs) between vertices
+* Loops on vertices
+
+`Graphy::UndirectedGraph`, `Graphy::UndirectedPseudoGraph`, and
+`Graph::UndirectedMultiGraph` are similar but all edges are undirected.
+
+### Data Structures
+
+In order to modelize data structures, make use of the `Graphy::AdjacencyGraph`
+module which provides a generalized adjacency list and an edge list adaptor.
+
+The `Graphy::Digraph` class is the general purpose "swiss army knife" of graph
+classes, most of the other classes are just modifications to this class.
+It is optimized for efficient access to just the out-edges, fast vertex
+insertion and removal at the cost of extra space overhead, etc.
+
+## Example Usage
+
+Using IRB, first require the library:
+
+    require 'rubygems' # only if you are using ruby 1.8.x
+    require 'graphy'
+
+If you'd like to include all the classes in the current scope (so you
+don't have to prefix with `Graphy::`), just:
+
+    include Graphy
+
+Let's play with the library a bit in IRB:
+
+    >> dg = Digraph[1,2, 2,3, 2,4, 4,5, 6,4, 1,6]
+    => Graphy::Digraph[[2, 3], [1, 6], [2, 4], [4, 5], [1, 2], [6, 4]] 
+
+A few properties of the graph we just created:
+
+    >> dg.directed?
+    => true
+    >> dg.vertex?(4)
+    => true
+    >> dg.edge?(2,4)
+    => true
+    >> dg.edge?(4,2)
+    => false
+    >> dg.vertices
+    => [1, 2, 3, 4, 5, 6]
+
+Every object could be a vertex, even the class object `Object`:
+
+    >> dg.vertex?(Object)
+    => false
+
+    >> UndirectedGraph.new(dg).edges.sort.to_s
+    => "[Graphy::Edge[1,2,nil], Graphy::Edge[2,3,nil], Graphy::Edge[2,4,nil],
+         Graphy::Edge[4,5,nil], Graphy::Edge[1,6,nil], Graphy::Edge[6,4,nil]]"
+
+Add inverse edge `(4-2)` to directed graph:
+
+    >> dg.add_edge!(4,2)
+    => Graphy::DirectedGraph[Graphy::Arc[1,2,nil], Graphy::Arc[1,6,nil], Graphy::Arc[2,3,nil],
+                             Graphy::Arc[2,4,nil], Graphy::Arc[4,5,nil], Graphy::Arc[4,2,nil],
+                             Graphy::Arc[6,4,nil]]
+
+`(4-2) == (2-4)` in the undirected graph (4-2 doesn't show up):
+
+    >> UndirectedGraph.new(dg).edges.sort.to_s
+    => "[Graphy::Edge[1,2,nil], Graphy::Edge[2,3,nil], Graphy::Edge[2,4,nil],
+         Graphy::Edge[4,5,nil], Graphy::Edge[1,6,nil], Graphy::Edge[6,4,nil]]"
+
+`(4-2) != (2-4)` in directed graphs (both show up):
+
+    >> dg.edges.sort.to_s
+    => "[Graphy::Arc[1,2,nil], Graphy::Arc[1,6,nil], Graphy::Arc[2,3,nil],
+         Graphy::Arc[2,4,nil], Graphy::Arc[4,2,nil], Graphy::Arc[4,5,nil],
+         Graphy::Arc[6,4,nil]]"
+
+    >> dg.remove_edge! 4,2
+    => Graphy::DirectedGraph[Graphy::Arc[1,2,nil], Graphy::Arc[1,6,nil], Graphy::Arc[2,3,nil],
+                             Graphy::Arc[2,4,nil], Graphy::Arc[4,5,nil], Graphy::Arc[6,4,nil]]
+
+Topological sorting is realized with an iterator:
+
+    >> dg.topsort         
+    => [1, 6, 2, 4, 5, 3]
+    >> y = 0; dg.topsort { |v| y += v }; y
+    => 21
+
+You can use DOT to visualize the graph:
+
+    >> require 'graphy/dot'
+    >> dg.write_to_graphic_file('jpg','visualize')
+
+Here's an example showing the module inheritance hierarchy:
+
+    >> module_graph = Digraph.new
+    >> ObjectSpace.each_object(Module) do |m|
+    >>   m.ancestors.each {|a| module_graph.add_edge!(m,a) if m != a} 
+    >> end
+    >> gv = module_graph.vertices.select {|v| v.to_s.match(/Graphy/) }
+    >> module_graph.induced_subgraph(gv).write_to_graphic_file('jpg','module_graph')
+
+Look for more in the examples directory.
+ 
+## History
+
+This library is based on [GRATR][1] by Shawn Garbett (itself a fork of
+Horst Duchene's [RGL][2] library) which is heavily influenced by the [Boost][3]
+Graph Library (BGL).
+
+This fork attempts to modernize and extend the API and tests.
+
+## References
+
+For more information on Graph Theory, you may want to read:
+
+* the [documentation][3] for the Boost Graph Library
+* [the Dictionary of Algorithms and Data Structures][4]
+
+## Credits
+
+See CREDITS.markdown
+
+## TODO
+
+See TODO.markdown
+
+## CHANGELOG
+
+See CHANGELOG.markdown
+
+## License
+
+See LICENSE
+
+[1]: http://gratr.rubyforge.org
+[2]: http://rgl.rubyforge.org
+[3]: http://www.boost.org/libs/graph/doc
+[4]: http://www.nist.gov/dads/HTML/graph.html
+

data/vendor/git/graphy/Rakefile

@@ -0,0 +1,61 @@
+require 'rubygems'
+require 'rake'
+require 'yard'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "graphy"
+    gem.summary = "A Graph Theory Ruby library"
+    gem.description =<<-EOD
+A framework for graph data structures and algorithms.
+
+This library is based on GRATR and RGL.
+
+Graph algorithms currently provided are:
+
+* Topological Sort
+* Strongly Connected Components 
+* Transitive Closure
+* Rural Chinese Postman
+* Biconnected
+    EOD
+    gem.email = "bruce@codefluency.com"
+    gem.homepage = "http://github.com/bruce/graphy"
+    gem.authors = ["Bruce Williams"]
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "graphy #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+#require 'spec/rake/spectask'
+#Spec::Rake::SpecTask.new(:spec) do |spec|
+  #spec.libs << 'lib' << 'spec'
+  #spec.spec_files = FileList['spec/**/*_spec.rb']
+#end
+
+#Spec::Rake::SpecTask.new(:rcov) do |spec|
+  #spec.libs << 'lib' << 'spec'
+  #spec.pattern = 'spec/**/*_spec.rb'
+  #spec.rcov = true
+#end
+
+#task :spec => :check_dependencies
+
+#task :default => :spec
+
+YARD::Rake::YardocTask.new do |t|
+  t.files   = ['lib/**/*.rb', 'README.md', 'TODO.md', 'CREDITS.md', 'LICENSE', 'VERSION']
+  #t.options = ['--any', '--extra', '--opts'] # optional
+end

data/vendor/git/graphy/TODO.md

@@ -0,0 +1,20 @@
+# TODO
+
+## From the current Graphy project
+
+* code cleanup: syntax, typo
+* YARD documentation
+* hunt for buggy behaviors
+* a solid helper to check graphy object type in replacement of the current `is_a?` hack
+* have the `[]` class method propagate through nested module inclusions [see this topic](http://www.ruby-forum.com/topic/68638)
+* [Incremental heuristic search algorithms](http://en.wikipedia.org/wiki/Incremental_heuristic_search)?
+
+## From GRATR
+
+The following list was present in GRATR, and items may (or may not) be added to this library:
+
+* Primal Dual for combinatorial optimization problems
+* Min-Max Flow 
+* Near optimal traveling salesman problem
+* Orientation of undirected graphs
+* Undirected graphs from ActiveRecord

data/vendor/git/graphy/VERSION

@@ -0,0 +1 @@
+0.5.2

data/vendor/git/graphy/examples/graph_self.rb

@@ -0,0 +1,56 @@
+#!/usr/bin/ruby -I../lib
+
+require 'gratr'
+require 'gratr/dot'
+
+include GRATR
+
+# This program gives an example of dynamic analysis of a program's call stack,
+# that exports to dot and creates a jpg visualization of the call diagram.
+
+class GraphSelf
+  
+  # Setup some data to call Dijkstra's Algorithm
+  def initialize
+    @d = Digraph[ [:a,:b] => 9, [:a,:e] => 3,
+                  [:b,:c] => 2, [:b,:e] => 6,
+                  [:c,:d] => 1,
+                  [:d,:c] => 2,
+                  [:e,:b] => 2, [:e,:f] => 1,
+                  [:f,:c] => 2, [:f,:d] => 7, [:f,:e] => 2 ]
+
+    @call_stack = []
+    @call_graph = Digraph.new
+  end
+  
+  # Get the call graph variable
+  def call_graph() @call_graph; end
+  
+  # Turn capturing of call graph on
+  def capture_func
+    Proc.new do |event, f, l, id, b, klass|
+      # Only interested in the GRATR library itself
+      if ( klass.to_s =~ /GRATR/ ) 
+        case event.to_s
+          when /call/ 
+            method = "#{klass.to_s.split('::')[1]}.#{id}" # Removes GRATR:: 
+            @call_graph.add_edge!(@call_stack[-1],method) if @call_stack[-1] 
+            @call_stack.push(method)
+          when /return/ : @call_stack.pop
+        end
+      end
+    end
+  end 
+
+  # Run a capture of the call graph for Dijkstra's algorithm  
+  def run
+    set_trace_func capture_func
+    @d.dijkstras_algorithm(:a)
+    set_trace_func nil
+    self
+  end
+   
+end
+
+# Run a capture and generate the resulting jpg file
+GraphSelf.new.run.call_graph.write_to_graphic_file('jpg','self_graph')

data/vendor/git/graphy/examples/module_graph.rb

@@ -0,0 +1,14 @@
+#!/usr/bin/ruby -I../lib
+
+require 'gratr'
+require 'gratr/dot'
+
+include GRATR
+
+module_graph=Digraph.new
+ObjectSpace.each_object(Module) do |m|
+  m.ancestors.each {|a| module_graph.add_edge!(m,a) if m != a} 
+end
+
+gv = module_graph.vertices.select {|v| v.to_s.match(/GRATR/) && v.to_s != 'GRATR'}
+module_graph.induced_subgraph(gv).write_to_graphic_file('jpg','module_graph')

data/vendor/git/graphy/examples/visualize.rb

@@ -0,0 +1,10 @@
+#!/usr/bin/ruby -I../lib
+
+require 'gratr'
+require 'gratr/dot'
+
+import GRATR
+
+dg = Digraph[1,2, 2,3, 2,4, 4,5, 6,4, 1,6]
+
+dg.write_to_graphic_file('jpg','visualize')

data/vendor/git/graphy/graphy.gemspec

@@ -0,0 +1,149 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{graphy}
+  s.version = "0.5.2"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Bruce Williams"]
+  s.date = %q{2010-04-04}
+  s.description = %q{A framework for graph data structures and algorithms.
+
+This library is based on GRATR and RGL.
+
+Graph algorithms currently provided are:
+
+* Topological Sort
+* Strongly Connected Components 
+* Transitive Closure
+* Rural Chinese Postman
+* Biconnected
+}
+  s.email = %q{bruce@codefluency.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.md"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "CREDITS.md",
+     "LICENSE",
+     "README.md",
+     "Rakefile",
+     "TODO.md",
+     "VERSION",
+     "examples/graph_self.rb",
+     "examples/module_graph.jpg",
+     "examples/module_graph.rb",
+     "examples/self_graph.jpg",
+     "examples/visualize.jpg",
+     "examples/visualize.rb",
+     "graphy.gemspec",
+     "lib/graphy.rb",
+     "lib/graphy/adjacency_graph.rb",
+     "lib/graphy/arc.rb",
+     "lib/graphy/arc_number.rb",
+     "lib/graphy/biconnected.rb",
+     "lib/graphy/chinese_postman.rb",
+     "lib/graphy/classes/graph_classes.rb",
+     "lib/graphy/common.rb",
+     "lib/graphy/comparability.rb",
+     "lib/graphy/directed_graph.rb",
+     "lib/graphy/directed_graph/algorithms.rb",
+     "lib/graphy/directed_graph/distance.rb",
+     "lib/graphy/dot.rb",
+     "lib/graphy/edge.rb",
+     "lib/graphy/ext.rb",
+     "lib/graphy/graph.rb",
+     "lib/graphy/graph_api.rb",
+     "lib/graphy/labels.rb",
+     "lib/graphy/maximum_flow.rb",
+     "lib/graphy/ruby_compatibility.rb",
+     "lib/graphy/search.rb",
+     "lib/graphy/strong_components.rb",
+     "lib/graphy/support/support.rb",
+     "lib/graphy/undirected_graph.rb",
+     "lib/graphy/undirected_graph/algorithms.rb",
+     "spec/biconnected_spec.rb",
+     "spec/chinese_postman_spec.rb",
+     "spec/community_spec.rb",
+     "spec/complement_spec.rb",
+     "spec/digraph_distance_spec.rb",
+     "spec/digraph_spec.rb",
+     "spec/dot_spec.rb",
+     "spec/edge_spec.rb",
+     "spec/inspection_spec.rb",
+     "spec/multi_edge_spec.rb",
+     "spec/neighborhood_spec.rb",
+     "spec/properties_spec.rb",
+     "spec/search_spec.rb",
+     "spec/spec.opts",
+     "spec/spec_helper.rb",
+     "spec/strong_components_spec.rb",
+     "spec/triangulated_spec.rb",
+     "spec/undirected_graph_spec.rb",
+     "vendor/priority-queue/CHANGELOG",
+     "vendor/priority-queue/Makefile",
+     "vendor/priority-queue/README",
+     "vendor/priority-queue/benchmark/dijkstra.rb",
+     "vendor/priority-queue/compare_comments.rb",
+     "vendor/priority-queue/doc/c-vs-rb.png",
+     "vendor/priority-queue/doc/compare_big.gp",
+     "vendor/priority-queue/doc/compare_big.png",
+     "vendor/priority-queue/doc/compare_small.gp",
+     "vendor/priority-queue/doc/compare_small.png",
+     "vendor/priority-queue/doc/results.csv",
+     "vendor/priority-queue/ext/priority_queue/CPriorityQueue/extconf.rb",
+     "vendor/priority-queue/ext/priority_queue/CPriorityQueue/priority_queue.c",
+     "vendor/priority-queue/lib/priority_queue.rb",
+     "vendor/priority-queue/lib/priority_queue/c_priority_queue.rb",
+     "vendor/priority-queue/lib/priority_queue/poor_priority_queue.rb",
+     "vendor/priority-queue/lib/priority_queue/ruby_priority_queue.rb",
+     "vendor/priority-queue/priority_queue.so",
+     "vendor/priority-queue/setup.rb",
+     "vendor/priority-queue/test/priority_queue_test.rb",
+     "vendor/rdot.rb"
+  ]
+  s.homepage = %q{http://github.com/bruce/graphy}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{A Graph Theory Ruby library}
+  s.test_files = [
+    "spec/edge_spec.rb",
+     "spec/triangulated_spec.rb",
+     "spec/undirected_graph_spec.rb",
+     "spec/properties_spec.rb",
+     "spec/complement_spec.rb",
+     "spec/search_spec.rb",
+     "spec/digraph_spec.rb",
+     "spec/inspection_spec.rb",
+     "spec/community_spec.rb",
+     "spec/multi_edge_spec.rb",
+     "spec/neighborhood_spec.rb",
+     "spec/biconnected_spec.rb",
+     "spec/spec_helper.rb",
+     "spec/chinese_postman_spec.rb",
+     "spec/dot_spec.rb",
+     "spec/digraph_distance_spec.rb",
+     "spec/strong_components_spec.rb",
+     "examples/visualize.rb",
+     "examples/module_graph.rb",
+     "examples/graph_self.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+