networkx 0.1.1 → 0.2.0

data/lib/networkx/multidigraph.rb

@@ -10,12 +10,13 @@ module NetworkX
   class MultiDiGraph < DiGraph
     # Returns a new key
     #
-    # @param node_1 [Object] the first node of a given edge
-    # @param node_2 [Object] the second node of a given edge
-    def new_edge_key(node_1, node_2)
-      return 0 if @adj[node_1][node_2].nil?
-      key = @adj[node_1][node_2].length
-      key += 1 while @adj[node_1][node_2].key?(key)
+    # @param node1 [Object] the first node of a given edge
+    # @param node2 [Object] the second node of a given edge
+    def new_edge_key(node1, node2)
+      return 0 if @adj[node1][node2].nil?
+
+      key = @adj[node1][node2].length
+      key += 1 while @adj[node1][node2].has_key?(key)
       key
     end
 
@@ -27,52 +28,60 @@ module NetworkX
     # @example Add an edge with no attribute
     #   graph.add_edge("Bangalore", "Chennai")
     #
-    # @param node_1 [Object] the first node of the edge
-    # @param node_2 [Object] the second node of the edge
+    # @param node1 [Object] the first node of the edge
+    # @param node2 [Object] the second node of the edge
     # @param edge_attrs [Hash{ Object => Object }] the hash of the edge attributes
-    def add_edge(node_1, node_2, **edge_attrs)
-      add_node(node_1)
-      add_node(node_2)
-      key = new_edge_key(node_1, node_2)
-      all_edge_attrs = @adj[node_1][node_2] || {}
+    def add_edge(node1, node2, **edge_attrs)
+      add_node(node1)
+      add_node(node2)
+      key = new_edge_key(node1, node2)
+      all_edge_attrs = @adj[node1][node2] || {}
       all_edge_attrs[key] = edge_attrs
-      @adj[node_1][node_2] = all_edge_attrs
-      @pred[node_2][node_1] = all_edge_attrs
+      @adj[node1][node2] = all_edge_attrs
+      @pred[node2][node1] = all_edge_attrs
     end
 
-    # TODO: Reduce method complexity
-
     # Removes edge from the graph
     #
     # @example
     #   graph.remove_edge('Noida', 'Bangalore')
     #
-    # @param node_1 [Object] the first node of the edge
-    # @param node_2 [Object] the second node of the edge
-    def remove_edge(node_1, node_2, key=nil)
-      if key.nil?
-        super(node_1, node_2)
-        return
+    # @param node1 [Object] the first node of the edge
+    # @param node2 [Object] the second node of the edge
+    def remove_edge(node1, node2, key = nil)
+      return super(node1, node2) if key.nil?
+
+      raise KeyError, "#{node1} is not a valid node." unless @nodes.has_key?(node1)
+      raise KeyError, "#{node2} is not a valid node" unless @nodes.has_key?(node2)
+      raise KeyError, 'The given edge is not a valid one.' unless @adj[node1].has_key?(node2)
+      if @adj[node1][node2].none? { |_index, data| data[:key] == key }
+        raise KeyError, 'The given edge is not a valid one'
       end
-      raise KeyError, "#{node_1} is not a valid node." unless @nodes.key?(node_1)
-      raise KeyError, "#{node_2} is not a valid node" unless @nodes.key?(node_2)
-      raise KeyError, 'The given edge is not a valid one.' unless @adj[node_1].key?(node_2)
-      raise KeyError, 'The given edge is not a valid one.' unless @adj[node_1][node_2].key?(key)
-      @adj[node_1][node_2].delete(key)
-      @pred[node_2][node_1].delete(key)
+
+      @adj[node1][node2].delete_if { |_indx, data| data[:key] == key }
+      @pred[node2][node1].delete_if { |_indx, data| data[:key] == key }
     end
 
     # Checks if the the edge consisting of two nodes is present in the graph
     #
     # @example
-    #   graph.edge?(node_1, node_2)
+    #   graph.edge?(node1, node2)
     #
-    # @param node_1 [Object] the first node of the edge to be checked
-    # @param node_2 [Object] the second node of the edge to be checked
+    # @param node1 [Object] the first node of the edge to be checked
+    # @param node2 [Object] the second node of the edge to be checked
     # @param key [Integer] the key of the given edge
-    def edge?(node_1, node_2, key=nil)
-      super(node_1, node_2) if key.nil?
-      node?(node_1) && @adj[node_1].key?(node_2) && @adj[node_1][node_2].key?(key)
+    def edge?(node1, node2, key = nil)
+      return super(node1, node2) if key.nil?
+
+      node?(node1) && @adj[node1].has_key?(node2) && @adj[node1][node2].has_key?(key)
+    end
+
+    def has_edge?(node1, node2, key = nil)
+      return super(node1, node2) if key.nil?
+
+      return false unless node?(node1) && @adj[node1].has_key?(node2)
+
+      @adj[node1][node2].any? { |_index, data| data[:key] == key }
     end
 
     # Returns the undirected version of the graph
@@ -80,13 +89,13 @@ module NetworkX
     # @example
     #   graph.to_undirected
     def to_undirected
-      graph = NetworkX::Graph.new(@graph)
-      @nodes.each { |node, node_attr| graph.add_node(node, node_attr) }
-      @adj.each do |node_1, node_1_edges|
-        node_1_edges.each do |node_2, node_1_node_2|
+      graph = NetworkX::Graph.new(**@graph)
+      @nodes.each { |node, node_attr| graph.add_node(node, **node_attr) }
+      @adj.each do |node1, node1_edges|
+        node1_edges.each do |node2, node1_node2|
           edge_attrs = {}
-          node_1_node_2.each { |_key, attrs| edge_attrs.merge!(attrs) }
-          graph.add_edge(node_1, node_2, edge_attrs)
+          node1_node2.each { |_key, attrs| edge_attrs.merge!(attrs) }
+          graph.add_edge(node1, node2, **edge_attrs)
         end
       end
       graph
@@ -97,13 +106,13 @@ module NetworkX
     # @example
     #   graph.to_directed
     def to_directed
-      graph = NetworkX::DiGraph.new(@graph)
-      @nodes.each { |node, node_attr| graph.add_node(node, node_attr) }
-      @adj.each do |node_1, node_1_edges|
-        node_1_edges.each do |node_2, node_1_node_2|
+      graph = NetworkX::DiGraph.new(**@graph)
+      @nodes.each { |node, node_attr| graph.add_node(node, **node_attr) }
+      @adj.each do |node1, node1_edges|
+        node1_edges.each do |node2, node1_node2|
           edge_attrs = {}
-          node_1_node_2.each { |_key, attrs| edge_attrs.merge!(attrs) }
-          graph.add_edge(node_1, node_2, edge_attrs)
+          node1_node2.each { |_key, attrs| edge_attrs.merge!(attrs) }
+          graph.add_edge(node1, node2, **edge_attrs)
         end
       end
       graph
@@ -114,13 +123,11 @@ module NetworkX
     # @example
     #   graph.to_multigraph
     def to_multigraph
-      graph = NetworkX::MultiGraph.new(@graph)
-      @nodes.each { |node, node_attr| graph.add_node(node, node_attr) }
-      @adj.each do |node_1, node_1_edges|
-        node_1_edges.each_key do |node_2, node_1_node_2|
-          edge_attrs = {}
-          node_1_node_2.each { |_key, attrs| graph.add_edge(node_1, node_2, attrs) }
-          graph.add_edge(node_1, node_2, edge_attrs)
+      graph = NetworkX::MultiGraph.new(**@graph)
+      @nodes.each { |node, node_attr| graph.add_node(node, **node_attr) }
+      @adj.each do |node1, node2_edges|
+        node2_edges.each do |node2, edges|
+          edges.each { |_key, attrs| graph.add_edge(node1, node2, **attrs) }
         end
       end
       graph
@@ -131,10 +138,10 @@ module NetworkX
     # @example
     #   graph.reverse
     def reverse
-      new_graph = NetworkX::MultiDiGraph.new(@graph)
-      @nodes.each { |node, attrs| new_graph.add_node(node, attrs) }
+      new_graph = NetworkX::MultiDiGraph.new(**@graph)
+      @nodes.each { |node, attrs| new_graph.add_node(node, **attrs) }
       @adj.each do |u, u_edges|
-        u_edges.each { |v, uv_attrs| uv_attrs.each { |_k, edge_attrs| new_graph.add_edge(v, u, edge_attrs) } }
+        u_edges.each { |v, uv_attrs| uv_attrs.each { |_k, edge_attrs| new_graph.add_edge(v, u, **edge_attrs) } }
       end
       new_graph
     end
@@ -146,7 +153,7 @@ module NetworkX
     #
     # @param node [Object] the node whose in degree is to be calculated
     def in_degree(node)
-      @pred[node].values.map(:length).inject(:+)
+      @pred[node].values.map(&:length).sum
     end
 
     # Returns out-degree of a given node
@@ -156,7 +163,7 @@ module NetworkX
     #
     # @param node [Object] the node whose out degree is to be calculated
     def out_degree(node)
-      @adj[node].values.map(:length).inject(:+)
+      @adj[node].values.map(&:length).sum
     end
 
     # Returns number of edges
@@ -164,7 +171,7 @@ module NetworkX
     # @example
     #   graph.number_of_edges
     def number_of_edges
-      @adj.values.flat_map(&:values).map(&:length).inject(:+)
+      @adj.values.flat_map(&:values).map(&:length).sum
     end
 
     # Returns the size of the graph
@@ -174,19 +181,17 @@ module NetworkX
     #
     # @param is_weighted [Bool] if true, method returns sum of weights of all edges
     #                           else returns number of edges
-    def size(is_weighted=false)
+    def size(is_weighted = false)
       if is_weighted
         graph_size = 0
         @adj.each do |_, hash_val|
-          hash_val.each { |_, v| v.each { |_, attrs| graph_size += attrs[:weight] if attrs.key?(:weight) } }
+          hash_val.each { |_, v| v.each { |_, attrs| graph_size += attrs[:weight] if attrs.has_key?(:weight) } }
         end
         return graph_size
       end
       number_of_edges
     end
 
-    # TODO: Reduce method length and method complexity
-
     # Returns subgraph consisting of given array of nodes
     #
     # @example
@@ -196,23 +201,22 @@ module NetworkX
     def subgraph(nodes)
       case nodes
       when Array, Set
-        sub_graph = NetworkX::MultiDiGraph.new(@graph)
+        sub_graph = NetworkX::MultiDiGraph.new(**@graph)
         nodes.each do |u, _|
-          raise KeyError, "#{u} does not exist in the current graph!" unless @nodes.key?(u)
-          sub_graph.add_node(u, @nodes[u])
+          raise KeyError, "#{u} does not exist in the current graph!" unless @nodes.has_key?(u)
+
+          sub_graph.add_node(u, **@nodes[u])
           @adj[u].each do |v, edge_val|
-            edge_val.each { |_, keyval| sub_graph.add_edge(u, v, keyval) if @adj[u].key?(v) && nodes.include?(v) }
+            edge_val.each { |_, keyval| sub_graph.add_edge(u, v, **keyval) if @adj[u].has_key?(v) && nodes.include?(v) }
           end
-          return sub_graph
         end
+        sub_graph
       else
-        raise ArgumentError, 'Expected Argument to be Array or Set of nodes, '\
+        raise ArgumentError, 'Expected Argument to be Array or Set of nodes, ' \
                              "received #{nodes.class.name} instead."
       end
     end
 
-    # TODO: Reduce method length and method complexity
-
     # Returns subgraph conisting of given edges
     #
     # @example
@@ -222,19 +226,24 @@ module NetworkX
     def edge_subgraph(edges)
       case edges
       when Array, Set
-        sub_graph = NetworkX::MultiDiGraph.new(@graph)
+        sub_graph = NetworkX::MultiDiGraph.new(**@graph)
         edges.each do |u, v|
-          raise KeyError, "Edge between #{u} and #{v} does not exist in the graph!" unless @nodes.key?(u)\
-                                                                                    && @adj[u].key?(v)
-          sub_graph.add_node(u, @nodes[u])
-          sub_graph.add_node(v, @nodes[v])
-          @adj[u][v].each { |_, keyval| sub_graph.add_edge(u, v, keyval) }
+          raise KeyError, "Edge between #{u} and #{v} does not exist in the graph!" unless @nodes.has_key?(u) \
+                                                                                    && @adj[u].has_key?(v)
+
+          sub_graph.add_node(u, **@nodes[u])
+          sub_graph.add_node(v, **@nodes[v])
+          @adj[u][v].each { |_, keyval| sub_graph.add_edge(u, v, **keyval) }
         end
-        return sub_graph
+        sub_graph
       else
-        raise ArgumentError, 'Expected Argument to be Array or Set of edges, '\
-        "received #{edges.class.name} instead."
+        raise ArgumentError, 'Expected Argument to be Array or Set of edges, ' \
+                             "received #{edges.class.name} instead."
       end
     end
+
+    def multigraph?
+      true
+    end
   end
 end

data/lib/networkx/multigraph.rb

@@ -8,12 +8,13 @@ module NetworkX
   class MultiGraph < Graph
     # Returns a new key
     #
-    # @param node_1 [Object] the first node of a given edge
-    # @param node_2 [Object] the second node of a given edge
-    def new_edge_key(node_1, node_2)
-      return 0 if @adj[node_1][node_2].nil?
-      key = @adj[node_1][node_2].length
-      key += 1 while @adj[node_1][node_2].key?(key)
+    # @param node1 [Object] the first node of a given edge
+    # @param node2 [Object] the second node of a given edge
+    def new_edge_key(node1, node2)
+      return 0 if @adj[node1][node2].nil?
+
+      key = @adj[node1][node2].length
+      key += 1 while @adj[node1][node2].has_key?(key)
       key
     end
 
@@ -25,39 +26,39 @@ module NetworkX
     # @example Add an edge with no attribute
     #   graph.add_edge("Bangalore", "Chennai")
     #
-    # @param node_1 [Object] the first node of the edge
-    # @param node_2 [Object] the second node of the edge
+    # @param node1 [Object] the first node of the edge
+    # @param node2 [Object] the second node of the edge
     # @param edge_attrs [Hash{ Object => Object }] the hash of the edge attributes
-    def add_edge(node_1, node_2, **edge_attrs)
-      add_node(node_1)
-      add_node(node_2)
-      key = new_edge_key(node_1, node_2)
-      all_edge_attrs = @adj[node_1][node_2] || {}
+    def add_edge(node1, node2, **edge_attrs)
+      add_node(node1)
+      add_node(node2)
+      key = new_edge_key(node1, node2)
+      all_edge_attrs = @adj[node1][node2] || {}
       all_edge_attrs[key] = edge_attrs
-      @adj[node_1][node_2] = all_edge_attrs
-      @adj[node_2][node_1] = all_edge_attrs
+      @adj[node1][node2] = all_edge_attrs
+      @adj[node2][node1] = all_edge_attrs
     end
 
-    # TODO: Reduce method complexity
-
     # Removes edge from the graph
     #
     # @example
     #   graph.remove_edge('Noida', 'Bangalore')
     #
-    # @param node_1 [Object] the first node of the edge
-    # @param node_2 [Object] the second node of the edge
-    def remove_edge(node_1, node_2, key=nil)
-      if key.nil?
-        super(node_1, node_2)
-        return
+    # @param node1 [Object] the first node of the edge
+    # @param node2 [Object] the second node of the edge
+    def remove_edge(node1, node2, key = nil)
+      return super(node1, node2) if key.nil?
+
+      raise KeyError, "#{node1} is not a valid node." unless @nodes.has_key?(node1)
+      raise KeyError, "#{node2} is not a valid node" unless @nodes.has_key?(node2)
+      raise KeyError, 'The given edge is not a valid one.' unless @adj[node1].has_key?(node2)
+
+      if @adj[node1][node2].none? { |_index, data| data[:key] == key }
+        raise KeyError, 'The given edge is not a valid one'
       end
-      raise KeyError, "#{node_1} is not a valid node." unless @nodes.key?(node_1)
-      raise KeyError, "#{node_2} is not a valid node" unless @nodes.key?(node_2)
-      raise KeyError, 'The given edge is not a valid one.' unless @adj[node_1].key?(node_2)
-      raise KeyError, 'The given edge is not a valid one.' unless @adj[node_1][node_2].key?(key)
-      @adj[node_1][node_2].delete(key)
-      @adj[node_2][node_1].delete(key)
+
+      @adj[node1][node2].delete_if { |_indx, data| data[:key] == key }
+      @adj[node2][node1].delete_if { |_indx, data| data[:key] == key }
     end
 
     # Returns the size of the graph
@@ -67,11 +68,11 @@ module NetworkX
     #
     # @param is_weighted [Bool] if true, method returns sum of weights of all edges
     #                           else returns number of edges
-    def size(is_weighted=false)
+    def size(is_weighted = false)
       if is_weighted
         graph_size = 0
         @adj.each do |_, hash_val|
-          hash_val.each { |_, v| v.each { |_, attrs| graph_size += attrs[:weight] if attrs.key?(:weight) } }
+          hash_val.each { |_, v| v.each { |_, attrs| graph_size += attrs[:weight] if attrs.has_key?(:weight) } }
         end
         return graph_size / 2
       end
@@ -83,20 +84,43 @@ module NetworkX
     # @example
     #   graph.number_of_edges
     def number_of_edges
-      @adj.values.flat_map(&:values).map(&:length).inject(:+) / 2
+      @adj.values.flat_map(&:values).map(&:length).sum / 2
     end
 
     # Checks if the the edge consisting of two nodes is present in the graph
     #
     # @example
-    #   graph.edge?(node_1, node_2)
+    #   graph.edge?(node1, node2)
     #
-    # @param node_1 [Object] the first node of the edge to be checked
-    # @param node_2 [Object] the second node of the edge to be checked
+    # @param node1 [Object] the first node of the edge to be checked
+    # @param node2 [Object] the second node of the edge to be checked
     # @param key [Integer] the key of the given edge
-    def edge?(node_1, node_2, key=nil)
-      super(node_1, node_2) if key.nil?
-      node?(node_1) && @adj[node_1].key?(node_2) && @adj[node_1][node_2].key?(key)
+    def edge?(node1, node2, key = nil)
+      return super(node1, node2) if key.nil?
+
+      node?(node1) && @adj[node1].has_key?(node2) && @adj[node1][node2].has_key?(key)
+    end
+
+    def has_edge?(node1, node2, key = nil)
+      return super(node1, node2) if key.nil?
+
+      return false unless node?(node1) && @adj[node1].has_key?(node2)
+
+      @adj[node1][node2].any? { |_index, data| data[:key] == key }
+    end
+
+    def each_edge(data: false)
+      return enum_for(:each_edge, data: data) unless block_given?
+
+      @adj.each do |v, ws|
+        ws.each do |w, key_and_info|
+          next if v > w
+
+          key_and_info.each do |key, info|
+            data ? yield(v, w, key, info) : yield(v, w, key)
+          end
+        end
+      end
     end
 
     # Returns the undirected version of the graph
@@ -104,20 +128,18 @@ module NetworkX
     # @example
     #   graph.to_undirected
     def to_undirected
-      graph = NetworkX::Graph.new(@graph)
-      @nodes.each { |node, node_attr| graph.add_node(node, node_attr) }
-      @adj.each do |node_1, node_1_edges|
-        node_1_edges.each do |node_2, node_1_node_2|
+      graph = NetworkX::Graph.new(**@graph)
+      @nodes.each { |node, node_attr| graph.add_node(node, **node_attr) }
+      @adj.each do |node1, node1_edges|
+        node1_edges.each do |node2, node1_node2|
           edge_attrs = {}
-          node_1_node_2.each { |_key, attrs| edge_attrs.merge!(attrs) }
-          graph.add_edge(node_1, node_2, edge_attrs)
+          node1_node2.each { |_key, attrs| edge_attrs.merge!(attrs) }
+          graph.add_edge(node1, node2, **edge_attrs)
         end
       end
       graph
     end
 
-    # TODO: Reduce method complexity and method length
-
     # Returns subgraph consisting of given array of nodes
     #
     # @example
@@ -127,23 +149,24 @@ module NetworkX
     def subgraph(nodes)
       case nodes
       when Array, Set
-        sub_graph = NetworkX::MultiGraph.new(@graph)
+        sub_graph = NetworkX::MultiGraph.new(**@graph)
         nodes.each do |u, _|
-          raise KeyError, "#{u} does not exist in the current graph!" unless @nodes.key?(u)
-          sub_graph.add_node(u, @nodes[u])
+          raise KeyError, "#{u} does not exist in the current graph!" unless @nodes.has_key?(u)
+
+          sub_graph.add_node(u, **@nodes[u])
           @adj[u].each do |v, edge_val|
-            edge_val.each { |_, keyval| sub_graph.add_edge(u, v, keyval) if @adj[u].key?(v) && nodes.include?(v) }
+            next if u > v
+
+            edge_val.each { |_, keyval| sub_graph.add_edge(u, v, **keyval) if @adj[u].has_key?(v) && nodes.include?(v) }
           end
-          return sub_graph
         end
+        sub_graph
       else
-        raise ArgumentError, 'Expected Argument to be Array or Set of nodes, '\
+        raise ArgumentError, 'Expected Argument to be Array or Set of nodes, ' \
                              "received #{nodes.class.name} instead."
       end
     end
 
-    # TODO: Reduce method complexity and method length
-
     # Returns subgraph conisting of given edges
     #
     # @example
@@ -153,19 +176,24 @@ module NetworkX
     def edge_subgraph(edges)
       case edges
       when Array, Set
-        sub_graph = NetworkX::MultiGraph.new(@graph)
+        sub_graph = NetworkX::MultiGraph.new(**@graph)
         edges.each do |u, v|
-          raise KeyError, "Edge between #{u} and #{v} does not exist in the graph!" unless @nodes.key?(u)\
-                                                                                    && @adj[u].key?(v)
-          sub_graph.add_node(u, @nodes[u])
-          sub_graph.add_node(v, @nodes[v])
-          @adj[u][v].each { |_, keyval| sub_graph.add_edge(u, v, keyval) }
+          raise KeyError, "Edge between #{u} and #{v} does not exist in the graph!" unless @nodes.has_key?(u) \
+                                                                                    && @adj[u].has_key?(v)
+
+          sub_graph.add_node(u, **@nodes[u])
+          sub_graph.add_node(v, **@nodes[v])
+          @adj[u][v].each { |_, keyval| sub_graph.add_edge(u, v, **keyval) }
         end
-        return sub_graph
+        sub_graph
       else
-        raise ArgumentError, 'Expected Argument to be Array or Set of edges, '\
-        "received #{edges.class.name} instead."
+        raise ArgumentError, 'Expected Argument to be Array or Set of edges, ' \
+                             "received #{edges.class.name} instead."
       end
     end
+
+    def multigraph?
+      true
+    end
   end
 end

data/lib/networkx/operators/all.rb

@@ -1,11 +1,12 @@
 module NetworkX
   # Performs the union of many graphs
   #
-  # @param [Array<Graph>, Array<DiGraph>, Array<MultiGraph>, Array<MultiDiGraph>] Array of graphs
+  # @param graphs [Array<Graph>, Array<DiGraph>, Array<MultiGraph>, Array<MultiDiGraph>] Array of graphs
   #
   # @return [Graph, DiGraph, MultiGraph, MultiDiGraph] union of all the graphs
   def self.union_all(graphs)
     raise ArgumentError, 'Argument array is empty' if graphs.empty?
+
     result = graphs.shift
 
     graphs.each do |graph|
@@ -16,11 +17,12 @@ module NetworkX
 
   # Performs the disjoint union of many graphs
   #
-  # @param [Array<Graph>, Array<DiGraph>, Array<MultiGraph>, Array<MultiDiGraph>] Array of graphs
+  # @param graphs [Array<Graph>, Array<DiGraph>, Array<MultiGraph>, Array<MultiDiGraph>] Array of graphs
   #
   # @return [Graph, DiGraph, MultiGraph, MultiDiGraph] disjoint union of all the graphs
   def self.disjoint_union_all(graphs)
     raise ArgumentError, 'Argument array is empty' if graphs.empty?
+
     result = graphs.shift
 
     graphs.each do |graph|
@@ -31,11 +33,12 @@ module NetworkX
 
   # Performs the intersection of many graphs
   #
-  # @param [Array<Graph>, Array<DiGraph>, Array<MultiGraph>, Array<MultiDiGraph>] Array of graphs
+  # @param graphs [Array<Graph>, Array<DiGraph>, Array<MultiGraph>, Array<MultiDiGraph>] Array of graphs
   #
   # @return [Graph, DiGraph, MultiGraph, MultiDiGraph] intersection of all the graphs
   def self.intersection_all(graphs)
     raise ArgumentError, 'Argument array is empty' if graphs.empty?
+
     result = graphs.shift
 
     graphs.each do |graph|
@@ -46,11 +49,12 @@ module NetworkX
 
   # Performs the composition of many graphs
   #
-  # @param [Array<Graph>, Array<DiGraph>, Array<MultiGraph>, Array<MultiDiGraph>] Array of graphs
+  # @param graphs [Array<Graph>, Array<DiGraph>, Array<MultiGraph>, Array<MultiDiGraph>] Array of graphs
   #
   # @return [Graph, DiGraph, MultiGraph, MultiDiGraph] composition of all the graphs
   def self.compose_all(graphs)
     raise ArgumentError, 'Argument array is empty' if graphs.empty?
+
     result = graphs.shift
 
     graphs.each do |graph|