tangle 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5203984ea1bf3218c6ac6e2a84493af7feec46d2dda8f6005e8d24b5e81671db
-  data.tar.gz: b39938c50a2a828963af60ee6877dae048a52a5a83fb6e5ccadc3f2727cc66d0
+  metadata.gz: 49703932d4a9666672412e9861b5a6a5e771375b1d7147ccff6a76da283d76ea
+  data.tar.gz: bd1681a13bead0ee180e01447bfdab7d9041f033e968840c6124d2e794688f86
 SHA512:
-  metadata.gz: 5598f8494cee8dfdbbc6061ab2f00596fb70fd419872a8884182c21b0ad0c62c234c2ac766df1dadffa4cd6ce84b60b5a1b44f46cbc27782e162535252db89b2
-  data.tar.gz: c34f2d721e72680ffca31108d1b608b868912bc8b631f9abd7ea866335503e287ae9031660a8d2c1e2781a6ce9276c22d302001339522ddf18224b665838695f
+  metadata.gz: c649bf8ef9250797945c2fc378a639118689d41c531a45c2b5be9e997d8a670c8e30bffd958c573f31a03b81885c85a3f5d1e24a202fe4dd0be08d3cf8fffc8c
+  data.tar.gz: b0d0fde21a7e2f38bd99e787695c2f07098c02163485f02ec0bc17bd7a0a295f49eef72258324fa9c3ff1b514ead63c75451d0cd8ab462fa6b60efeb274d9faa

data/README.md

@@ -13,8 +13,6 @@ Tangle aims to untangle your graphs, by providing a set of classes for managing
 
 **Feature mixins**:
  * Connectedness
- * Ancestry
- * ~~Vertex ordering~~
  * ~~Coloring~~
  * ~~GraphViz~~
 

data/lib/tangle/directed/acyclic/graph.rb

@@ -1,13 +1,24 @@
 require 'tangle/directed/graph'
-require 'tangle/directed/acyclic/edge'
+require 'tangle/directed/acyclic/partial_order'
 
 module Tangle
   module Directed
     module Acyclic
-      #
       # A directed acyclic graph
       class Graph < Tangle::Directed::Graph
-        Edge = Tangle::Directed::Acyclic::Edge
+        # Return a topological ordering of a set of vertices, or all
+        # vertices in the graph.
+        def topological_ordering(*vertices)
+          PartialOrder[self, *vertices].sort!.map(&:vertex)
+        end
+
+        protected
+
+        def insert_edge(edge)
+          raise CyclicError if successor?(edge.head, edge.tail) ||
+                               predecessor?(edge.tail, edge.head)
+          super
+        end
       end
     end
   end

data/lib/tangle/directed/acyclic/partial_order.rb

@@ -0,0 +1,37 @@
+module Tangle
+  module Directed
+    module Acyclic
+      # Implement a Partial Order for vertices in a DAG.
+      class PartialOrder
+        include Comparable
+
+        # Wrap a set of vertices, or all vertices, in a graph
+        # in a parial ordering, such that the elements in the
+        # returned set are comparable by u <= v iff v is an
+        # ancestor of u.
+        def self.[](graph, *vertices)
+          vertices = graph.vertices if vertices.empty?
+          vertices.map { |vertex| new(graph, vertex) }
+        end
+
+        attr_reader :vertex
+
+        protected
+
+        attr_reader :graph
+
+        def initialize(graph, vertex)
+          @graph = graph
+          @vertex = vertex
+        end
+
+        def <=>(other)
+          raise RuntimeError unless graph == other.graph
+          return 0 if vertex == other.vertex
+          return -1 if graph.successor?(vertex, other.vertex)
+          1
+        end
+      end
+    end
+  end
+end

data/lib/tangle/directed/edge.rb

@@ -6,28 +6,32 @@ module Tangle
     # An edge in a directed graph
     #
     class Edge < Tangle::Edge
-      def parent?(vertex)
-        @parent == vertex
+      attr_reader :head, :tail
+
+      def head?(vertex)
+        @head == vertex
       end
 
-      def parent(_vertex = nil)
-        @parent
+      def tail?(vertex)
+        @tail == vertex
       end
 
-      def child?(vertex)
-        @child == vertex
+      def each_vertex(&block)
+        [@tail, @head].each(&block)
       end
 
-      def child(_vertex = nil)
-        @child
+      def to_s
+        "{#{@tail}-->#{@head}}"
       end
+      alias inspect to_s
 
-      protected
+      private
 
-      def with_vertices(child, parent = child)
-        @child = child
-        @parent = parent
+      def initialize_vertices(tail, head = tail)
         super
+        @tail = tail
+        @head = head
+        @vertices = { tail => head }
       end
     end
   end

data/lib/tangle/directed/graph.rb

@@ -7,7 +7,97 @@ module Tangle
     # A directed graph
     class Graph < Tangle::Graph
       Edge = Tangle::Directed::Edge
-      DEFAULT_MIXINS = [Tangle::Mixin::Ancestry].freeze
+      DEFAULT_MIXINS = [].freeze
+
+      # Return the incoming edges for +vertex+
+      def in_edges(vertex)
+        edges(vertex).select { |edge| edge.head?(vertex) }
+      end
+
+      # Return the direct predecessors of +vertex+
+      def direct_predecessors(vertex)
+        Set.new(in_edges(vertex).map(&:tail))
+      end
+
+      # Is +other+ a direct predecessor of +vertex+?
+      def direct_predecessor?(vertex, other)
+        direct_predecessors(vertex).include?(other)
+      end
+
+      # Return a breadth first enumerator for all predecessors
+      def predecessors(vertex)
+        vertex_enumerator(vertex, :direct_predecessors)
+      end
+
+      # Is +other+ a predecessor of +vertex+?
+      def predecessor?(vertex, other)
+        predecessors(vertex).include?(other)
+      end
+
+      # Return a subgraph with all predecessors of a +vertex+
+      def predecessor_subgraph(vertex, &selector)
+        subgraph(predecessors(vertex), &selector)
+      end
+
+      # Return the outgoing edges for +vertex+
+      def out_edges(vertex)
+        edges(vertex).select { |edge| edge.tail?(vertex) }
+      end
+
+      # Return the direct successors of +vertex+
+      def direct_successors(vertex)
+        Set.new(out_edges(vertex).map(&:head))
+      end
+
+      # Is +other+ a direct successor of +vertex+?
+      def direct_successor?(vertex, other)
+        direct_successors(vertex).include?(other)
+      end
+
+      # Return a breadth first enumerator for all successors
+      def successors(vertex)
+        vertex_enumerator(vertex, :direct_successors)
+      end
+
+      # Is +other+ a successor of +vertex+?
+      def successor?(vertex, other)
+        successors(vertex).include?(other)
+      end
+
+      # Return a subgraph with all successors of a +vertex+
+      def successor_subgraph(vertex, &selector)
+        subgraph(successors(vertex), &selector)
+      end
+
+      # Return the in degree for +vertex+
+      def in_degree(vertex)
+        in_edges(vertex).count
+      end
+
+      # Return the out degree for +vertex+
+      def out_degree(vertex)
+        out_edges(vertex).count
+      end
+
+      # Is +vertex+ a sink in the graph?
+      def sink?(vertex)
+        out_degree(vertex).zero?
+      end
+
+      # Is +vertex+ a source in the graph?
+      def source?(vertex)
+        in_degree(vertex).zero?
+      end
+
+      # Is +vertex+ internal in the graph?
+      def internal?(vertex)
+        !(sink?(vertex) || source?(vertex))
+      end
+
+      # Is the graph balanced?
+      def balanced?
+        vertices.all? { |vertex| in_degree(vertex) == out_degree(vertex) }
+      end
     end
   end
 end

data/lib/tangle/edge.rb

@@ -6,9 +6,10 @@ module Tangle
   # An edge in a graph, connecting two vertices
   #
   class Edge
-    extend Forwardable
     include Tangle::Mixin::Initialize
 
+    attr_reader :name
+
     # Create a new edge between vertices
     #
     # Edge.new(vtx1) => Edge (loop)
@@ -16,86 +17,43 @@ module Tangle
     #
     # End users should probably use Graph#add_edge instead.
     #
-    def initialize(vertex1, vertex2 = vertex1, graph: nil, name: nil, **kwargs)
+    def initialize(vertex1, vertex2 = vertex1, name: nil, **kwargs)
       @name = name
-      with_graph(graph)
-      with_vertices(vertex1, vertex2)
-
+      initialize_vertices(vertex1, vertex2)
       initialize_mixins(**kwargs)
-
-      validate_edge
     end
 
-    # Follow the edge from a vertex to the other end
-    #
-    # walk(vertex) => Vertex
-    #
-    def walk(from_vertex, selector: :other)
-      send(selector, from_vertex)
+    def [](from_vertex)
+      @vertices[from_vertex]
     end
 
-    # Return the other vertex for a vertex of this edge
-    #
-    def other(for_vertex)
-      raise RuntimeError unless @vertices.include?(for_vertex)
-
-      @vertices.find { |other| other != for_vertex } || for_vertex
+    def walk(from_vertex)
+      @vertices.fetch(from_vertex)
     end
 
-    # Clone an edge into another graph, replacing original vertices with
-    # their already prepared duplicates in the other graph. Returns nil if any
-    # of the vertices does not exist in the other graph.
-    # End users should probably use Graph#subgraph instead.
-    #
-    # clone_into(graph) => Edge or nil
-    #
-    # Raises an ArgumentError if graph would remain the same.
-    #
-    def clone_into(graph)
-      raise ArgumentError if graph == @graph
-
-      vertices = @vertices.map do |vertex|
-        graph.get_vertex(vertex.vertex_id)
-      end
-
-      clone.with_graph(graph).with_vertices(*vertices)
-    rescue KeyError
-      nil
-    end
-
-    def inspect
-      "#<#{self.class}: #{@vertices}>"
+    def to_s
+      vertex1, vertex2 = @vertices.keys
+      "{#{vertex1}<->#{vertex2}}"
     end
+    alias inspect to_s
 
-    def eql?(other)
-      @graph == other.graph && @vertices == other.vertices
+    def each_vertex(&block)
+      @vertices.each_key(&block)
     end
-    alias == eql?
-    alias === eql?
-    alias equal? eql?
-
-    attr_reader :name
-    attr_reader :graph
-    attr_reader :vertices
-
-    def_delegators :@vertices, :include?, :hash
-
-    protected
 
-    def with_graph(graph)
-      @graph = graph
-      self
+    def include?(vertex)
+      each_vertex.include?(vertex)
     end
 
-    def with_vertices(vertex1, vertex2 = vertex1)
-      @vertices = Set[vertex1, vertex2]
-      self
+    def loop?
+      @loop
     end
 
     private
 
-    def validate_edge
-      raise GraphError unless @vertices.all? { |vertex| vertex.graph == @graph }
+    def initialize_vertices(vertex1, vertex2 = vertex1)
+      @loop = vertex1 == vertex2
+      @vertices = { vertex1 => vertex2, vertex2 => vertex1 }.freeze
     end
   end
 end

data/lib/tangle/graph.rb

@@ -1,19 +1,19 @@
 require 'tangle/mixin'
-require 'tangle/vertex'
+require 'tangle/mixin/connectedness'
 require 'tangle/edge'
-require 'tangle/graph_private'
-require 'tangle/graph_protected'
+require 'tangle/graph_vertices'
+require 'tangle/graph_edges'
 
 module Tangle
   #
   # Base class for all kinds of graphs
   #
   class Graph
-    include Tangle::GraphPrivate
-    include Tangle::GraphProtected
+    include Tangle::GraphVertices
+    include Tangle::GraphEdges
     include Tangle::Mixin::Initialize
     Edge = Tangle::Edge
-    DEFAULT_MIXINS = [Tangle::Mixin::Connectedness].freeze
+    DEFAULT_MIXINS = Tangle::Mixin::Connectedness::MIXINS
 
     # Initialize a new graph, preloading it with vertices and edges
     #
@@ -31,7 +31,7 @@ module Tangle
     #
     def self.[](vertices, edges = {}, **kwargs)
       graph = new(**kwargs)
-      graph.add_vertices(vertices)
+      vertices.each { |vertex| graph.add_vertex(vertex) }
       edges.each { |from, to| graph.add_edge(from, to) }
       graph
     end
@@ -52,71 +52,7 @@ module Tangle
     def initialize(mixins: self.class::DEFAULT_MIXINS, **kwargs)
       initialize_vertices
       initialize_edges
-      initialize_mixins(mixins, **kwargs)
-    end
-
-    # Get all edges.
-    #
-    # edges => Array
-    #
-    def edges(vertex: nil, &selector)
-      edges = vertex.nil? ? @edges : @edges_by_vertex[vertex]
-      if block_given?
-        edges.select(&selector)
-      else
-        edges.to_a
-      end
-    end
-
-    # Add a new edge to the graph
-    #
-    # add_edge(vtx1, vtx2, ...) => Edge
-    #
-    def add_edge(*vertices, **kvargs)
-      vertices = vertices.map { |v| get_vertex(v) }
-      insert_edge(self.class::Edge.new(*vertices, graph: self, **kvargs))
-    end
-
-    # Get all vertices.
-    #
-    # vertices => Array
-    #
-    def vertices
-      if block_given?
-        @vertices_by_id.select { |_, vertex| yield(vertex) }
-      else
-        @vertices_by_id
-      end.values
-    end
-
-    # Add a new vertex to the graph
-    #
-    # add_vertex(...) => Vertex
-    #
-    # Optional named arguments:
-    #   name: unique name or label for vertex
-    #
-    def add_vertex(**kvargs)
-      insert_vertex(Vertex.new(graph: self, **kvargs))
-    end
-
-    def add_vertices(vertices)
-      case vertices
-      when Hash
-        vertices.each { |name, kwargs| add_vertex(name: name, **kwargs) }
-      else
-        vertices.each { |kwargs| add_vertex(**kwargs) }
-      end
-    end
-
-    def get_vertex(name_or_vertex)
-      case name_or_vertex
-      when Vertex
-        name_or_vertex
-      else
-        @vertices_by_name[name_or_vertex] ||
-          @vertices_by_id.fetch(name_or_vertex)
-      end
+      initialize_mixins(mixins: mixins, **kwargs)
     end
 
     # Return a subgraph, optionally filtered by a vertex selector block
@@ -126,12 +62,17 @@ module Tangle
     #
     # Unless a selector is provided, the subgraph contains the entire graph.
     #
-    def subgraph(&selector)
-      clone.with_vertices(vertices(&selector)).with_edges(edges)
+    def subgraph(included = nil)
+      included ||= vertices
+      result = clone
+      vertices.each do |vertex|
+        result.remove_vertex(vertex) unless included.include?(vertex)
+        next unless block_given?
+        result.remove_vertex(vertex) unless yield(vertex)
+      end
+      result
     end
 
-    attr_reader :mixins
-
     def to_s
       "#<#{self.class}: #{vertices.count} vertices, #{edges.count} edges>"
     end

data/lib/tangle/graph_edges.rb

@@ -0,0 +1,49 @@
+require 'set'
+
+module Tangle
+  # Edge related methods in a graph
+  module GraphEdges
+    # Get all edges.
+    #
+    # edges => Array
+    #
+    def edges(vertex = nil)
+      return @edges if vertex.nil?
+      @vertices.fetch(vertex)
+    end
+
+    # Add a new edge to the graph
+    #
+    # add_edge(vtx1, vtx2, ...) => Edge
+    #
+    def add_edge(*vertices, **kvargs)
+      insert_edge(self.class::Edge.new(*vertices, mixins: @mixins, **kvargs))
+    end
+
+    # Remove an edge from the graph
+    def remove_edge(edge)
+      edge.each_vertex do |vertex|
+        @vertices.fetch(vertex).delete(edge)
+      end
+      @edges.delete(edge)
+    end
+
+    protected
+
+    # Insert a prepared edge into the graph
+    #
+    def insert_edge(edge)
+      @edges << edge
+      edge.each_vertex do |vertex|
+        @vertices.fetch(vertex) << edge
+      end
+      edge
+    end
+
+    private
+
+    def initialize_edges
+      @edges = Set[]
+    end
+  end
+end

data/lib/tangle/graph_vertices.rb

@@ -0,0 +1,53 @@
+require 'set'
+
+module Tangle
+  # Vertex related methods in a graph
+  module GraphVertices
+    # Return all vertices in the graph
+    def vertices
+      @vertices.keys
+    end
+
+    # Add a vertex into the graph
+    def add_vertex(vertex)
+      @vertices[vertex] = Set[]
+      self
+    end
+    alias << add_vertex
+
+    # Remove a vertex from the graph
+    def remove_vertex(vertex)
+      @vertices[vertex].each do |edge|
+        remove_edge(edge) if edge.include?(vertex)
+      end
+      @vertices.delete(vertex)
+    end
+
+    private
+
+    # Initialize vertex related attributes
+    def initialize_vertices
+      @vertices = {}
+    end
+
+    # Yield each reachable vertex to a block, breadth first
+    def each_vertex_breadth_first(start_vertex, walk_method)
+      remaining = [start_vertex]
+      remaining.each_with_object([]) do |vertex, history|
+        history << vertex
+        yield vertex
+        send(walk_method, vertex).each do |other|
+          remaining << other unless history.include?(other)
+        end
+      end
+    end
+
+    def vertex_enumerator(start_vertex, walk_method)
+      Enumerator.new do |yielder|
+        each_vertex_breadth_first(start_vertex, walk_method) do |vertex|
+          yielder << vertex
+        end
+      end
+    end
+  end
+end

data/lib/tangle/mixin/connectedness.rb

@@ -4,17 +4,28 @@ module Tangle
     # Mixins for adding connectedness features
     #
     module Connectedness
+      MIXINS = [Tangle::Mixin::Connectedness].freeze
       #
       # Mixin for adding connectedness to a graph
       #
       module Graph
+        # Two vertices are adjacent if there is an edge between them
+        def adjacent?(vertex, other)
+          edges(vertex).any? { |edge| edge[vertex] == other }
+        end
+
+        # Return the set of adjacent vertices
+        def adjacent(vertex)
+          Set.new(edges(vertex).map { |edge| edge.walk(vertex) })
+        end
+
         # Get the largest connected subgraph for a vertex.
         # Also aliased as :component and :connected_component
         #
         # connected_subgraph(vertex) => Graph
         #
         def connected_subgraph(vertex)
-          subgraph { |other| vertex.connected?(other) }
+          subgraph { |other| connected_vertices?(vertex, other) }
         end
         alias component connected_subgraph
         alias connected_component connected_subgraph
@@ -23,51 +34,33 @@ module Tangle
         # left after removing the connected subgraph.
         #
         def disconnected_subgraph(vertex)
-          subgraph { |other| !vertex.connected?(other) }
+          subgraph { |other| !connected_vertices?(vertex, other) }
         end
 
         # A graph is connected if all vertices are connected to all vertices
         # An empty graph is disconnected.
         #
-        def connected?
-          return false if vertices.empty?
+        def connected?(*tested_vertices)
+          tested_vertices = vertices if tested_vertices.empty?
+          return false if tested_vertices.empty?
 
-          vertices.combination(2).all? do |pair|
+          tested_vertices.combination(2).all? do |pair|
             this, that = pair.to_a
-            this.connected?(that)
+            reachable(this).any? { |other| other == that }
           end
         end
 
         # A graph is disconnected if any vertex is not connected to all other.
         # An empty graph is disconnected.
         #
-        def disconnected?
-          !connected?
-        end
-      end
-
-      #
-      # Mixin for adding connectedness to a vertex
-      #
-      module Vertex
-        # Two vertices are connected if there is a path between them,
-        # and a vertex is connected to itself.
-        #
-        def connected?(other)
-          raise GraphError unless @graph == other.graph
-          return true if self == other
-
-          connected_excluding?(other, Set[self])
+        def disconnected?(*tested_vertices)
+          !connected?(*tested_vertices)
         end
 
-        protected
-
-        def connected_excluding?(other, history)
-          return true if other.adjacent?(self)
-
-          (neighbours - history).any? do |vertex|
-            vertex.connected_excluding?(other, history << self)
-          end
+        # Return a breadth-first Enumerator for all reachable vertices,
+        # by transitive adjacency.
+        def reachable(start_vertex)
+          vertex_enumerator(start_vertex, :adjacent)
         end
       end
     end

data/lib/tangle/mixin.rb

@@ -1,28 +1,23 @@
-require 'tangle/mixin/ancestry'
-require 'tangle/mixin/connectedness'
-
 module Tangle
   module Mixin
     #
     # Mixin to initialize the dynamic mixin system
     #
     module Initialize
+      attr_reader :mixins
+
       private
 
-      def initialize_mixins(mixins = nil, **kwargs)
-        case klass = self.class.name[/[^:]+$/].to_sym
-        when :Graph
-          @mixins = mixins
-        else
-          mixins = @graph.mixins unless @graph.nil?
-        end
+      def initialize_mixins(mixins: nil, **kwargs)
+        @mixins = mixins
 
-        extend_with_mixins(klass, mixins) unless mixins.nil?
+        extend_with_mixins unless @mixins.nil?
         initialize_kwargs(**kwargs) unless kwargs.empty?
       end
 
-      def extend_with_mixins(klass, mixins)
-        mixins.each do |mixin|
+      def extend_with_mixins
+        klass = self.class.name[/[^:]+$/].to_sym
+        @mixins.each do |mixin|
           extend(mixin.const_get(klass)) if mixin.const_defined?(klass)
         end
       end

data/lib/tangle/simple/graph.rb

@@ -1,12 +1,17 @@
 require 'tangle/graph'
-require 'tangle/simple/edge'
 
 module Tangle
   module Simple
     #
     # A simple graph, without loops and multiple edges
     class Graph < Tangle::Graph
-      Edge = Tangle::Simple::Edge
+      protected
+
+      def insert_edge(edge)
+        raise LoopError if edge.loop?
+        raise MultiEdgeError if adjacent?(*edge.each_vertex)
+        super
+      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tangle
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Calle Englund
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-04-07 00:00:00.000000000 Z
+date: 2018-05-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: git-version-bump
@@ -99,22 +99,19 @@ files:
 - bin/console
 - bin/setup
 - lib/tangle.rb
-- lib/tangle/directed/acyclic/edge.rb
 - lib/tangle/directed/acyclic/graph.rb
+- lib/tangle/directed/acyclic/partial_order.rb
 - lib/tangle/directed/edge.rb
 - lib/tangle/directed/graph.rb
 - lib/tangle/edge.rb
 - lib/tangle/errors.rb
 - lib/tangle/graph.rb
-- lib/tangle/graph_private.rb
-- lib/tangle/graph_protected.rb
+- lib/tangle/graph_edges.rb
+- lib/tangle/graph_vertices.rb
 - lib/tangle/mixin.rb
-- lib/tangle/mixin/ancestry.rb
 - lib/tangle/mixin/connectedness.rb
-- lib/tangle/simple/edge.rb
 - lib/tangle/simple/graph.rb
 - lib/tangle/version.rb
-- lib/tangle/vertex.rb
 - tangle.gemspec
 homepage: https://github.com/notcalle/ruby-tangle
 licenses:

data/lib/tangle/directed/acyclic/edge.rb

@@ -1,20 +0,0 @@
-require 'tangle/directed/edge'
-
-module Tangle
-  module Directed
-    module Acyclic
-      #
-      # An edge in a directed acyclic graph
-      #
-      class Edge < Tangle::Directed::Edge
-        private
-
-        def validate_edge
-          super
-          raise CyclicError if @parent.ancestor?(@child) ||
-                               @child.descendant?(@parent)
-        end
-      end
-    end
-  end
-end

data/lib/tangle/graph_private.rb

@@ -1,31 +0,0 @@
-module Tangle
-  #
-  # The private bits of Graph
-  #
-  module GraphPrivate
-    private
-
-    def initialize_vertices
-      @vertices_by_id = {}
-      @vertices_by_name = {}
-      @edges_by_vertex = {}
-    end
-
-    def initialize_edges
-      @edges = []
-    end
-
-    def clone_vertices_into(graph, &selector)
-      vertices(&selector).each do |vertex|
-        graph.insert_vertex(vertex.clone_into(graph))
-      end
-    end
-
-    def clone_edges_into(graph)
-      edges.each do |edge|
-        new_edge = edge.clone_into(graph)
-        graph.insert_edge(new_edge) unless new_edge.nil?
-      end
-    end
-  end
-end

data/lib/tangle/graph_protected.rb

@@ -1,49 +0,0 @@
-module Tangle
-  #
-  # The protected bits of Graph
-  #
-  module GraphProtected
-    protected
-
-    # Insert a prepared vertex into the graph
-    #
-    def insert_vertex(vertex)
-      raise ArgumentError unless vertex.graph.eql?(self)
-
-      @edges_by_vertex[vertex] = []
-      @vertices_by_name[vertex.name] = vertex unless vertex.name.nil?
-      @vertices_by_id[vertex.vertex_id] = vertex
-    end
-
-    # Insert a prepared edge into the graph
-    #
-    def insert_edge(edge)
-      raise ArgumentError unless edge.graph.eql?(self)
-
-      @edges << edge
-      edge.vertices.each do |vertex|
-        @edges_by_vertex[vertex] << edge
-      end
-      edge
-    end
-
-    def with_vertices(vertices = [])
-      initialize_vertices
-
-      vertices.each do |vertex|
-        insert_vertex(vertex.clone_into(self))
-      end
-      self
-    end
-
-    def with_edges(edges = [])
-      initialize_edges
-
-      edges.each do |edge|
-        new_edge = edge.clone_into(self)
-        insert_edge(new_edge) unless new_edge.nil?
-      end
-      self
-    end
-  end
-end

data/lib/tangle/mixin/ancestry.rb

@@ -1,78 +0,0 @@
-require 'tangle/mixin/connectedness'
-
-module Tangle
-  module Mixin
-    #
-    # Mixin for adding ancestry features
-    #
-    module Ancestry
-      #
-      # Mixins for adding ancestry relations to a digraph
-      #
-      module Graph
-        include Tangle::Mixin::Connectedness::Graph
-
-        def ancestor_subgraph(vertex, &selector)
-          vertex = get_vertex(vertex) unless vertex.is_a? Vertex
-          clone.with_vertices(vertex.ancestors(&selector)).with_edges(edges)
-        end
-
-        def descendant_subgraph(vertex, &selector)
-          vertex = get_vertex(vertex) unless vertex.is_a? Vertex
-          clone.with_vertices(vertex.descendants(&selector)).with_edges(edges)
-        end
-      end
-
-      #
-      # Mixins for adding ancestry relations to vertices in a digraph
-      #
-      module Vertex
-        include Tangle::Mixin::Connectedness::Vertex
-
-        def parent_edges
-          @graph.edges(vertex: self) { |edge| edge.child?(self) }
-        end
-
-        def parents
-          neighbours(parent_edges)
-        end
-
-        def ancestors
-          result = [self] + parents.flat_map(&:ancestors)
-          return result unless block_given?
-          result.select(&:yield)
-        end
-
-        def parent?(other)
-          @graph.edges.any? { |edge| edge.child?(self) && edge.parent?(other) }
-        end
-
-        def ancestor?(other)
-          other == self || parents.any? { |parent| parent.ancestor?(other) }
-        end
-
-        def child_edges
-          @graph.edges(vertex: self) { |edge| edge.parent?(self) }
-        end
-
-        def children
-          neighbours(child_edges)
-        end
-
-        def child?(other)
-          @graph.edges.any? { |edge| edge.parent?(self) && edge.child?(other) }
-        end
-
-        def descendants
-          result = [self] + children.flat_map(&:descendants)
-          return result unless block_given?
-          result.select(&:yield)
-        end
-
-        def descendant?(other)
-          other == self || children.any? { |child| child.descendant?(other) }
-        end
-      end
-    end
-  end
-end

data/lib/tangle/simple/edge.rb

@@ -1,18 +0,0 @@
-require 'tangle/edge'
-
-module Tangle
-  module Simple
-    #
-    # An edge in a simple graph, with no loops or multiedges
-    #
-    class Edge < Tangle::Edge
-      private
-
-      def validate_edge
-        super
-        raise LoopError unless @vertices.count == 2
-        raise MultiEdgeError if @graph.edges.include? self
-      end
-    end
-  end
-end

data/lib/tangle/vertex.rb

@@ -1,104 +0,0 @@
-require 'delegate'
-require 'pp'
-require 'tangle/mixin'
-
-module Tangle
-  #
-  # A named vertex in a graph
-  #
-  class Vertex
-    include Tangle::Mixin::Initialize
-
-    # Create a new vertex
-    #
-    # Vertex.new(...) => Vertex
-    #
-    # Named arguments:
-    #   graph: a Graph or nil for an orphaned vertex
-    #   name: anything that's hashable and unique within the graph
-    #
-    def initialize(graph: nil,
-                   name: nil,
-                   vertex_id: object_id,
-                   **kwargs)
-      @graph = graph
-      @name = name
-      @vertex_id = vertex_id
-
-      initialize_mixins(**kwargs)
-    end
-
-    # Clone a vertex in a new graph, keeping all other contained attributes
-    # End users should probably use Graph#subgraph instead.
-    #
-    # clone_into(new_graph) => Vertex
-    #
-    # Raises an ArgumentError if graph would remain the same.
-    #
-    def clone_into(graph)
-      raise ArgumentError if graph == @graph
-
-      clone.with_graph(graph)
-    end
-
-    # Return all edges that touch this vertex
-    #
-    def edges
-      return [] if @graph.nil?
-
-      @graph.edges(vertex: self)
-    end
-
-    # Return the set of adjacent vertices
-    #
-    def neighbours(included = edges)
-      Set.new(included.map { |edge| edge.walk(self) })
-    end
-
-    # If two vertices have the same vertex_id, they have the same value
-    #
-    def ==(other)
-      @vertex_id == other.vertex_id
-    end
-
-    # If two vertices have the same vertex_id, they have the same value
-    #
-    def !=(other)
-      @vertex_id != other.vertex_id
-    end
-
-    # If two vertices have the same object_id, they are identical
-    #
-    def eql?(other)
-      @object_id == other.object_id
-    end
-
-    # Two vertices are adjacent if there is an edge between them
-    #
-    def adjacent?(other)
-      raise GraphError unless @graph == other.graph
-      edges.any? { |edge| edge.walk(self) == other }
-    end
-
-    attr_reader :graph
-    attr_reader :name
-    attr_reader :vertex_id
-
-    def to_s
-      values = {
-        class: self.class,
-        ident: name.nil? ? format('0x%x', vertex_id) : "'#{name}'",
-        n_edges: edges.count
-      }
-      format('#<%<class>s:%<ident>s: %<n_edges>d edges>', values)
-    end
-    alias inspect to_s
-
-    protected
-
-    def with_graph(graph)
-      @graph = graph
-      self
-    end
-  end
-end