philiprehberger-dependency_graph 0.1.7 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e7adfe2ea19f84682a7098e4b2721e0da82302a2820b795910d7eed48b8ab2ba
-  data.tar.gz: d7440b81ffe5f4a9a7b84ef2c70bd39b6a6f31115213df1dcef51ebce7c05669
+  metadata.gz: a9091598b68332edaee82a0a8a55bd23d3d00278c78466b88ac86b0e25651390
+  data.tar.gz: '0889cc1cdd1d277dc63b4c08228b6e091bacccbcb3670833d5015c4aec02cba9'
 SHA512:
-  metadata.gz: 6372378bf705c2d620a0971b47a5fd52c3664664ec11388f983b318cc3f5548557fe5395a744d9b440deb85cb1144425009ec63211cfc525ea93c9e38ce39f78
-  data.tar.gz: c038fa5661134768db05a5833ae52d912cb19e3bf3d53ffc998a665375d40f6dca1bb6ccb9fa0cbd8f08a00c61c0ce15163f0c627548c99cec9b8e4dd889900a
+  metadata.gz: c9ecc7105f38fe9d6dcb1a63e2456d91883f26bb114b2097ea2bada656f80dfd77065c5143dadf579a9f29b07b069fc3c2fb98d39ddca7be71c65c1537275d9c
+  data.tar.gz: 37f0dc97583b44d80f9c046dd68375fc2749ac14f360905b0de8c64e3f630645814471d012f053434b91318ec9ab77ea9f6af0b3cb839846ed760bbc31d1ef1b

data/CHANGELOG.md

@@ -7,6 +7,23 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.2.0] - 2026-04-03
+
+### Added
+- `Graph#dependencies_of(item)` — returns direct dependencies of a node
+- `Graph#all_dependencies_of(item)` — returns transitive closure of all dependencies
+- `Graph#dependents_of(item)` — reverse lookup of items that depend on a node
+- `Graph#path(from, to)` — BFS shortest dependency path between two nodes
+- `Graph#subgraph(*items)` — extract a new graph containing only specified nodes and their edges
+- `Graph#roots` — nodes with no dependencies
+- `Graph#leaves` — nodes with no dependents
+- `Graph#depth(item)` — maximum dependency depth for a node
+
+## [0.1.8] - 2026-03-31
+
+### Added
+- Add GitHub issue templates, dependabot config, and PR template
+
 ## [0.1.7] - 2026-03-31
 
 ### Changed

data/README.md

@@ -65,6 +65,43 @@ graph.cycle?  # => true
 graph.cycles  # => [[:a, :b, :a]]
 ```
 
+### Dependency Queries
+
+```ruby
+graph = Philiprehberger::DependencyGraph.new
+graph.add(:a)
+graph.add(:b, depends_on: [:a])
+graph.add(:c, depends_on: [:b])
+graph.add(:d, depends_on: [:b, :c])
+
+graph.dependencies_of(:d)      # => [:b, :c]
+graph.all_dependencies_of(:d)  # => [:b, :c, :a]
+graph.dependents_of(:b)        # => [:c, :d]
+```
+
+### Path Finding
+
+```ruby
+graph.path(:d, :a)  # => [:d, :b, :a]
+graph.path(:a, :d)  # => nil (no path in that direction)
+```
+
+### Subgraph Extraction
+
+```ruby
+sub = graph.subgraph(:a, :b, :c)
+sub.resolve  # => [:a, :b, :c]
+# Edges to nodes outside the subgraph are excluded
+```
+
+### Roots, Leaves, and Depth
+
+```ruby
+graph.roots   # => [:a]  (no dependencies)
+graph.leaves  # => [:d]  (nothing depends on it)
+graph.depth(:d)  # => 2  (longest path from a root)
+```
+
 ### Chaining
 
 ```ruby
@@ -83,6 +120,14 @@ graph.resolve  # => [:a, :b, :c]
 | `Graph#parallel_batches` | Group into parallel execution batches |
 | `Graph#cycle?` | Check if the graph contains cycles |
 | `Graph#cycles` | List all detected cycles |
+| `Graph#dependencies_of(item)` | Direct dependencies of an item |
+| `Graph#all_dependencies_of(item)` | All transitive dependencies |
+| `Graph#dependents_of(item)` | Items that directly depend on an item |
+| `Graph#path(from, to)` | Shortest dependency path (BFS), or nil |
+| `Graph#subgraph(*items)` | Extract a new graph with specified nodes |
+| `Graph#roots` | Nodes with no dependencies |
+| `Graph#leaves` | Nodes with no dependents |
+| `Graph#depth(item)` | Maximum dependency depth of a node |
 
 ## Development
 

data/lib/philiprehberger/dependency_graph/graph.rb

@@ -105,8 +105,145 @@ module Philiprehberger
         found_cycles
       end
 
+      # Return direct dependencies of an item
+      #
+      # @param item [Object] the item to query
+      # @return [Array] direct dependencies, or empty array if item is unknown
+      def dependencies_of(item)
+        (@nodes[item] || []).dup
+      end
+
+      # Return all transitive dependencies of an item (direct + indirect)
+      #
+      # @param item [Object] the item to query
+      # @return [Array] all dependencies in no particular order
+      def all_dependencies_of(item)
+        return [] unless @nodes.key?(item)
+
+        visited = {}
+        queue = @nodes[item].dup
+        result = []
+
+        until queue.empty?
+          dep = queue.shift
+          next if visited[dep]
+
+          visited[dep] = true
+          result << dep
+          queue.concat(@nodes[dep] || [])
+        end
+
+        result
+      end
+
+      # Return items that directly depend on the given item (reverse lookup)
+      #
+      # @param item [Object] the item to query
+      # @return [Array] direct dependents
+      def dependents_of(item)
+        @nodes.each_with_object([]) do |(node, deps), acc|
+          acc << node if deps.include?(item)
+        end
+      end
+
+      # Find shortest dependency path between two nodes using BFS
+      #
+      # @param from [Object] the starting node
+      # @param to [Object] the target node
+      # @return [Array, nil] array of nodes forming the path, or nil if no path exists
+      def path(from, to)
+        return nil unless @nodes.key?(from) && @nodes.key?(to)
+        return [from] if from == to
+
+        visited = { from => nil }
+        queue = [from]
+
+        until queue.empty?
+          current = queue.shift
+          (@nodes[current] || []).each do |dep|
+            next if visited.key?(dep)
+
+            visited[dep] = current
+            if dep == to
+              return build_path(visited, from, to)
+            end
+
+            queue << dep
+          end
+        end
+
+        nil
+      end
+
+      # Extract a subgraph containing only the specified nodes and edges between them
+      #
+      # @param items [Array<Object>] nodes to include
+      # @return [Graph] a new graph with only the specified nodes
+      def subgraph(*items)
+        item_set = items.flatten.to_h { |i| [i, true] }
+        new_graph = self.class.new
+
+        items.flatten.each do |item|
+          next unless @nodes.key?(item)
+
+          matching_deps = (@nodes[item] || []).select { |dep| item_set[dep] }
+          new_graph.add(item, depends_on: matching_deps)
+        end
+
+        new_graph
+      end
+
+      # Return nodes that have no dependencies
+      #
+      # @return [Array] root nodes
+      def roots
+        @nodes.select { |_node, deps| deps.empty? }.keys
+      end
+
+      # Return nodes with no dependents (no other node depends on them)
+      #
+      # @return [Array] leaf nodes
+      def leaves
+        depended_on = @nodes.values.flatten.uniq
+        @nodes.keys.reject { |node| depended_on.include?(node) }
+      end
+
+      # Calculate maximum dependency depth for a node (longest path from any root to this node)
+      #
+      # @param item [Object] the item to query
+      # @return [Integer] the depth, or 0 if the item is a root or unknown
+      def depth(item)
+        return 0 unless @nodes.key?(item)
+
+        memo = {}
+        compute_depth(item, memo)
+      end
+
       private
 
+      def build_path(visited, from, to)
+        path = [to]
+        current = to
+        while current != from
+          current = visited[current]
+          path.unshift(current)
+        end
+        path
+      end
+
+      def compute_depth(item, memo)
+        return memo[item] if memo.key?(item)
+
+        deps = @nodes[item] || []
+        memo[item] = if deps.empty?
+                       0
+                     else
+                       deps.map { |dep| compute_depth(dep, memo) }.max + 1
+                     end
+
+        memo[item]
+      end
+
       def detect_cycles(node, visited, stack, path, found_cycles)
         visited[node] = true
         stack[node] = true

data/lib/philiprehberger/dependency_graph/version.rb

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

metadata

@@ -1,17 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: philiprehberger-dependency_graph
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.2.0
 platform: ruby
 authors:
 - Philip Rehberger
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-03-31 00:00:00.000000000 Z
+date: 2026-04-04 00:00:00.000000000 Z
 dependencies: []
 description: Build and resolve dependency graphs using topological sort, detect cycles,
-  and generate parallel execution batches for concurrent task scheduling.
+  generate parallel execution batches, query dependencies and dependents, find shortest
+  paths, and extract subgraphs.
 email:
 - me@philiprehberger.com
 executables: []
@@ -24,11 +25,11 @@ files:
 - lib/philiprehberger/dependency_graph.rb
 - lib/philiprehberger/dependency_graph/graph.rb
 - lib/philiprehberger/dependency_graph/version.rb
-homepage: https://github.com/philiprehberger/rb-dependency-graph
+homepage: https://philiprehberger.com/open-source-packages/ruby/philiprehberger-dependency_graph
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/philiprehberger/rb-dependency-graph
+  homepage_uri: https://philiprehberger.com/open-source-packages/ruby/philiprehberger-dependency_graph
   source_code_uri: https://github.com/philiprehberger/rb-dependency-graph
   changelog_uri: https://github.com/philiprehberger/rb-dependency-graph/blob/main/CHANGELOG.md
   bug_tracker_uri: https://github.com/philiprehberger/rb-dependency-graph/issues