philiprehberger-dependency_graph 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a9091598b68332edaee82a0a8a55bd23d3d00278c78466b88ac86b0e25651390
-  data.tar.gz: '0889cc1cdd1d277dc63b4c08228b6e091bacccbcb3670833d5015c4aec02cba9'
+  metadata.gz: d893dfbce550ce9ba6022f2f647b4b70cf2306a972b52b93ed096d7bc9384c9c
+  data.tar.gz: 57ef5e2ddea71da6b58e15adeb0e1d1d38443b455d99c17aa14a795cfdf7a421
 SHA512:
-  metadata.gz: c9ecc7105f38fe9d6dcb1a63e2456d91883f26bb114b2097ea2bada656f80dfd77065c5143dadf579a9f29b07b069fc3c2fb98d39ddca7be71c65c1537275d9c
-  data.tar.gz: 37f0dc97583b44d80f9c046dd68375fc2749ac14f360905b0de8c64e3f630645814471d012f053434b91318ec9ab77ea9f6af0b3cb839846ed760bbc31d1ef1b
+  metadata.gz: a3096da9a20d0a487aec73c8f5fccd26483e4ef6d19e237f767892f8ef3c5f1a8ad670d859b137b3c10c7afb4e28a86467e9485f0d081fe4bc1ca2be706eb0af
+  data.tar.gz: 657e23b74e72698eefd35515b25ce8f3a8d508107384460fac9d9d608589018d6b11705f49fd2547fe5d879fe5f06e68a2361d28cf2009adb5c560c6a572fef2

data/CHANGELOG.md

@@ -7,6 +7,21 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.4.0] - 2026-04-21
+
+### Added
+- `Graph#to_dot` — Graphviz DOT export for visualization
+
+### Fixed
+- `bug_report.yml` — require Ruby version; add Gem version input per guide
+
+## [0.3.0] - 2026-04-09
+
+### Added
+- `Graph#reverse` — return a new graph with all edges flipped (useful for dependent analysis)
+- `Graph#all_dependents_of(item)` — transitive closure of items depending on a node
+- `Graph#independent?(a, b)` — check whether two nodes are mutually unreachable
+
 ## [0.2.0] - 2026-04-03
 
 ### Added

data/README.md

@@ -110,6 +110,23 @@ graph.add(:a).add(:b, depends_on: [:a]).add(:c, depends_on: [:b])
 graph.resolve  # => [:a, :b, :c]
 ```
 
+### Graphviz Export
+
+```ruby
+graph = Philiprehberger::DependencyGraph.new
+graph.add(:a)
+graph.add(:b, depends_on: [:a])
+graph.add(:c, depends_on: [:b])
+
+puts graph.to_dot
+# digraph dependencies {
+#   "b" -> "a";
+#   "c" -> "b";
+# }
+
+graph.to_dot(name: 'MyDeps')  # Customize the digraph name
+```
+
 ## API
 
 | Method | Description |
@@ -128,6 +145,10 @@ graph.resolve  # => [:a, :b, :c]
 | `Graph#roots` | Nodes with no dependencies |
 | `Graph#leaves` | Nodes with no dependents |
 | `Graph#depth(item)` | Maximum dependency depth of a node |
+| `Graph#reverse` | Return a new graph with all edges flipped |
+| `Graph#all_dependents_of(item)` | All transitive dependents of a node |
+| `Graph#independent?(a, b)` | Whether two nodes are mutually unreachable |
+| `#to_dot(name:)` | Graphviz DOT representation |
 
 ## Development
 

data/lib/philiprehberger/dependency_graph/graph.rb

@@ -208,6 +208,125 @@ module Philiprehberger
         @nodes.keys.reject { |node| depended_on.include?(node) }
       end
 
+      # Merge another graph into this one, combining nodes and dependencies
+      #
+      # @param other [Graph] another graph to merge
+      # @return [self]
+      def merge(other)
+        raise Error, 'Can only merge Graph instances' unless other.is_a?(self.class)
+
+        other.nodes.each do |node, deps|
+          @nodes[node] ||= []
+          deps.each do |dep|
+            @nodes[node] << dep unless @nodes[node].include?(dep)
+          end
+        end
+        self
+      end
+
+      # Remove a node and all edges referencing it
+      #
+      # @param item [Object] the item to remove
+      # @return [Boolean] true if the node existed, false otherwise
+      def remove(item)
+        return false unless @nodes.key?(item)
+
+        @nodes.delete(item)
+        @nodes.each_value { |deps| deps.delete(item) }
+        true
+      end
+
+      # Total number of nodes in the graph
+      #
+      # @return [Integer]
+      def size
+        @nodes.size
+      end
+
+      # Whether the graph has no nodes
+      #
+      # @return [Boolean]
+      def empty?
+        @nodes.empty?
+      end
+
+      # Return a new graph with all edges reversed (dependents become dependencies)
+      #
+      # @return [Graph] a new graph where each edge direction is flipped
+      def reverse
+        new_graph = self.class.new
+        @nodes.each_key { |node| new_graph.instance_variable_get(:@nodes)[node] ||= [] }
+        @nodes.each do |node, deps|
+          deps.each { |dep| new_graph.add(dep, depends_on: [node]) }
+        end
+        new_graph
+      end
+
+      # Return all transitive dependents of an item (direct + indirect)
+      #
+      # @param item [Object] the item to query
+      # @return [Array] all items that depend on this item, directly or transitively
+      def all_dependents_of(item)
+        return [] unless @nodes.key?(item)
+
+        visited = {}
+        queue = dependents_of(item)
+        result = []
+
+        until queue.empty?
+          dep = queue.shift
+          next if visited[dep]
+
+          visited[dep] = true
+          result << dep
+          queue.concat(dependents_of(dep))
+        end
+
+        result
+      end
+
+      # Check whether two nodes are independent (neither depends on the other transitively)
+      #
+      # @param node_a [Object]
+      # @param node_b [Object]
+      # @return [Boolean] true if neither node is reachable from the other
+      def independent?(node_a, node_b)
+        return false if node_a == node_b
+        return false unless @nodes.key?(node_a) && @nodes.key?(node_b)
+
+        !all_dependencies_of(node_a).include?(node_b) &&
+          !all_dependencies_of(node_b).include?(node_a)
+      end
+
+      # Export the graph in Graphviz DOT format.
+      #
+      # Nodes are emitted in alphabetical order (cast to string for sort key),
+      # and edges within a node are sorted alphabetically for deterministic
+      # output. Nodes that participate in at least one edge (incoming or
+      # outgoing) are emitted implicitly via the edge lines; truly isolated
+      # nodes are declared explicitly so they still appear in the rendered
+      # graph. Works on graphs containing cycles.
+      #
+      # @param name [String] the digraph name used in the `digraph` header
+      # @return [String] Graphviz DOT source, terminated by a newline
+      def to_dot(name: 'dependencies')
+        output = "digraph #{name} {\n"
+        depended_on = @nodes.each_with_object({}) do |(_node, deps), acc|
+          deps.each { |dep| acc[dep] = true }
+        end
+        sorted_nodes = @nodes.keys.sort_by(&:to_s)
+        sorted_nodes.each do |node|
+          deps = (@nodes[node] || []).sort_by(&:to_s)
+          if deps.empty?
+            output << "  #{dot_quote(node)};\n" unless depended_on[node]
+          else
+            deps.each { |dep| output << "  #{dot_quote(node)} -> #{dot_quote(dep)};\n" }
+          end
+        end
+        output << "}\n"
+        output
+      end
+
       # Calculate maximum dependency depth for a node (longest path from any root to this node)
       #
       # @param item [Object] the item to query
@@ -221,6 +340,10 @@ module Philiprehberger
 
       private
 
+      def dot_quote(node)
+        %("#{node.to_s.gsub('"', '\"')}")
+      end
+
       def build_path(visited, from, to)
         path = [to]
         current = to

data/lib/philiprehberger/dependency_graph/version.rb

@@ -2,6 +2,6 @@
 
 module Philiprehberger
   module DependencyGraph
-    VERSION = '0.2.0'
+    VERSION = '0.4.0'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: philiprehberger-dependency_graph
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Philip Rehberger
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-04-04 00:00:00.000000000 Z
+date: 2026-04-21 00:00:00.000000000 Z
 dependencies: []
 description: Build and resolve dependency graphs using topological sort, detect cycles,
   generate parallel execution batches, query dependencies and dependents, find shortest