yargi 0.1.2 → 0.2.0

data/lib/yargi/digraph_edge.rb

@@ -1,81 +1,81 @@
 module Yargi
   class Digraph
-    
+
     #
     # Edge inside a digraph
     #
-    # Methods reconnect, index= are provided for Digraph itself and are not 
-    # intended to be used directly. Probably unexpectedly, source and target 
+    # Methods reconnect, index= are provided for Digraph itself and are not
+    # intended to be used directly. Probably unexpectedly, source and target
     # writers are provided as reconnection shortcuts and can be used by users.
     #
     class Edge
       include Yargi::Markable
-      
+
       # Owning graph
       attr_reader :graph
       alias :digraph :graph
-    
+
       # Index in the vertices list of the owner
       attr_accessor :index
-      
+
       # Source vertex
       attr_reader :source
-      
+
       # Target vertex
       attr_reader :target
-    
+
       # Creates an edge instance
       def initialize(graph, index, source, target)
         @graph, @index = graph, index
         @source, @target = source, target
       end
 
-    
+
       ### Pseudo-protected section ##########################################
-      
+
       # Reconnects source and target
       def reconnect(source, target)
         @source = source if source
         @target = target if target
       end
 
-      
+
       ### Query section #######################################################
-      
+
       # Returns edge extremities
       def extremities
         VertexSet[source, target]
       end
-      
+
       # Shortcut for digraph.reconnect(edge, source, nil)
       def source=(source)
         @graph.reconnect(self, source, nil)
       end
-    
+
       # Shortcut for digraph.reconnect(edge, nil, target)
       def target=(target)
         @graph.reconnect(self, nil, target)
       end
-      
-      
+
+
       ### Sort, Hash, etc. section ############################################
-      
+
       # Compares indexes
       def <=>(other)
         return nil unless Edge===other and self.graph==other.graph
         self.index <=> other.index
       end
-      
-      
+
+
       ### Export section ######################################################
-      
+
       # Returns a string representation
       def to_s; "e#{index}:#{source.to_s}->#{target.to_s}" end
-          
+
       # Inspects the vertex
       def inspect; "e#{index}:#{source.inspect}->#{target.inspect}" end
-      
+
     end # class Edge
-    
+
   end
 end

data/lib/yargi/digraph_vertex.rb

@@ -1,98 +1,98 @@
 module Yargi
   class Digraph
-    
+
     #
     # Vertex inside a digraph.
     #
-    # Methods add_in_edge, remove_in_edge, add_out_edge, remove_out_edge and index= 
+    # Methods add_in_edge, remove_in_edge, add_out_edge, remove_out_edge and index=
     # are provided for Digraph itself and are not intended to be used directly.
     #
     class Vertex
       include Yargi::Markable
-    
+
       # Owning graph
       attr_reader :graph
       alias :digraph :graph
-    
+
       # Index in the vertices list of the owner
       attr_accessor :index
-      
+
       # Creates a vertex instance
       def initialize(graph, index)
         @graph, @index = graph, index
         @in_edges, @out_edges = EdgeSet[], EdgeSet[]
       end
 
-      
+
       ### Query section #######################################################
-      
+
       # Returns a copy of the incoming edges list.
       def in_edges(filter=nil, &block)
         @in_edges.filter(filter, &block)
       end
-    
+
       # Returns a copy of the outgoing edges list.
       def out_edges(filter=nil, &block)
         @out_edges.filter(filter, &block)
       end
-      
+
       # Returns all adjacent vertices
       def adjacent(filter=nil, &block)
         (in_adjacent(filter, &block) + out_adjacent(filter, &block)).uniq
       end
-      
-      # Returns back-adjacent vertices 
+
+      # Returns back-adjacent vertices
       def in_adjacent(filter=nil, &block)
         @in_edges.source.filter(filter, &block)
       end
-    
-      # Returns forward-adjacent vertices 
+
+      # Returns forward-adjacent vertices
       def out_adjacent(filter=nil, &block)
         @out_edges.target.filter(filter, &block)
       end
 
-    
+
       ### Pseudo-protected section ##########################################
-      
+
       # Adds an incoming edge
       def add_in_edge(edge)
         @in_edges << edge
       end
-      
+
       # Removes an incoming edge
       def remove_in_edge(edge)
         @in_edges.delete(edge)
       end
-      
+
       # Adds an outgoing edge
       def add_out_edge(edge)
         @out_edges << edge
       end
-    
+
       # Removes an outgoing edge
       def remove_out_edge(edge)
         @out_edges.delete(edge)
       end
-      
-      
+
+
       ### Sort, Hash, etc. section ############################################
-      
+
       # Compares indexes
       def <=>(other)
         return nil unless Vertex===other and self.graph==other.graph
         self.index <=> other.index
       end
-      
-      
+
+
       ### Export section ######################################################
-      
+
       # Returns a string representation
       def to_s; "V#{index}" end
-    
+
       # Inspects the vertex
       def inspect; "V#{index}" end
-    
+
     end # class Vertex
-    
+
   end
 end

data/lib/yargi/edge_set.rb

@@ -1,45 +1,45 @@
 module Yargi
-  
+
   # A set of edges
   class EdgeSet < ElementSet
-    
+
     ### Factory section #######################################################
-    
+
     # Creates a VertexSet instance using _elements_ varargs.
     def self.[](*elements)
       EdgeSet.new(elements)
     end
-    
+
     ### Walking section #######################################################
-    
+
     # Returns a VertexSet with reachable vertices using the edges of this set.
     def target
       VertexSet.new(self.collect {|e| e.target}).uniq
     end
     alias :targets :target
-    
-    # Returns a VertexSet with back-reachable vertices using the edges of this 
+
+    # Returns a VertexSet with back-reachable vertices using the edges of this
     # set.
     def source
       VertexSet.new(self.collect {|e| e.source}).uniq
     end
     alias :sources :source
-    
+
     ### Writing section #######################################################
-    
+
     # Fired to each edge in the set
     def source=(source)
       self.each{|e| e.source=source}
     end
-    
+
     # Fired to each edge in the set
     def target=(target)
       self.each{|e| e.target=target}
     end
-    
+
     ### Protected section #####################################################
     protected
-        
+
     # Extends with EdgeSet instead of ElementSet
     def extend_result(result)
       EdgeSet.new(result)

data/lib/yargi/element_set.rb

@@ -1,139 +1,139 @@
 require 'delegate'
 
 module Yargi
-  
+
   # Main module of VertexSet and EdgeSet
   class ElementSet < Array
-    
+
     ### Factory section #######################################################
-    
+
     # Creates a ElementSet instance using _elements_ varargs.
     def self.[](*elements)
       ElementSet.new(elements)
     end
-    
-    
+
+
     ### Array handling ########################################################
 
     # Same as Array.dup
     def dup() # :nodoc: #
-      extend_result(super) 
+      extend_result(super)
     end
-    
+
     # See Array.compact
     def compact() # :nodoc: #
-      extend_result(super) 
+      extend_result(super)
     end
-    
+
     # See Array.flatten
     def flatten() # :nodoc: #
-      extend_result(super) 
+      extend_result(super)
     end
-    
+
     # See Array.reverse
     def reverse() # :nodoc: #
-      extend_result(super) 
+      extend_result(super)
     end
-    
+
     # See Array.uniq
     def uniq() # :nodoc: #
-      extend_result(super) 
+      extend_result(super)
     end
-    
+
     # See Array.sort
     def sort(&block) # :nodoc: #
-      extend_result(super(&block)) 
+      extend_result(super(&block))
     end
-    
+
     # See Array.concat
     def concat(other) # :nodoc: #
       extend_result(super(other))
     end
-    
+
     # See Array.[]
     def [](*args) # :nodoc: #
       result = super(*args)
-      Array===result ? extend_result(result) : result 
+      Array===result ? extend_result(result) : result
     end
-    
+
     # See Array.+
     def +(right) # :nodoc: #
-      extend_result(super(right)) 
+      extend_result(super(right))
     end
-    
+
     # See Array.-
     def -(right) # :nodoc: #
-      extend_result(super(right)) 
+      extend_result(super(right))
     end
-      
-      
+
+
     ### Enumerable handling ###################################################
-    
+
     # See Enumerable.each_cons
     def each_cons(n) # :nodoc: #
-      super(n) {|c| yield extend_result(c)} 
+      super(n) {|c| yield extend_result(c)}
     end
-    
+
     # See Enumerable.each_slice
     def each_slice(n) # :nodoc: #
-      super(n) {|c| yield extend_result(c)} 
+      super(n) {|c| yield extend_result(c)}
     end
-    
+
     # See Enumerable.select
     def select(&block) # :nodoc: #
-      extend_result(super(&block)) 
+      extend_result(super(&block))
     end
-      
+
     # See Enumerable.find_all
     def find_all(&block) # :nodoc: #
-      extend_result(super(&block)) 
+      extend_result(super(&block))
     end
-      
+
     # See Enumerable.grep
     def grep(pattern, &block) # :nodoc: #
       greped = super(pattern, &block)
       block_given? ? greped : extend_result(greped)
     end
-      
+
     # See Enumerable.reject
     def partition(&block) # :nodoc: #
       p = super(&block)
       [extend_result(p[0]), extend_result(p[1])]
     end
-      
+
     # See Enumerable.reject
     def reject(&block) # :nodoc: #
-      extend_result(super(&block)) 
+      extend_result(super(&block))
     end
-  
-    
+
+
     ### Markable handling #####################################################
-    
-    # Fired to each element of the group. 
+
+    # Fired to each element of the group.
     def tag(*modules)
       self.each {|elm| elm.tag(*modules)}
     end
-    
-    # Collects result of get_mark invocation on each element of the 
+
+    # Collects result of get_mark invocation on each element of the
     # group and returns it as an array.
     def get_mark(key)
       self.collect {|elm| elm.get_mark(key)}
     end
 
-    # Fired to each element of the group. Values are duplicated by default. 
+    # Fired to each element of the group. Values are duplicated by default.
     # Put dup to false to avoid this behavior.
     def set_mark(key, value, dup=true)
       self.each {|elm| elm.set_mark(key, (dup and not(Symbol===value)) ? value.dup : value)}
     end
-    
+
     # When _marks_ is provided, the invocation is fired to all group
     # elements. When a block is given, it is called on each element,
     # passing it as argument. If the block returns a hash, that hash
-    # is installed as marks on the iterated element. 
+    # is installed as marks on the iterated element.
     # The two usages (_marks_ and block) can be used conjointly.
     def add_marks(marks=nil)
       self.each {|elm| elm.add_marks(marks)} if marks
-      if block_given? 
+      if block_given?
         self.each do |elm|
           hash = yield elm
           elm.add_marks(hash) if Hash===hash
@@ -141,20 +141,20 @@ module Yargi
       end
     end
     alias :merge_marks :add_marks
-  
-    
+
+
     ### Query handling ########################################################
-    
-    # Filters this set with a 'predicate and block' predicate 
+
+    # Filters this set with a 'predicate and block' predicate
     # (see Yargi::Predicate)
     def filter(predicate=nil, &block)
       pred = Yargi::Predicate.to_predicate(predicate, &block)
       extend_result(self.select{|e| pred===e})
     end
-    
+
     ### Protected section #####################################################
     protected
-        
+
     # Extends a resulting array with the module. This method is intended
     # to be overrided by specialization of this module.
     def extend_result(result)
@@ -162,5 +162,5 @@ module Yargi
     end
 
   end # class ElementSet
-  
+
 end