rgl 0.5.1 → 0.5.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d301ca82307bce4dd2de05303de4bc633f92dbf4
+  data.tar.gz: a133f96bc69d3baa7a790674fd9d6e08a8b93d83
+SHA512:
+  metadata.gz: 88d2fcb68bfc33c482cc11d0c82ac8c143ac9d2fcd1f4c287f3392944fc7ca212dd9f93bed4654a243c4ab9d73038d9c3c34dcd84e1521923756e8833e69963d
+  data.tar.gz: ffe9faef0d0e4f77cef5c830a3ef0a86b2fe61bb8ad7e8f62c272c9360d550e24aca23c5aaf392f9f6990cdf1e36e9d631dab7d982ff1c8b89823eecc4c39042

data/ChangeLog

@@ -1,3 +1,16 @@
+2016-05 Release 0.5.2
+
+Horst Duchene <monora@gmail.com>
+ * Issue #21: Use new method vertex_id instead of object_id to identify vertices in dot export. (fa7592)
+ * Integrate Code Climate's test coverage reporting (0ab722)
+ * Clarify traversal order of DFS search (see #20). (afa788)
+Chase Gilliam <chase.gilliam@gmail.com>
+ * drop 1.9.3 add newer jruby and rubinius (fad333)
+Matías Battocchia <matias@riseup.net>
+ * Switched to a different heap implementation. (bd7c13)
+gorn <j@kub.cz>
+ * Adding failing test for issue #24 (1f6204)
+
 2015-12 Release 0.5.1
 
 Horst Duchene <monora@gmail.com>
@@ -21,7 +34,7 @@ Chase <chase.gilliam@gmail.com>
   * updated algorithms to 6.1 and added test unit to support newer rubies (fbd874)
 Louis Rose <louismrose@gmail.com>
   * Fix #15. Use object IDs rather than labels to identify vertexs in DOT graph to ensure that distinct nodes that share a label are shown. (33206f)
-	* Issue #15. Fix tests. (4fc455)
+  * Issue #15. Fix tests. (4fc455)
 
 
 2014-12 Release 0.5.0
@@ -29,13 +42,13 @@ Horst Duchene <monora@gmail.com>
   * Changed edge sequence to match example picture (daa88e)
   * Fixed comment (6a6c93)
   * Fixed spelling (7ca281)
-Horst Duchêne <monora@gmail.com>
 Chase <chase.gilliam@gmail.com>
   * updated algorithms to 6.1 and added test unit to support newer rubies (fbd874)
 Louis Rose <louismrose@gmail.com>
-  * Fix #15. Use object IDs rather than labels to identify vertexs in DOT graph to ensure that distinct nodes that share a label are shown. (33206f)
-	* Issue #15. Fix tests. (4fc455)
-
+  * Fix #15. Use object IDs rather than labels to identify vertexs
+	in DOT graph to ensure that distinct nodes that share a label are
+	shown. (33206f)
+  * Issue #15. Fix tests. (4fc455)
 
 2014-12 Release 0.5.0
 

data/Gemfile

@@ -2,6 +2,4 @@ source 'https://rubygems.org'
 
 gemspec
 
-gem 'rake'
-gem 'yard'
-gem 'asciidoctor'
+gem "codeclimate-test-reporter", group: :test, require: nil

data/README.md

@@ -0,0 +1,252 @@
+# Ruby Graph Library (RGL) [<img src="https://secure.travis-ci.org/monora/rgl.png?branch=master" alt="Build Status" />](https://travis-ci.org/monora/rgl) [<img src="https://codeclimate.com/github/monora/rgl/badges/coverage.svg" />](https://codeclimate.com/github/monora/rgl/coverage)
+
+RGL is a framework for graph data structures and algorithms.
+
+The design of the library is much influenced by the Boost Graph Library (BGL)
+which is written in C++. Refer to http://www.boost.org/libs/graph/doc for
+further links and documentation on graph data structures and algorithms and
+the design rationales of BGL.
+
+A comprehensive summary of graph terminology can be found in the graph section
+of the *Dictionary of Algorithms and Data Structures* at
+http://www.nist.gov/dads/HTML/graph.html or
+[Wikipedia](https://en.wikipedia.org/wiki/Graph_%28discrete_mathematics%29).
+
+## Documentation
+
+*   RGL's [API Reference](http://www.rubydoc.info/github/monora/rgl) at
+    http://rubydoc.info
+
+
+## Design principles
+
+This document concentrates on the special issues of the implementation in
+Ruby. The main design goals directly taken from the BGL design are:
+
+*   An interface for how the structure of a graph can be accessed using a
+    generic interface that hides the details of the graph data structure
+    implementation. This interface is defined by the module {RGL::Graph},
+    which should be included in concrete classes.
+
+*   A standardized generic interface for traversing graphs
+    {RGL::GraphIterator}
+
+
+RGL provides some general purpose graph classes that conform to this
+interface, but they are not meant to be the **only** graph classes. As in BGL
+I believe that the main contribution of the RGL is the formulation of this
+interface.
+
+The BGL graph interface and graph components are generic in the sense of the
+C++ Standard Template Library (STL). In Ruby other techniques are available to
+express the generic character of the algorithms and data structures mainly
+using mixins and iterators. The BGL documentation mentions three means to
+achieve genericity:
+
+*   Algorithm/Data-Structure Interoperability
+*   Extension through Function Objects and Visitors
+*   Element Type Parameterization
+*   Vertex and Edge Property Multi-Parameterization
+
+
+The first is easily achieved in RGL using mixins, which of course is not as
+efficient than C++ templates (but much more readable :-). The second one is
+even more easily implemented using standard iterators with blocks or using the
+[stream](http://www.rubydoc.info/github/monora/stream) module. The third one
+is no issue since Ruby is dynamically typed: Each object can be a graph
+vertex. There is no need for a vertex (or even edge type). In the current
+version of RGL properties of vertices are simply attached using hashes. At
+first there seems to be not much need for the graph property machinery.
+
+### Algorithms
+
+RGL current contains a core set of algorithm patterns:
+
+*   Breadth First Search {RGL::BFSIterator}
+*   Depth First Search {RGL::DFSIterator}
+
+
+The algorithm patterns by themselves do not compute any meaningful quantities
+over graphs, they are merely building blocks for constructing graph
+algorithms. The graph algorithms in RGL currently include:
+
+*   Topological Sort {RGL::TopsortIterator}
+*   Connected Components {RGL::Graph#each_connected_component}
+*   Strongly Connected Components {RGL::Graph#strongly_connected_components}
+*   Transitive Closure {RGL::Graph#transitive_closure}
+*   Dijkstras Shortest Path Algorithm {RGL::DijkstraAlgorithm}
+*   Bellman Ford Algorithm {RGL::BellmanFordAlgorithm}
+
+
+### Data Structures
+
+RGL currently provides two graph classes that implement a generalized
+adjacency list and an edge list adaptor.
+
+*   {RGL::AdjacencyGraph}
+*   {RGL::ImplicitGraph}
+
+
+The AdjacencyGraph class is the general purpose _swiss army knife_ of graph
+classes. It is highly parameterized so that it can be optimized for different
+situations: the graph is directed or undirected, allow or disallow parallel
+edges, efficient access to just the out-edges, fast vertex insertion and
+removal at the cost of extra space overhead, etc.
+
+### Differences to BGL
+
+The concepts of IncidenceGraph, AdjacencyGraph and VertexListGraph (see
+http://www.boost.org/libs/graph/doc/IncidenceGraph.html) are here bundled in
+the base graph module. Most methods of IncidenceGraph should be standard in
+the base module Graph. The complexity guarantees can not necessarily provided.
+ See http://www.boost.org/libs/graph/doc/graph_concepts.html.
+
+## Installation
+
+    % gem install rgl
+
+or download the latest sources from the git repository
+http://github.com/monora/rgl.
+
+## Running tests
+
+Checkout RGL git repository and go to the project directory. First, install
+RGL dependencies with bundler:
+
+    % bundle install
+
+After that you can run the tests:
+
+    % rake test
+
+## Example irb session with RGL
+
+    irb> require 'rgl/adjacency'
+    irb> dg=RGL::DirectedAdjacencyGraph[1,2 ,2,3 ,2,4, 4,5, 6,4, 1,6]
+    # Use DOT to visualize this graph:
+    irb> require 'rgl/dot'
+    irb> dg.write_to_graphic_file('jpg')
+    "graph.jpg"
+
+The result:
+
+![Example](https://github.com/monora/rgl/raw/master/images/example.jpg)
+
+    irb> dg.directed?
+    true
+    irb> dg.vertices
+    [5, 6, 1, 2, 3, 4]
+    irb> dg.has_vertex? 4
+    true
+
+Every object could be a vertex (there is no class Vertex), even the class
+object *Object*:
+
+    irb> dg.has_vertex? Object
+    false
+    irb> dg.edges.sort.to_s
+    "(1-2)(1-6)(2-3)(2-4)(4-5)(6-4)"
+    irb> dg.to_undirected.edges.sort.to_s
+    "(1=2)(1=6)(2=3)(2=4)(5=4)(6=4)"
+
+Add inverse edge (4-2) to directed graph:
+
+    irb> dg.add_edge 4,2
+
+(4-2) == (2-4) in the undirected graph:
+
+    irb> dg.to_undirected.edges.sort.to_s
+    "(1=2)(1=6)(2=3)(2=4)(5=4)(6=4)"
+
+(4-2) != (2-4) in directed graphs:
+
+    irb> dg.edges.sort.to_s
+    "(1-2)(1-6)(2-3)(2-4)(4-2)(4-5)(6-4)"
+    irb> dg.remove_edge 4,2
+    true
+
+*Topological sort* is implemented as an iterator:
+
+    require 'rgl/topsort'
+    irb> dg.topsort_iterator.to_a
+    [1, 2, 3, 6, 4, 5]
+
+A more elaborated example showing *implicit graphs*:
+
+    require 'rgl/implicit'
+    def module_graph
+      RGL::ImplicitGraph.new { |g|
+        g.vertex_iterator { |b|
+          ObjectSpace.each_object(Module, &b)
+        }
+        g.adjacent_iterator { |x, b|
+          x.ancestors.each { |y|
+            b.call(y) unless x == y || y == Kernel || y == Object
+          }
+        }
+        g.directed = true
+      }
+    end
+
+This function creates a directed graph, with vertices being all loaded
+modules:
+
+    g = module_graph
+
+We only want to see the ancestors of {RGL::AdjacencyGraph}:
+
+    require 'rgl/traversal'
+    tree = g.bfs_search_tree_from(RGL::AdjacencyGraph)
+
+Now we want to visualize this component of g with DOT.  We therefore create a
+subgraph of the original graph, using a filtered graph:
+
+    g = g.vertices_filtered_by {|v| tree.has_vertex? v}
+    g.write_to_graphic_file('jpg')
+
+creates the following graph image with DOT:
+
+![Module graph](https://github.com/monora/rgl/raw/master/images/module_graph.jpg)
+
+This graph shows all loaded RGL modules:
+
+![RGL Modules](https://github.com/monora/rgl/raw/master/images/rgl_modules.png)
+
+Look for more in
+[examples](https://github.com/monora/rgl/tree/master/examples) directory.
+
+I collect some links to stuff around RGL at http://del.icio.us/monora/rgl.
+
+## Credits
+
+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.
+
+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](http://www.boost.org/libs/graph/doc) kindly allowed to use the BGL
+documentation as a *cheap* reference for RGL. He and Robert also gave feedback
+and many ideas for RGL.
+
+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 rgl/dot.rb).
+
+Jeremy Bopp, John Carter, Sascha Doerdelmann, Shawn Garbett, Andreas Schörk
+and Kirill Lashuk for contributing additions, test cases and bugfixes.
+
+Kirill Lashuk who started to take over further development in November 2012.
+
+See also http://github.com/monora/rgl/contributors.
+
+## Copying
+
+RGL is Copyright (c) 2002,2004,2005,2008,2013,2015 by Horst Duchene. It is
+free software, and may be redistributed under the terms specified in the
+README file of the Ruby distribution.

data/Rakefile

@@ -6,12 +6,12 @@ require 'bundler/setup'
 require 'rubygems/package_task'
 
 require 'rake/testtask'
+require 'rake/clean'
 require 'yard'
 
 $:.unshift File.join(File.dirname(__FILE__), 'lib')
 require 'rgl/base' # require base module to get RGL_VERSION
 
-SUMMARY = "Ruby Graph Library"
 SOURCES = FileList['lib/**/*.rb']
 
 # The default task is run if rake is given no explicit arguments.
@@ -26,20 +26,6 @@ Rake::TestTask.new do |t|
   t.verbose = true
 end
 
-begin
-  require 'rcov/rcovtask'
-
-  desc "Calculate code coverage with rcov"
-  Rcov::RcovTask.new(:rcov) do |t|
-    t.libs << 'test'
-    t.pattern = 'test/*_test.rb'
-    t.verbose = true
-    t.rcov_opts += ['--exclude', 'test/,gems/']
-  end
-rescue LoadError
-  nil # rcov is available only on Ruby 1.8
-end
-
 # Git tagging
 
 desc "Commit all changes as a new version commit. Tag the commit with v<version> tag"

data/lib/rgl/base.rb

@@ -6,7 +6,7 @@
 
 require 'rgl/enumerable_ext'
 
-RGL_VERSION = "0.5.1"
+RGL_VERSION = "0.5.2"
 
 module RGL
   class NotDirectedError < RuntimeError; end
@@ -77,6 +77,9 @@ module RGL
         "(#{source}-#{target})"
       end
 
+      # Since Ruby 2.0 #inspect no longer calls #to_s. So we alias it to to_s (fixes #22)
+      alias inspect to_s
+
       # Returns the array [source,target].
       #
       def to_a

data/lib/rgl/bellman_ford.rb

@@ -2,8 +2,7 @@ require 'rgl/dijkstra_visitor'
 require 'rgl/edge_properties_map'
 require 'rgl/path_builder'
 
-require 'delegate'
-require 'algorithms'
+require 'lazy_priority_queue'
 
 module RGL
 

data/lib/rgl/dijkstra.rb

@@ -2,8 +2,7 @@ require 'rgl/dijkstra_visitor'
 require 'rgl/edge_properties_map'
 require 'rgl/path_builder'
 
-require 'delegate'
-require 'algorithms'
+require 'lazy_priority_queue'
 
 module RGL
 
@@ -55,7 +54,7 @@ module RGL
     def init(source)
       @visitor.set_source(source)
 
-      @queue = Queue.new
+      @queue = MinPriorityQueue.new
       @queue.push(source, 0)
     end
 
@@ -82,8 +81,6 @@ module RGL
       new_v_distance = @distance_combinator.call(@visitor.distance_map[u], @edge_weights_map.edge_property(u, v))
 
       if new_v_distance < @visitor.distance_map[v]
-        old_v_distance = @visitor.distance_map[v]
-
         @visitor.distance_map[v] = new_v_distance
         @visitor.parents_map[v]  = u
 
@@ -91,7 +88,7 @@ module RGL
           @visitor.color_map[v] = :GRAY
           @queue.push(v, new_v_distance)
         elsif @visitor.color_map[v] == :GRAY
-          @queue.decrease_key(v, old_v_distance, new_v_distance)
+          @queue.decrease_key(v, new_v_distance)
         end
 
         @visitor.handle_edge_relaxed(u, v)
@@ -104,29 +101,6 @@ module RGL
       edge_weights_map.is_a?(EdgePropertiesMap) ? edge_weights_map : NonNegativeEdgePropertiesMap.new(edge_weights_map, @graph.directed?)
     end
 
-    class Queue < SimpleDelegator # :nodoc:
-
-      def initialize
-        @heap = Containers::Heap.new { |a, b| a.distance < b.distance }
-        super(@heap)
-      end
-
-      def push(vertex, distance)
-        @heap.push(vertex_key(vertex, distance), vertex)
-      end
-
-      def decrease_key(vertex, old_distance, new_distance)
-        @heap.change_key(vertex_key(vertex, old_distance), vertex_key(vertex, new_distance))
-      end
-
-      def vertex_key(vertex, distance)
-        VertexKey.new(vertex, distance)
-      end
-
-      VertexKey = Struct.new(:vertex, :distance)
-
-    end
-
   end # class DijkstraAlgorithm
 
   module Graph

data/lib/rgl/dot.rb

@@ -17,6 +17,10 @@ module RGL
       v.to_s
     end
 
+    def vertex_id(v)
+      v
+    end
+
     # Return a RGL::DOT::Digraph for directed graphs or a DOT::Graph for an
     # undirected Graph. _params_ can contain any graph property specified in
     # rdot.rb.
@@ -29,7 +33,7 @@ module RGL
 
       each_vertex do |v|
         graph << DOT::Node.new(
-            'name'     => v.object_id,
+            'name'     => vertex_id(v),
             'fontsize' => fontsize,
             'label'    => vertex_label(v)
         )
@@ -37,8 +41,8 @@ module RGL
 
       each_edge do |u, v|
         graph << edge_class.new(
-            'from'     => u.object_id,
-            'to'       => v.object_id,
+            'from'     => vertex_id(u),
+            'to'       => vertex_id(v),
             'fontsize' => fontsize
         )
       end

data/lib/rgl/traversal.rb

@@ -169,6 +169,10 @@ module RGL
     # it is called on each _finish_vertex_ event. See
     # strongly_connected_components for an example usage.
     #
+    # Note that this traversal does not garantee, that roots are at the top of
+    # each spanning subtree induced by the DFS search on a directed graph (see
+    # also the discussion in issue #20[https://github.com/monora/rgl/issues/20]).
+    #
     def depth_first_search(vis = DFSVisitor.new(self), &b)
       each_vertex do |u|
         unless vis.finished_vertex?(u)

data/test/dijkstra_issue24_test.rb

@@ -0,0 +1,23 @@
+require 'test_helper'
+
+require 'rgl/dijkstra'
+require 'rgl/adjacency'
+
+include RGL
+
+class TestDijkstraIssue24 < Test::Unit::TestCase
+
+  def setup
+    @graph = RGL::AdjacencyGraph[2,53, 2,3, 3,8, 3,28, 3,39, 29,58, 8,35, 12,39, 10,29, 62,15, 15,32,  32,58, 58,44, 44,53]
+
+  end
+
+  def test_shortest_path_search
+    assert_equal([53, 44, 58, 32, 15, 62], shortest_path(53, 62))
+  end
+
+  def shortest_path(v,w)
+    @graph.dijkstra_shortest_path(Hash.new(1), v, w)
+  end
+
+end

data/test/dot_test.rb

@@ -10,25 +10,29 @@ class TestDot < Test::Unit::TestCase
   end
 
   def test_to_dot_digraph
-    graph = RGL::DirectedAdjacencyGraph[1, 2]
+    graph = RGL::DirectedAdjacencyGraph["a", "b"]
     dot   = graph.to_dot_graph.to_s
 
-    first_vertex_id = 1.object_id
-    second_vertex_id = 2.object_id
+    first_vertex_id = "a"
+    second_vertex_id = "b"
 
     assert_match(dot, /\{[^}]*\}/) # {...}
     assert_match(dot, /#{first_vertex_id}\s*\[/)  # node 1
-    assert_match(dot, /label\s*=\s*1/)            # node 1 label
+    assert_match(dot, /label\s*=\s*a/)            # node 1 label
     assert_match(dot, /#{second_vertex_id}\s*\[/) # node 2
-    assert_match(dot, /label\s*=\s*2/)            # node 2 label
+    assert_match(dot, /label\s*=\s*b/)            # node 2 label
     assert_match(dot, /#{first_vertex_id}\s*->\s*#{second_vertex_id}/) # edge
   end
 
   def test_to_dot_graph
-    graph = RGL::AdjacencyGraph[1, 2]
+    graph = RGL::AdjacencyGraph["a", "b"]
     def graph.vertex_label(v)
       "label-"+v.to_s
     end
+
+    def graph.vertex_id(v)
+      "id-"+v.to_s
+    end
     dot = graph.write_to_graphic_file
   end
 end

data/test/graph_test.rb

@@ -63,6 +63,11 @@ class TestGraph < Test::Unit::TestCase
     assert_equal edges, @dg1.edges
   end
 
+  # Test for issue #22
+  def test_edges_to_s
+    assert_equal @dg1.edges.sort.to_s, "[(1-2), (1-6), (2-3), (2-4), (4-5), (6-4)]"
+  end
+
   def test_not_implemented
     graph = NotImplementedGraph.new
     assert_raise(NotImplementedError) { graph.each_vertex }

data/test/test_helper.rb

@@ -1,3 +1,6 @@
+require "codeclimate-test-reporter"
+CodeClimate::TestReporter.start
+
 require 'rubygems'
 require 'test/unit'
 

metadata

@@ -1,8 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rgl
 version: !ruby/object:Gem::Version
-  version: 0.5.1
-  prerelease: 
+  version: 0.5.2
 platform: ruby
 authors:
 - Horst Duchene
@@ -10,12 +9,11 @@ authors:
 autorequire: rgl/base
 bindir: bin
 cert_chain: []
-date: 2015-07-25 00:00:00.000000000 Z
+date: 2016-05-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: stream
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -23,73 +21,64 @@ dependencies:
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: 0.5.0
 - !ruby/object:Gem::Dependency
-  name: algorithms
+  name: lazy_priority_queue
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.6.1
+        version: 0.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.6.1
+        version: 0.1.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: test-unit
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 description: RGL is a framework for graph data structures and algorithms
@@ -97,7 +86,7 @@ email: monora@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files:
-- README.rdoc
+- README.md
 files:
 - lib/rgl/dijkstra.rb
 - lib/rgl/edmonds_karp.rb
@@ -126,9 +115,6 @@ files:
 - lib/rgl/graph_wrapper.rb
 - lib/rgl/bipartite.rb
 - ChangeLog
-- examples/images/module_graph.jpg
-- examples/images/example.jpg
-- examples/images/rgl_modules.png
 - examples/insel_der_tausend_gefahren.rb
 - examples/rdep-rgl.rb
 - examples/north2.rb
@@ -203,7 +189,6 @@ files:
 - examples/north/g.10.2.graphml
 - examples/examples.rb
 - Gemfile
-- README.rdoc
 - Rakefile
 - rakelib/dep_graph.rake
 - test/dijkstra_test.rb
@@ -222,43 +207,38 @@ files:
 - test/bellman_ford_test.rb
 - test/rdot_test.rb
 - test/cycles_test.rb
+- test/dijkstra_issue24_test.rb
 - test/test_helper.rb
 - test/transitivity_test.rb
 - test/bipartite_test.rb
+- README.md
 homepage: https://github.com/monora/rgl
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options:
 - --title
 - RGL - Ruby Graph Library
 - --main
-- README.rdoc
+- README.md
 - --line-numbers
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 900116365
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 900116365
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.0.14
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Ruby Graph Library
 test_files: []
 has_rdoc: true

data/README.rdoc

@@ -1,248 +0,0 @@
-= Ruby Graph Library (RGL) {<img src="https://secure.travis-ci.org/monora/rgl.png?branch=master" alt="Build Status" />}[https://travis-ci.org/monora/rgl]
-
-RGL is a framework for graph data structures and algorithms.
-
-The design of the library is much influenced by the Boost Graph Library (BGL)
-which is written in C++ heavily using its template mechanism. Refer to
-http://www.boost.org/libs/graph/doc for further links and documentation on graph
-data structures and algorithms and the design rationales of BGL.
-
-A comprehensive summary of graph terminology can be found in the the graph
-section of the <em>Dictionary of Algorithms and Data Structures</em> at
-http://www.nist.gov/dads/HTML/graph.html.
-
-== Design principles
-
-This document concentrates on the special issues of the implementation in
-Ruby. The main design goals directly taken from the BGL design are:
-
-* An interface for how the structure of a graph can be accessed using a generic
-  interface that hides the details of the graph data structure
-  implementation. This interface is defined by the module {Graph}, which should be
-  included in concrete classes.
-
-* A standardized generic interface for traversing graphs {RGL::GraphIterator}
-
-RGL provides some general purpose graph classes that conform to this interface,
-but they are not meant to be the *only* graph classes. As in BGL I believe that
-the main contribution of the RGL is the formulation of this interface.
-
-The BGL graph interface and graph components are generic in the sense of the C++
-Standard Template Library (STL). In Ruby other techniques are available to
-express the generic character of the algorithms and data structures mainly using
-mixins and iterators. The BGL documentation mentions three means to achieve
-genericity:
-
-* Algorithm/Data-Structure Interoperability
-* Extension through Function Objects and Visitors
-* Element Type Parameterization
-* Vertex and Edge Property Multi-Parameterization
-
-The first is easily achieved in RGL using mixins, which of course is not as
-efficient than C++ templates (but much more readable :-). The second one is even
-more easily implemented using standard iterators with blocks or using the
-{http://www.rubydoc.info/github/monora/stream stream module}. The third one is
-no issue since Ruby is dynamically typed: Each object can be a graph vertex.
-There is no need for a vertex (or even edge type). In the current version of RGL
-properties of vertices are simply attached using hashes. At first there seems to
-be not much need for the graph property machinery.
-
-=== Algorithms
-
-RGL current contains a core set of algorithm patterns:
-
-* Breadth First Search {RGL::BFSIterator}
-* Depth First Search {RGL::DFSIterator}
-
-The algorithm patterns by themselves do not compute any meaningful quantities
-over graphs, they are merely building blocks for constructing graph
-algorithms. The graph algorithms in RGL currently include:
-
-* Topological Sort {RGL::TopsortIterator}
-* Connected Components {RGL::Graph#each_connected_component}
-* Strongly Connected Components {RGL::Graph#strongly_connected_components}
-* Transitive Closure {RGL::Graph#transitive_closure}
-* Dijkstras Shortest Path Algorithm {RGL::DijkstraAlgorithm}
-* Bellman Ford Algorithm {RGL::BellmanFordAlgorithm}
-
-=== Data Structures
-
-RGL currently provides two graph classes that implement a generalized adjacency
-list and an edge list adaptor.
-
-* {RGL::AdjacencyGraph}
-* {RGL::ImplicitGraph}
-
-The AdjacencyGraph class is the general purpose _swiss army knife_ of graph
-classes. It is highly parameterized so that it can be optimized for different
-situations: the graph is directed or undirected, allow or disallow parallel
-edges, efficient access to just the out-edges, fast vertex insertion and removal
-at the cost of extra space overhead, etc.
-
-=== Differences to BGL
-
-The concepts of IncidenceGraph, AdjacencyGraph and VertexListGraph (see
-http://www.boost.org/libs/graph/doc/IncidenceGraph.html) are here bundled in the
-base graph module. Most methods of IncidenceGraph should be standard in the base
-module Graph. The complexity guarantees can not necessarily provided.  See
-http://www.boost.org/libs/graph/doc/graph_concepts.html.
-
-== Installation
-
-  % gem install rgl
-
-or download the latest sources from the git repository http://github.com/monora/rgl.
-
-== Running tests
-
-Checkout RGL git repository and go to the project directory. First, install RGL
-dependencies with bundler:
-
- % bundle install
-
-After that you can run the tests:
-
- % rake test
-
-To see tests coverage run rcov[http://github.com/relevance/rcov] rake task:
-
- % rake rcov
-
-This command will generate tests coverage report in coverage/ directory.
-
-<em>Node: rcov is not compatible with Ruby >= 1.9, so this rake task is
-available only on Ruby 1.8.</em>
-
-== Example irb session with RGL
-
-
-  irb> require 'rgl/adjacency'
-  irb> dg=RGL::DirectedAdjacencyGraph[1,2 ,2,3 ,2,4, 4,5, 6,4, 1,6]
-  # Use DOT to visualize this graph:
-  irb> require 'rgl/dot'
-  irb> dg.write_to_graphic_file('jpg')
-  "graph.jpg"
-
-The result:
-
-link:images/example.jpg
-
-  irb> dg.directed?
-  true
-  irb> dg.vertices
-  [5, 6, 1, 2, 3, 4]
-  irb> dg.has_vertex? 4
-  true
-
-Every object could be a vertex (there is no class Vertex), even the class
-object _Object_:
-
-  irb> dg.has_vertex? Object
-  false
-  irb> dg.edges.sort.to_s
-  "(1-2)(1-6)(2-3)(2-4)(4-5)(6-4)"
-  irb> dg.to_undirected.edges.sort.to_s
-  "(1=2)(1=6)(2=3)(2=4)(5=4)(6=4)"
-
-Add inverse edge (4-2) to directed graph:
-
-  irb> dg.add_edge 4,2
-
-(4-2) == (2-4) in the undirected graph:
-
-  irb> dg.to_undirected.edges.sort.to_s
-  "(1=2)(1=6)(2=3)(2=4)(5=4)(6=4)"
-
-(4-2) != (2-4) in directed graphs:
-
-  irb> dg.edges.sort.to_s
-  "(1-2)(1-6)(2-3)(2-4)(4-2)(4-5)(6-4)"
-  irb> dg.remove_edge 4,2
-  true
-
-<em>Topological sort</em> is implemented as an iterator:
-
-  require 'rgl/topsort'
-  irb> dg.topsort_iterator.to_a
-  [1, 2, 3, 6, 4, 5]
-
-A more elaborated example showing <em>implicit graphs</em>:
-
-  require 'rgl/implicit'
-  def module_graph
-    RGL::ImplicitGraph.new { |g|
-      g.vertex_iterator { |b|
-        ObjectSpace.each_object(Module, &b)
-      }
-      g.adjacent_iterator { |x, b|
-        x.ancestors.each { |y|
-          b.call(y) unless x == y || y == Kernel || y == Object
-        }
-      }
-      g.directed = true
-    }
-  end
-
-This function creates a directed graph, with vertices being all loaded modules:
-
-  g = module_graph
-
-We only want to see the ancestors of {RGL::AdjacencyGraph}:
-
-  require 'rgl/traversal'
-  tree = g.bfs_search_tree_from(RGL::AdjacencyGraph)
-
-Now we want to visualize this component of g with DOT.  We therefore create a
-subgraph of the original graph, using a filtered graph:
-
-  g = g.vertices_filtered_by {|v| tree.has_vertex? v}
-  g.write_to_graphic_file('jpg')
-
-creates the following graph image with DOT:
-
-link:images/module_graph.jpg
-
-This graph shows all loaded RGL modules:
-
-link:images/rgl_modules.png
-
-Look for more in _examples_ directory (i.e. {file:examples/examples.rb}).
-
-== My del.icio.us links concerning RGL
-
-I collect some links to stuff around RGL at http://del.icio.us/monora/rgl.
-
-== Credits
-
-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.
-
-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 RGL. He and Robert also gave
-feedback and many ideas for RGL.
-
-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 rgl/dot.rb).
-
-Jeremy Bopp, John Carter, Sascha Doerdelmann, Shawn Garbett, Andreas Schörk
-and Kirill Lashuk for contributing additions, test cases and bugfixes.
-
-Kirill Lashuk who started to take over further development in November 2012.
-
-See also http://github.com/monora/rgl/contributors.
-
-== Copying
-
-RGL is Copyright (c) 2002,2004,2005,2008,2013,2015 by Horst Duchene. It is free software,
-and may be redistributed under the terms specified in the README file of the
-Ruby distribution.
-