simple_dag 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fa2d29444d0ba1fc5d58a978b2155b6ae935bbab
+  data.tar.gz: 169ecd6b74d0dbcb692be5d7d31451a962acefbf
+SHA512:
+  metadata.gz: bfec6a34670faf8dfc41cb179e8a77c2aa5185f7810d380072bce9fd2295b457a4dd7c56e9cb8577b5e8fc03a56992d03f6ea842b5e6f163e7db70932e5eddd8
+  data.tar.gz: e4efddca431809b0e28e04cfa80b7eb30e170242e33f12c4fc3653e329c727d6fddb615d1f4a88deaa1771839929c2efb2c0431a023373519d0820fac90f1a39

data/.rspec

@@ -0,0 +1,3 @@
+--color
+-Ilib
+

data/.yardopts

@@ -0,0 +1 @@
+--no-private

data/CONTRIBUTING.md

@@ -0,0 +1,6 @@
+# Style
+
+Please use Rubocop with default settings as a beautifier. In the atom ide, for
+instance, it can be used in combination with the package atom-beautify.
+
+Also use a maximal line length of 80 characters. 

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/Gemfile.lock

@@ -0,0 +1,33 @@
+PATH
+  remote: .
+  specs:
+    simple_dag (0.0.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.2.5)
+    rake (10.4.2)
+    rspec (3.1.0)
+      rspec-core (~> 3.1.0)
+      rspec-expectations (~> 3.1.0)
+      rspec-mocks (~> 3.1.0)
+    rspec-core (3.1.7)
+      rspec-support (~> 3.1.0)
+    rspec-expectations (3.1.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.1.0)
+    rspec-mocks (3.1.3)
+      rspec-support (~> 3.1.0)
+    rspec-support (3.1.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rake (~> 10)
+  rspec (~> 3)
+  simple_dag!
+
+BUNDLED WITH
+   1.16.1

data/LICENSE

@@ -0,0 +1,23 @@
+MIT License
+
+Copyright (c) 2013 Kevin Rutherford
+
+Modified work Copyright 2018 Fabian Sobanski
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,124 @@
+# DAG
+
+Simple directed acyclic graphs for Ruby.
+
+## History
+
+This ruby gem started out as a fork of [kevinrutherford's dag implementation](https://github.com/kevinrutherford/dag). If you want to migrate
+from his implementation to this one, have a look at the
+[breaking changes](#breaking-changes). Have a look at
+[performance improvements](#performance-improvements) to see why you might
+want to migrate.
+
+## Installation
+
+Install the gem
+
+```
+gem install simple_dag
+```
+
+Or add it to your Gemfile and run `bundle`.
+
+``` ruby
+gem 'simple_dag'
+```
+
+## Usage
+
+```ruby
+require 'simple_dag'
+
+dag = DAG.new
+
+v1 = dag.add_vertex
+v2 = dag.add_vertex
+v3 = dag.add_vertex
+
+dag.add_edge from: v1, to: v2
+dag.add_edge from: v2, to: v3
+
+v1.path_to?(v3)                  # => true
+v3.path_to?(v1)                  # => false
+
+dag.add_edge from: v3, to: v1        # => ArgumentError: A DAG must not have cycles
+
+dag.add_edge from: v1, to: v2        # => ArgumentError: Edge already exists
+dag.add_edge from: v1, to: v3
+v1.successors                        # => [v2, v3]
+```
+
+See the specs for more detailed usage scenarios.
+
+## Compatibility
+
+Tested with Ruby 2.2, 2.3, 2.4, 2.5, JRuby, Rubinius.
+Builds with Ruby 2.5 and JRuby are currently failing. See
+[this issue](https://github.com/fsobanski/dag/issues/1) for details.
+
+## Differences to [dag](https://github.com/kevinrutherford/dag)
+
+### Breaking changes
+
+- The function `DAG::Vertex#has_path_to?` aliased as
+`DAG::Vertex#has_descendant?` and `DAG::Vertex#has_descendent?` has been renamed
+to `DAG::Vertex#path_to?`. The aliases have been removed.
+
+- The function `DAG::Vertex#has_ancestor?` aliased as
+`DAG::Vertex#is_reachable_from?` has been renamed to
+`DAG::Vertex#reachable_from?`. The aliases have been removed.
+
+- The array of edges returned by `DAG#edges` is no longer sorted by insertion
+order of the edges.
+
+- `DAG::Vertex#path_to?` and `DAG::Vertex#reachable_from?` no longer raise
+errors if the vertex passed as an argument is not a vertex in the same `DAG`.
+Instead, they just return `false`.
+
+- [Parallel edges](https://en.wikipedia.org/wiki/Multiple_edges) are no longer
+allowed in the dag. Instead, `DAG#add_edge` raises an `ArgumentError` if you
+try to add an edge between two adjacent vertices. If you want to model a
+multigraph, you can add a weight payload to the edges that contains a natural
+number.
+
+### New functions
+
+- `DAG#topological_sort` returns a topological sort of the vertices in the dag
+in a theoretically optimal computational time complexity.
+
+- `DAG#enumerated_edges` returns an `Enumerator` of the edges in the dag.
+
+### Performance improvements
+
+- The computational complexity of `DAG::Vertex#outgoing_edges` has
+improved to a constant because the edges are no longer stored in one array in
+the `DAG`. Instead, the edges are now stored in their respective source
+`Vertex`.
+
+- The performance of `DAG::Vertex#successors` has improved because firstly,
+it depends on `DAG::Vertex#outgoing_edges` and secondly the call to
+`Array#uniq` is no longer necessary since parallel edges are prohibited.
+
+- The computational complexities of `DAG::Vertex#descendants`,
+`DAG::Vertex#path_to?` and `DAG::Vertex#reachable_from?` have improved because
+the functions depend on `DAG::Vertex#successors`.
+
+- The computational complexity of `DAG::Vertex#incoming_edges` is
+unchanged: Linear in the number of all edges in the `DAG`.
+
+- The performance of `DAG::Vertex#predecessors` has improved because the call
+to `Array#uniq` is no longer necessary since parallel edges are prohibited.
+
+- The performance of `DAG::Vertex#ancestors` has improved because the function
+depends on `DAG::Vertex#predecessors`.
+
+- The computational complexity of `DAG::add_edge` has improved because the
+cycle check in the function depends on `DAG::Vertex#path_to?`.
+
+- The performance of `DAG#subgraph` has improved because the function depends
+on `DAG::Vertex#descendants`, `DAG::Vertex#ancestors` and `DAG::add_edge`.
+
+- The computational complexity of `DAG::edges` has worsened from a constant
+complexity to a linear complexity. This is irrelevant if you want to iterate
+over all the edges in the graph. You should consider using
+`DAG#enumerated_edges` for a better space utilization.

data/Rakefile

@@ -0,0 +1,6 @@
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new('spec')
+
+task :default => :spec
+

data/lib/simple_dag/vertex.rb

@@ -0,0 +1,102 @@
+require 'set'
+
+class DAG
+  class Vertex
+    attr_reader :dag, :payload, :outgoing_edges
+
+    def initialize(dag, payload)
+      @dag = dag
+      @payload = payload
+      @outgoing_edges = []
+    end
+
+    private :initialize
+
+    def incoming_edges
+      @dag.enumerated_edges.select { |e| e.destination == self }
+    end
+
+    def predecessors
+      incoming_edges.map(&:origin)
+    end
+
+    def successors
+      @outgoing_edges.map(&:destination)
+    end
+
+    def inspect
+      "DAG::Vertex:#{@payload.inspect}"
+    end
+
+    #
+    # Is there a path from here to +other+ following edges in the DAG?
+    #
+    # @param [DAG::Vertex] another Vertex is the same DAG
+    # @raise [ArgumentError] if +other+ is not a Vertex
+    # @return true iff there is a path following edges within this DAG
+    #
+    def path_to?(other)
+      raise ArgumentError, 'You must supply a vertex' unless other.is_a? Vertex
+      visited = Set.new
+
+      visit = lambda { |v|
+        return false if visited.include? v
+        return true if v.successors.lazy.include? other
+        return true if v.successors.lazy.any? { |succ| visit.call succ }
+        visited.add v
+        false
+      }
+
+      visit.call self
+    end
+
+    #
+    # Is there a path from +other+ to here following edges in the DAG?
+    #
+    # @param [DAG::Vertex] another Vertex is the same DAG
+    # @raise [ArgumentError] if +other+ is not a Vertex
+    # @return true iff there is a path following edges within this DAG
+    #
+    def reachable_from?(other)
+      raise ArgumentError, 'You must supply a vertex' unless other.is_a? Vertex
+      other.path_to? self
+    end
+
+    #
+    # Retrieve a value from the vertex's payload.
+    # This is a shortcut for vertex.payload[key].
+    #
+    # @param key [Object] the payload key
+    # @return the corresponding value from the payload Hash, or nil if not found
+    #
+    def [](key)
+      @payload[key]
+    end
+
+    def ancestors(result_set = Set.new)
+      predecessors.each do |v|
+        unless result_set.include? v
+          result_set.add(v)
+          v.ancestors(result_set)
+        end
+      end
+      result_set
+    end
+
+    def descendants(result_set = Set.new)
+      successors.each do |v|
+        unless result_set.include? v
+          result_set.add(v)
+          v.descendants(result_set)
+        end
+      end
+      result_set
+    end
+
+    private
+
+    def add_edge(destination, properties)
+      Edge.new(self, destination, properties).tap { |e| @outgoing_edges << e }
+    end
+  end
+end

data/lib/simple_dag.rb

@@ -0,0 +1,139 @@
+require 'set'
+
+require_relative 'simple_dag/vertex'
+
+class DAG
+  Edge = Struct.new(:origin, :destination, :properties)
+
+  attr_reader :vertices
+
+  #
+  # Create a new Directed Acyclic Graph
+  #
+  # @param [Hash] options configuration options
+  # @option options [Module] mix this module into any created +Vertex+
+  #
+  def initialize(options = {})
+    @vertices = []
+    @mixin = options[:mixin]
+    @n_of_edges = 0
+  end
+
+  def add_vertex(payload = {})
+    Vertex.new(self, payload).tap do |v|
+      v.extend(@mixin) if @mixin
+      @vertices << v
+    end
+  end
+
+  def add_edge(attrs)
+    origin = attrs[:origin] || attrs[:source] || attrs[:from] || attrs[:start]
+    destination = attrs[:destination] || attrs[:sink] || attrs[:to] ||
+                  attrs[:end]
+    properties = attrs[:properties] || {}
+    raise ArgumentError, 'Origin must be a vertex in this DAG' unless
+      my_vertex?(origin)
+    raise ArgumentError, 'Destination must be a vertex in this DAG' unless
+      my_vertex?(destination)
+    raise ArgumentError, 'Edge already exists' if
+      origin.successors.include? destination
+    raise ArgumentError, 'A DAG must not have cycles' if origin == destination
+    raise ArgumentError, 'A DAG must not have cycles' if
+      destination.path_to?(origin)
+    @n_of_edges += 1
+    origin.send :add_edge, destination, properties
+  end
+
+  # @return Enumerator over all edges in the dag
+  def enumerated_edges
+    Enumerator.new(@n_of_edges) do |e|
+      @vertices.each { |v| v.outgoing_edges.each { |out| e << out } }
+    end
+  end
+
+  def edges
+    enumerated_edges.to_a
+  end
+
+  def subgraph(predecessors_of = [], successors_of = [])
+    (predecessors_of + successors_of).each do |v|
+      raise ArgumentError, 'You must supply a vertex in this DAG' unless
+        my_vertex?(v)
+    end
+
+    result = self.class.new(mixin: @mixin)
+    vertex_mapping = {}
+
+    # Get the set of predecessors verticies and add a copy to the result
+    predecessors_set = Set.new(predecessors_of)
+    predecessors_of.each { |v| v.ancestors(predecessors_set) }
+
+    predecessors_set.each do |v|
+      vertex_mapping[v] = result.add_vertex(v.payload)
+    end
+
+    # Get the set of successor vertices and add a copy to the result
+    successors_set = Set.new(successors_of)
+    successors_of.each { |v| v.descendants(successors_set) }
+
+    successors_set.each do |v|
+      vertex_mapping[v] = result.add_vertex(v.payload) unless
+        vertex_mapping.include? v
+    end
+
+    # get the unique edges
+    edge_set = (
+      predecessors_set.flat_map(&:incoming_edges) +
+      successors_set.flat_map(&:outgoing_edges)
+    ).uniq
+
+    # Add them to the result via the vertex mapping
+    edge_set.each do |e|
+      result.add_edge(
+        from: vertex_mapping[e.origin],
+        to: vertex_mapping[e.destination],
+        properties: e.properties
+      )
+    end
+
+    result
+  end
+
+  # Returns an array of the vertices in the graph in a topological order, i.e.
+  # for every path in the dag from a vertex v to a vertex u, v comes before u
+  # in the array.
+  #
+  # Uses a depth first search.
+  #
+  # Assuming that the method include? of class Set runs in linear time, which
+  # can be assumed in all practical cases, this method runs in O(n+m) where
+  # m is the number of edges and n is the number of vertices.
+  def topological_sort
+    result_size = 0
+    result = Array.new(@vertices.length)
+    visited = Set.new
+
+    visit = lambda { |v|
+      return if visited.include? v
+      v.successors.each do |u|
+        visit.call u
+      end
+      visited.add v
+      result_size += 1
+      result[-result_size] = v
+    }
+
+    @vertices.each do |v|
+      next if visited.include? v
+      visit.call v
+    end
+
+    result
+  end
+
+  private
+
+  def my_vertex?(v)
+    v.is_a?(Vertex) && (v.dag == self)
+  end
+end

data/spec/lib/simple_dag/vertex_spec.rb

@@ -0,0 +1,137 @@
+require 'spec_helper'
+
+describe DAG::Vertex do
+  let(:dag) { DAG.new }
+  subject { dag.add_vertex }
+  let(:v1) { dag.add_vertex(name: :v1) }
+  let(:v2) { dag.add_vertex(name: :v2) }
+  let(:v3) { dag.add_vertex(name: 'v3') }
+
+  describe '#path_to?' do
+    it 'cannot have a path to a non-vertex' do
+      expect { subject.path_to?(23) }.to raise_error(ArgumentError)
+    end
+
+    it 'cannot have a path to a vertex in a different DAG' do
+      expect(subject.path_to?(DAG.new.add_vertex)).to be_falsey
+    end
+  end
+
+  describe '#reachable_from?' do
+    it 'ancestors must be a vertex' do
+      expect { subject.reachable_from?(23) }.to raise_error(ArgumentError)
+    end
+
+    it 'ancestors must be in the same DAG' do
+      expect(subject.reachable_from?(DAG.new.add_vertex)).to be_falsey
+    end
+  end
+
+  describe 'with a payload' do
+    subject { dag.add_vertex(name: 'Fred', size: 34) }
+
+    it 'allows the payload to be accessed' do
+      expect(subject[:name]).to eq('Fred')
+      expect(subject[:size]).to eq(34)
+      expect(subject.payload).to eq(name: 'Fred', size: 34)
+    end
+
+    it 'returns nil for missing payload key' do
+      expect(subject[56]).to be_nil
+    end
+
+    it 'allows the payload to be changed' do
+      subject.payload[:another] = 'ha'
+      expect(subject[:another]).to eq('ha')
+    end
+  end
+
+  context 'with predecessors' do
+    before do
+      dag.add_edge from: v1, to: subject
+      dag.add_edge from: v2, to: subject
+    end
+
+    it 'has the correct predecessors' do
+      expect(subject.predecessors).to eq([v1, v2])
+    end
+
+    it 'has no successors' do
+      expect(subject.successors).to be_empty
+    end
+
+    it 'has no paths to its predecessors' do
+      expect(subject.path_to?(v1)).to be_falsey
+      expect(subject.path_to?(v2)).to be_falsey
+    end
+
+    context 'with multiple paths' do
+      it 'throws an exception' do
+        expect { dag.add_edge from: v1, to: subject }
+          .to raise_error(ArgumentError)
+      end
+    end
+
+    it 'has the correct ancestors' do
+      expect(subject.reachable_from?(v1)).to be_truthy
+      expect(subject.reachable_from?(v2)).to be_truthy
+      expect(subject.reachable_from?(v3)).to be_falsey
+    end
+  end
+
+  context 'with successors' do
+    before do
+      dag.add_edge from: subject, to: v1
+      dag.add_edge from: subject, to: v2
+    end
+
+    it 'has no predecessors' do
+      expect(subject.predecessors).to be_empty
+    end
+
+    it 'has the correct successors' do
+      expect(subject.successors).to eq([v1, v2])
+    end
+
+    it 'has paths to its successors' do
+      expect(subject.path_to?(v1)).to be_truthy
+      expect(subject.path_to?(v2)).to be_truthy
+    end
+
+    it 'has no ancestors' do
+      expect(subject.reachable_from?(v1)).to be_falsey
+      expect(subject.reachable_from?(v2)).to be_falsey
+    end
+  end
+
+  context 'in a deep DAG' do
+    before do
+      dag.add_edge from: subject, to: v1
+      dag.add_edge from: v1, to: v2
+    end
+
+    it 'has a deep path to v2' do
+      expect(subject.path_to?(v2)).to be_truthy
+    end
+
+    it 'has no path to v3' do
+      expect(subject.path_to?(v3)).to be_falsey
+    end
+
+    it 'recognises that it is an ancestor of v2' do
+      expect(v2.reachable_from?(subject)).to be_truthy
+    end
+
+    it 'is known to all descendants' do
+      expect(v2.ancestors).to eq(Set.new([v1, subject]))
+    end
+
+    it 'knows has no ancestors' do
+      expect(subject.ancestors).to eq(Set.new)
+    end
+
+    it 'knows has all descendants' do
+      expect(subject.descendants).to eq(Set.new([v1, v2]))
+    end
+  end
+end

data/spec/lib/simple_dag_spec.rb

@@ -0,0 +1,231 @@
+require 'spec_helper'
+
+describe DAG do
+  it 'when new' do
+    expect(subject.vertices).to be_empty
+    expect(subject.enumerated_edges.size).to eq(0)
+  end
+
+  context 'with one vertex' do
+    it 'has only that vertex' do
+      v = subject.add_vertex
+      expect(subject.vertices).to eq([v])
+    end
+
+    it 'has no edges' do
+      v = subject.add_vertex
+      expect(v.outgoing_edges).to be_empty
+      expect(v.incoming_edges).to be_empty
+    end
+  end
+
+  context 'using a mix-in module' do
+    subject { DAG.new(mixin: Thing) }
+    let(:v) { subject.add_vertex(name: 'Fred') }
+
+    module Thing
+      def my_name
+        payload[:name]
+      end
+    end
+
+    it 'mixes the module into evey vertex' do
+      expect(v.is_a?(Thing)).to be_truthy
+    end
+
+    it 'allows the module to access the payload' do
+      expect(v.my_name).to eq('Fred')
+    end
+  end
+
+  context 'creating an edge' do
+    let(:v1) { subject.add_vertex }
+
+    context 'when valid' do
+      let(:v2) { subject.add_vertex }
+      let!(:e1) do
+        subject.add_edge(from: v1, to: v2, properties: { foo: 'bar' })
+      end
+
+      it 'leaves the origin vertex' do
+        expect(v1.outgoing_edges).to eq([e1])
+      end
+
+      it 'arrives at the destination vertex' do
+        expect(v2.incoming_edges).to eq([e1])
+      end
+
+      it 'adds no other edges' do
+        expect(v1.incoming_edges).to be_empty
+        expect(v2.outgoing_edges).to be_empty
+      end
+
+      it 'can specify properties' do
+        expect(e1.properties[:foo]).to eq('bar')
+      end
+    end
+
+    context 'when invalid' do
+      it 'requires an origin vertex' do
+        expect { subject.add_edge(to: v1) }.to raise_error(ArgumentError)
+      end
+
+      it 'requires a destination vertex' do
+        expect { subject.add_edge(from: v1) }.to raise_error(ArgumentError)
+      end
+
+      it 'requires the endpoints to be vertices' do
+        expect { subject.add_edge(from: v1, to: 23) }
+          .to raise_error(ArgumentError)
+        expect { subject.add_edge(from: 45, to: v1) }
+          .to raise_error(ArgumentError)
+      end
+
+      it 'requires the endpoints to be in the same DAG' do
+        v2 = DAG.new.add_vertex
+        expect { subject.add_edge(from: v1, to: v2) }
+          .to raise_error(ArgumentError)
+        expect { subject.add_edge(from: v2, to: v1) }
+          .to raise_error(ArgumentError)
+      end
+
+      it 'rejects an edge that would create a loop' do
+        v2 = subject.add_vertex
+        v3 = subject.add_vertex
+        v4 = subject.add_vertex
+        subject.add_edge from: v1, to: v2
+        subject.add_edge from: v2, to: v3
+        subject.add_edge from: v3, to: v4
+        expect { subject.add_edge from: v4, to: v1 }
+          .to raise_error(ArgumentError)
+      end
+
+      it 'rejects an edge from a vertex to itself' do
+        expect { subject.add_edge from: v1, to: v1 }
+          .to raise_error(ArgumentError)
+      end
+    end
+
+    context 'with different keywords' do
+      let(:v1) { subject.add_vertex }
+      let(:v2) { subject.add_vertex }
+
+      it 'allows :origin and :destination' do
+        expect { subject.add_edge(origin: v1, destination: v2) }
+          .to_not raise_error
+      end
+    end
+
+    context 'with different keywords' do
+      let(:v1) { subject.add_vertex }
+      let(:v2) { subject.add_vertex }
+
+      it 'allows :source and :sink' do
+        expect { subject.add_edge(source: v1, sink: v2) }.to_not raise_error
+      end
+    end
+
+    context 'with different keywords' do
+      let(:v1) { subject.add_vertex }
+      let(:v2) { subject.add_vertex }
+
+      it 'allows :from and :to' do
+        expect { subject.add_edge(from: v1, to: v2) }
+          .to_not raise_error
+      end
+    end
+
+    context 'with different keywords' do
+      let(:v1) { subject.add_vertex }
+      let(:v2) { subject.add_vertex }
+
+      it 'allows :start and :end' do
+        expect { subject.add_edge(start: v1, end: v2) }.to_not raise_error
+      end
+    end
+  end
+
+  context 'given a dag' do
+    subject { DAG.new(mixin: Thing) }
+    module Thing
+      def my_name
+        payload[:name]
+      end
+    end
+
+    let(:joe) { subject.add_vertex(name: 'joe') }
+    let(:bob) { subject.add_vertex(name: 'bob') }
+    let(:jane) { subject.add_vertex(name: 'jane') }
+    let(:ada) { subject.add_vertex(name: 'ada') }
+    let(:chris) { subject.add_vertex(name: 'chris') }
+    let!(:e1) do
+      subject.add_edge(origin: joe, destination: bob,
+                       properties: { name: 'father of' })
+    end
+    let!(:e2) { subject.add_edge(origin: joe, destination: jane) }
+    let!(:e3) { subject.add_edge(origin: bob, destination: jane) }
+    let!(:e4) { subject.add_edge(origin: ada, destination: joe) }
+    let!(:e5) { subject.add_edge(origin: jane, destination: chris) }
+
+    describe '.subgraph' do
+      it 'returns a graph' do
+        expect(subject.subgraph).to be_an_instance_of(DAG)
+      end
+
+      it 'of ada and her ancestors' do
+        subgraph = subject.subgraph([ada], [])
+        expect(subgraph.vertices.size).to eq(1)
+        expect(subgraph.vertices[0].my_name).to eq('ada')
+        expect(subgraph.enumerated_edges.size).to eq(0)
+      end
+
+      it 'of joe and his descendants' do
+        subgraph = subject.subgraph([], [joe])
+        expect(Set.new(subgraph.vertices.map(&:my_name)))
+          .to eq(Set.new(%w[joe bob jane chris]))
+        expect(subgraph.enumerated_edges.size).to eq(4)
+      end
+
+      it 'of Jane and her ancestors' do
+        subgraph = subject.subgraph([jane], [])
+        expect(Set.new(subgraph.vertices.map(&:my_name)))
+          .to eq(Set.new(%w[joe bob jane ada]))
+        expect(subgraph.enumerated_edges.size).to eq(4)
+      end
+
+      it 'of chris and his descendants' do
+        subgraph = subject.subgraph([], [chris])
+        expect(Set.new(subgraph.vertices.map(&:my_name)))
+          .to eq(Set.new(['chris']))
+        expect(subgraph.enumerated_edges.size).to eq(0)
+      end
+
+      it 'of bob and his descendants' do
+        subgraph = subject.subgraph([], [bob])
+        expect(Set.new(subgraph.vertices.map(&:my_name)))
+          .to eq(Set.new(%w[bob jane chris]))
+        expect(subgraph.enumerated_edges.size).to eq(2)
+      end
+
+      it 'there is something incestuous going on here' do
+        subgraph = subject.subgraph([bob], [bob])
+        expect(Set.new(subgraph.vertices.map(&:my_name)))
+          .to eq(Set.new(%w[bob jane joe ada chris]))
+        expect(subgraph.enumerated_edges.size).to eq(4)
+      end
+    end
+
+    describe '.topological_sort' do
+      it 'returns a correct topological sort' do
+        sort = subject.topological_sort
+        expect(sort).to be_an_instance_of(Array)
+        expect(sort.size).to eq(5)
+        expect(sort[0].my_name).to eq('ada')
+        expect(sort[1].my_name).to eq('joe')
+        expect(sort[2].my_name).to eq('bob')
+        expect(sort[3].my_name).to eq('jane')
+        expect(sort[4].my_name).to eq('chris')
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'simple_dag'

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: simple_dag
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Kevin Rutherford
+- Fabian Sobanski
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-01-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+description: A simple library for working with directed acyclic graphs
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".yardopts"
+- CONTRIBUTING.md
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- lib/simple_dag.rb
+- lib/simple_dag/vertex.rb
+- spec/lib/simple_dag/vertex_spec.rb
+- spec/lib/simple_dag_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/fsobanski/simple_dag
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.13
+signing_key: 
+specification_version: 4
+summary: Simple directed acyclic graphs
+test_files:
+- spec/lib/simple_dag/vertex_spec.rb
+- spec/lib/simple_dag_spec.rb
+- spec/spec_helper.rb