jumoku 0.1.2 → 0.1.3

data/vendor/git/{graphy/lib/graphy → plexus/lib/plexus}/directed_graph.rb

@@ -1,4 +1,4 @@
-module Graphy
+module Plexus
 
   # This implements a directed graph which does not allow parallel
   # edges nor loops. That is, only one arc per nodes couple,
@@ -6,21 +6,22 @@ module Graphy
   # structure.
   module DirectedGraphBuilder
     include GraphBuilder
-    
-    autoload :Algorithms, "graphy/directed_graph/algorithms"
-    autoload :Distance,   "graphy/directed_graph/distance"    
+
+    autoload :Algorithms, "plexus/directed_graph/algorithms"
+    autoload :Distance,   "plexus/directed_graph/distance"
 
     # FIXME: DRY this snippet, I didn't find a clever way to
     # to dit though
     # TODO: well, extends_host_with do ... end would be cool,
     # using Module.new.module_eval(&block) in the helper.
     extends_host
+
     module ClassMethods
       def [](*a)
         self.new.from_array(*a)
       end
     end
-    
+
     def initialize(*params)
       # FIXME/TODO: setting args to the hash or {} while getting rid
       # on the previous parameters prevents from passing another
@@ -30,11 +31,11 @@ module Graphy
       # we should provide a way to handle the graph as a hash
       # member.
       args = (params.pop if params.last.kind_of? Hash) || {}
-      args[:algorithmic_category] = DirectedGraphBuilder::Algorithms    
+      args[:algorithmic_category] = DirectedGraphBuilder::Algorithms
       super *(params << args)
     end
-  end # DirectedGraphBuilder
-  
+  end
+
   # DirectedGraph is just an alias for Digraph should one desire
   DigraphBuilder = DirectedGraphBuilder
 
@@ -43,23 +44,25 @@ module Graphy
   module DirectedPseudoGraphBuilder
     include DirectedGraphBuilder
     extends_host
+
     module ClassMethods
       def [](*a)
         self.new.from_array(*a)
       end
     end
-    
+
     def initialize(*params)
       args = (params.pop if params.last.kind_of? Hash) || {}
       args[:parallel_edges] = true
       super *(params << args)
     end
-  end # DirectedPseudoGraphBuilder
+  end
 
   # This is a Digraph that allows for both parallel edges and loops.
   module DirectedMultiGraphBuilder
     include DirectedPseudoGraphBuilder
     extends_host
+
     module ClassMethods
       def [](*a)
         self.new.from_array(*a)
@@ -71,6 +74,5 @@ module Graphy
       args[:loops] = true
       super *(params << args)
     end
-  end # DirectedMultiGraphBuilder
-
-end # Graphy
+  end
+end

data/vendor/git/{graphy/lib/graphy → plexus/lib/plexus}/directed_graph/algorithms.rb

@@ -1,9 +1,8 @@
-module Graphy
-
+module Plexus
   # Digraph is a directed graph which is a finite set of vertices
   # and a finite set of edges connecting vertices. It cannot contain parallel
   # edges going from the same source vertex to the same target. It also
-  # cannot contain loops, i.e. edges that go have the same vertex for source 
+  # cannot contain loops, i.e. edges that go have the same vertex for source
   # and target.
   #
   # DirectedPseudoGraph is a class that allows for parallel edges, and
@@ -11,31 +10,33 @@ module Graphy
   # as well.
   module DirectedGraphBuilder
     module Algorithms
-
       include Search
       include StrongComponents
       include Distance
       include ChinesePostman
 
-      # A directed graph is directed by definition
+      # A directed graph is directed by definition.
       #
       # @return [Boolean] always true
+      #
       def directed?
         true
       end
 
-      # A digraph uses the Arc class for edges
+      # A digraph uses the Arc class for edges.
+      #
+      # @return [Plexus::MultiArc, Plexus::Arc] `Plexus::MultiArc` if the graph allows for parallel edges,
+      #   `Plexus::Arc` otherwise.
       #
-      # @return [Graphy::MultiArc, Graphy::Arc] `Graphy::MultiArc` if the graph allows for parallel edges,
-      #   `Graphy::Arc` otherwise.
       def edge_class
-        @parallel_edges ? Graphy::MultiArc : Graphy::Arc
+        @parallel_edges ? Plexus::MultiArc : Plexus::Arc
       end
 
-      # Reverse all edges in a graph
+      # Reverse all edges in a graph.
       #
       # @return [DirectedGraph] a copy of the receiver for which the direction of edges has
       #   been inverted.
+      #
       def reversal
         result = self.class.new
         edges.inject(result) { |a,e| a << e.reverse}
@@ -43,23 +44,26 @@ module Graphy
         result
       end
 
-      # Check whether the Graph is oriented or not.
+      # Check whether the graph is oriented or not.
       #
       # @return [Boolean]
+      #
       def oriented?
         e = edges
         re = e.map { |x| x.reverse}
         not e.any? { |x| re.include?(x)}
       end
 
-      # Balanced is when the out edge count is equal to the in edge count
+      # Balanced is the state when the out edges count is equal to the in edges count.
       #
       # @return [Boolean]
+      #
       def balanced?(v)
         out_degree(v) == in_degree(v)
       end
 
-      # Returns out_degree(v) - in_degree(v)
+      # Returns out_degree(v) - in_degree(v).
+      #
       def delta(v)
         out_degree(v) - in_degree(v)
       end
@@ -85,8 +89,7 @@ module Graphy
 
       def family(node)
         community(node, :all)
-      end    
-
-    end # Algorithms
-  end # DirectedGraphBuilder
-end # Graphy
+      end
+    end
+  end
+end

data/vendor/git/{graphy/lib/graphy → plexus/lib/plexus}/directed_graph/distance.rb

@@ -1,4 +1,4 @@
-module Graphy
+module Plexus
   module DirectedGraphBuilder
 
     # This module provides algorithms computing distance between
@@ -164,4 +164,4 @@ module Graphy
 
     end # Distance
   end # DirectedGraph
-end # Graphy
+end # Plexus

data/vendor/git/{graphy/lib/graphy → plexus/lib/plexus}/dot.rb

@@ -1,4 +1,4 @@
-module Graphy
+module Plexus
   module Dot
 
     #FIXME: don't really understood where we stand with the dot generators.
@@ -91,4 +91,4 @@ module Graphy
     alias as_dot_graphic write_to_graphic_file
 
   end # Dot
-end # module Graphy
+end # module Plexus

data/vendor/git/{graphy/lib/graphy → plexus/lib/plexus}/edge.rb

@@ -1,23 +1,23 @@
-module Graphy
-    
+module Plexus
   # An undirected edge is simply an undirected pair (source, target) used in
   # undirected graphs. Edge[u,v] == Edge[v,u]
   class Edge < Arc
 
     # Equality allows for the swapping of source and target
-    def eql?(other) super or (self.class == other.class and target==other.source and source==other.target); end
-
-    # Alias for eql?
+    def eql?(other)
+      super or (self.class == other.class and target == other.source and source == other.target)
+    end
     alias == eql?
 
     # Hash is defined such that source and target can be reversed and the
     # hash value will be the same
-    def hash() source.hash ^ target.hash; end
+    def hash
+      source.hash ^ target.hash
+    end
 
     # Sort support
     def <=>(rhs)
-      [[source,target].max,[source,target].min] <=> 
-      [[rhs.source,rhs.target].max,[rhs.source,rhs.target].min]
+      [[source,target].max, [source,target].min] <=> [[rhs.source,rhs.target].max, [rhs.source,rhs.target].min]
     end
 
     # Edge[1,2].to_s == "(1=2 'label)"
@@ -33,5 +33,4 @@ module Graphy
   class MultiEdge < Edge
     include ArcNumber
   end
-
 end

data/vendor/git/{graphy/lib/graphy → plexus/lib/plexus}/ext.rb

@@ -28,9 +28,9 @@ class Object
   #
   #     class A; include Digraph; end
   #     a.singleton_class.ancestors
-  #     # => [Graphy::GraphAPI, Graphy::DirectedGraph::Algorithms, ... 
-  #           Graphy::Labels, Enumerable, Object, Graphy, Kernel, BasicObject]
-  #     a.is_a? Graphy::Graph
+  #     # => [Plexus::GraphAPI, Plexus::DirectedGraph::Algorithms, ...
+  #           Plexus::Labels, Enumerable, Object, Plexus, Kernel, BasicObject]
+  #     a.is_a? Plexus::Graph
   #     # => true
   #
   # @param [Class] klass

data/vendor/git/{graphy/lib/graphy → plexus/lib/plexus}/graph.rb

@@ -1,5 +1,4 @@
-module Graphy
-
+module Plexus
   # Using the methods required by the {GraphAPI}, it implements all the
   # *basic* functions of a {Graph} using *only* functions
   # requested in {GraphAPI}. The process is under the control of the pattern
@@ -9,7 +8,6 @@ module Graphy
   # An actual, complete implementation still needs to be done using this cheap result,
   # hence {Digraph}, {UndirectedGraph} and their roomates.
   module GraphBuilder
-
     include Enumerable
     include Labels
     include Dot
@@ -29,7 +27,7 @@ module Graphy
 
     # Creates a generic graph.
     #
-    # @param [Hash(Graphy::Graph, Array)] *params initialization parameters.
+    # @param [Hash(Plexus::Graph, Array)] *params initialization parameters.
     #   See {AdjacencyGraphBuilder#implementation_initialize} for more details.
     # @return [Graph]
     def initialize(*params)
@@ -38,7 +36,7 @@ module Graphy
         # and the is_a? redefinition trick (instance_evaling) should be
         # completed by a clever way to check the actual class of p.
         # Maybe using ObjectSpace to get the available Graph classes?
-        !(p.is_a? Graphy::GraphBuilder or p.is_a? Array or p.is_a? Hash)
+        !(p.is_a? Plexus::GraphBuilder or p.is_a? Array or p.is_a? Hash)
       end
 
       args = params.last || {}
@@ -47,24 +45,24 @@ module Graphy
         self
       end.module_eval do
         # These inclusions trigger some validations checks by the way.
-        include(args[:implementation]       ? args[:implementation]       : Graphy::AdjacencyGraphBuilder)
-        include(args[:algorithmic_category] ? args[:algorithmic_category] : Graphy::DigraphBuilder       )
-        include Graphy::GraphAPI
+        include(args[:implementation]       ? args[:implementation]       : Plexus::AdjacencyGraphBuilder)
+        include(args[:algorithmic_category] ? args[:algorithmic_category] : Plexus::DigraphBuilder       )
+        include Plexus::GraphAPI
       end
 
       implementation_initialize(*params)
-    end     
+    end
 
     # Shortcut for creating a Graph.
     #
     # Using an arry of implicit {Arc}, specifying the vertices:
     #
-    #     Graphy::Graph[1,2, 2,3, 2,4, 4,5].edges.to_a.to_s
+    #     Plexus::Graph[1,2, 2,3, 2,4, 4,5].edges.to_a.to_s
     #     # => "(1-2)(2-3)(2-4)(4-5)"
-    # 
+    #
     # Using a Hash for specifying labels along the way:
     #
-    #     Graphy::Graph[ [:a,:b] => 3, [:b,:c] => 4 ]  (note: do not use for Multi or Pseudo graphs)
+    #     Plexus::Graph[ [:a,:b] => 3, [:b,:c] => 4 ]  (note: do not use for Multi or Pseudo graphs)
     #
     # @param [Array, Hash] *a
     # @return [Graph]
@@ -73,16 +71,16 @@ module Graphy
         # Convert to edge class
         a[0].each do |k,v|
           #FIXME, edge class shouldn't be assume here!!!
-          if edge_class.include? Graphy::ArcNumber
+          if edge_class.include? Plexus::ArcNumber
             add_edge!(edge_class[k[0],k[1],nil,v])
           else
             add_edge!(edge_class[k[0],k[1],v])
-          end 
+          end
         end
         #FIXME, edge class shouldn't be assume here!!!
-      elsif a[0].is_a? Graphy::Arc
+      elsif a[0].is_a? Plexus::Arc
         a.each{ |e| add_edge!(e); self[e] = e.label}
-      elsif a.size % 2 == 0    
+      elsif a.size % 2 == 0
         0.step(a.size-1, 2) {|i| add_edge!(a[i], a[i+1])}
       else
         raise ArgumentError
@@ -110,7 +108,7 @@ module Graphy
       x = self.class.new(self)
       x.add_edge!(u, v, l)
     end
-    alias add_arc add_edge  
+    alias add_arc add_edge
 
     # Non destructive version of {AdjacencyGraphBuilder#remove_vertex!} (works on a copy of the graph).
     #
@@ -130,7 +128,7 @@ module Graphy
       x = self.class.new(self)
       x.remove_edge!(u, v)
     end
-    alias remove_arc remove_edge  
+    alias remove_arc remove_edge
 
     # Computes the adjacent portions of the Graph.
     #
@@ -155,7 +153,6 @@ module Graphy
     #FIXME: This is a hack around a serious problem
     alias graph_adjacent adjacent
 
-
     # Adds all specified vertices to the vertex set.
     #
     # @param [#each] *a an Enumerable vertices set
@@ -186,7 +183,7 @@ module Graphy
       a.each { |edge| add_edge!(edge) }
       self
     end
-    alias add_arcs! add_edges!  
+    alias add_arcs! add_edges!
 
     # Same as {GraphBuilder#add_egdes! add_edges!} but works on a copy of the receiver.
     #
@@ -274,7 +271,7 @@ module Graphy
     # @return [Boolean]
     def edge?(*args)
       edges.include?(edge_convert(*args))
-    end  
+    end
     alias arc? edge?
     alias has_edge? edge?
     alias has_arc? edge?
@@ -290,9 +287,9 @@ module Graphy
     # @param [vertex] target
     # @param [Symbol] direction (:all) constraint on the direction of adjacency; may be either `:in`, `:out` or `:all`
     def adjacent?(source, target, direction = :all)
-      if source.is_a? Graphy::Arc
+      if source.is_a? Plexus::Arc
         raise NoArcError unless edge? source
-        if target.is_a? Graphy::Arc
+        if target.is_a? Plexus::Arc
           raise NoArcError unless edge? target
           (direction != :out and source.source == target.target) or (direction != :in and source.target == target.source)
         else
@@ -301,7 +298,7 @@ module Graphy
         end
       else
         raise NoVertexError unless vertex? source
-        if target.is_a? Graphy::Arc
+        if target.is_a? Plexus::Arc
           raise NoArcError unless edge? target
           (direction != :out and source == target.target) or (direction != :in and source == target.source)
         else
@@ -343,15 +340,14 @@ module Graphy
     #
     # @return [Boolean]
     def empty?
-      puts "yan"
       vertices.size.zero?
     end
 
     # Returns true if the given object is a vertex or an {Arc arc} of the graph.
-    # 
+    #
     # @param [vertex, Arc] x
     def include?(x)
-      x.is_a?(Graphy::Arc) ? edge?(x) : vertex?(x)
+      x.is_a?(Plexus::Arc) ? edge?(x) : vertex?(x)
     end
     alias has? include?
 
@@ -359,11 +355,11 @@ module Graphy
     #
     # This is equivalent to {GraphBuilder#adjacent adjacent}, but the type is based on the
     # type of the specified object.
-    # 
+    #
     # @param [vertex, Arc] x
     # @param [Symbol] direction (:all) can be either `:all`, `:in` or `:out`
     def neighborhood(x, direction = :all)
-      adjacent(x, :direction => direction, :type => ((x.is_a? Graphy::Arc) ? :edges : :vertices )) 
+      adjacent(x, :direction => direction, :type => ((x.is_a? Plexus::Arc) ? :edges : :vertices ))
     end
 
     # Union of all neighborhoods of vertices (or edges) in the Enumerable x minus the contents of x.
@@ -373,8 +369,8 @@ module Graphy
     # @param [vertex] x
     # @param [Symbol] direction can be either `:all`, `:in` or `:out`
     def set_neighborhood(x, direction = :all)
-      x.inject(Set.new) { |a,v| a.merge(neighborhood(v, idirection))}.reject { |v2| x.include?(v2) }
-    end  
+      x.inject(Set.new) { |a,v| a.merge(neighborhood(v, direction))}.reject { |v2| x.include?(v2) }
+    end
 
     # Union of all {GraphBuilder#set_neighborhood set_neighborhoods} reachable
     # among the specified edges.
@@ -387,7 +383,7 @@ module Graphy
     # @param [Symbol] direction can be `:all`, `:in`, or `:out`
     def closed_pth_neighborhood(w, p, direction = :all)
       if    p <= 0
-        w 
+        w
       elsif p == 1
         (w + set_neighborhood(w, direction)).uniq
       else
@@ -410,10 +406,10 @@ module Graphy
         x
       elsif p == 1
         set_neighborhood(x,direction)
-      else  
+      else
         set_neighborhood(open_pth_neighborhood(x, p-1, direction), direction) -
         closed_pth_neighborhood(x, p-1, direction)
-      end    
+      end
     end
 
     # Returns the number of out-edges (for directed graphs) or the number of
@@ -451,7 +447,7 @@ module Graphy
     end
 
     # Minimum out-degree of the graph.
-    # 
+    #
     # @return [Integer, nil] returns `nil` if the graph is empty
     def min_out_degree
       return nil if to_a.empty?
@@ -529,11 +525,11 @@ module Graphy
 
     # Equality is defined to be same set of edges and directed?
     def eql?(g)
-      return false unless g.is_a? Graphy::Graph
+      return false unless g.is_a? Plexus::Graph
 
-      (g.directed?   == self.directed?)  and 
+      (directed?     == g.directed?)     and
       (vertices.sort == g.vertices.sort) and
-      (g.edges.sort  == edges.sort)
+      (edges.sort    == g.edges.sort)
     end
     alias == eql?
 
@@ -544,8 +540,8 @@ module Graphy
     def merge(other)
       other.vertices.each { |v| add_vertex!(v)       }
       other.edges.each    { |e| add_edge!(e)         }
-      other.edges.each    { |e| add_edge!(e.reverse) } if directed? and !other.directed? 
-      self 
+      other.edges.each    { |e| add_edge!(e.reverse) } if directed? and !other.directed?
+      self
     end
 
     # A synonym for {GraphBuilder#merge merge}, but doesn't modify the current graph.
@@ -555,9 +551,9 @@ module Graphy
     def +(other)
       result = self.class.new(self)
       case other
-      when Graphy::Graph
+      when Plexus::Graph
         result.merge(other)
-      when Graphy::Arc
+      when Plexus::Arc
         result.add_edge!(other)
       else
         result.add_vertex!(other)
@@ -567,12 +563,12 @@ module Graphy
     # Removes all vertices in the specified graph.
     #
     # @param [Graph, Arc] other
-    # @return [Graph] 
+    # @return [Graph]
     def -(other)
       case other
-      when Graphy::Graph
+      when Plexus::Graph
         induced_subgraph(vertices - other.vertices)
-      when Graphy::Arc
+      when Plexus::Arc
         self.class.new(self).remove_edge!(other)
       else
         self.class.new(self).remove_vertex!(other)
@@ -599,33 +595,32 @@ module Graphy
     # @param [Array(vertex)] v
     # @return [Graph]
     def induced_subgraph(v)
-      edges.inject(self.class.new) do |a,e| 
+      edges.inject(self.class.new) do |a,e|
         (v.include?(e.source) and v.include?(e.target)) ? (a << e) : a
       end
     end
 
-    #def inspect
+    def inspect
       ## FIXME: broken, it's not updated. The issue's not with inspect, but it's worth mentionning here.
       ## Example:
       ##     dg = Digraph[1,2, 2,3, 2,4, 4,5, 6,4, 1,6]
       ##     dg.add_vertices! 1, 5, "yosh"
-      ##     # => Graphy::Digraph[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]]
+      ##     # => Plexus::Digraph[Plexus::Arc[1,2,nil], Plexus::Arc[1,6,nil], Plexus::Arc[2,3,nil], Plexus::Arc[2,4,nil], Plexus::Arc[4,5,nil], Plexus::Arc[6,4,nil]]
       ##     dg.vertex?("yosh")
       ##     # => true
       ##     dg
-      ##     # =>Graphy::Digraph[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]] 
+      ##     # =>Plexus::Digraph[Plexus::Arc[1,2,nil], Plexus::Arc[1,6,nil], Plexus::Arc[2,3,nil], Plexus::Arc[2,4,nil], Plexus::Arc[4,5,nil], Plexus::Arc[6,4,nil]]
       ## the new vertex doesn't show up.
       ## Actually this version of inspect is far too verbose IMO :)
-      #l = vertices.select { |v| self[v]}.map { |u| "vertex_label_set(#{u.inspect}, #{self[u].inspect})"}.join('.')
-      #self.class.to_s + '[' + edges.map {|e| e.inspect}.join(', ') + ']' + (l && l != '' ? '.'+l : '')
-    #end
+      l = vertices.select { |v| self[v]}.map { |u| "vertex_label_set(#{u.inspect}, #{self[u].inspect})"}.join('.')
+      self.class.to_s + '[' + edges.map {|e| e.inspect}.join(', ') + ']' + (l && l != '' ? '.'+l : '')
+    end
 
     private
 
     # ?
     def edge_convert(*args)
-      args[0].is_a?(Graphy::Arc) ? args[0] : edge_class[*args]
+      args[0].is_a?(Plexus::Arc) ? args[0] : edge_class[*args]
     end
-
-  end # Graph
-end # Graphy
+  end
+end