tangle 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 49ee5268eb1851a1087ba45efac9f00794a248dfce75aadab846f6617d91620e
-  data.tar.gz: cc4d0d76f99b86c5494758311637bcb4610555afb58118e059833f62992ef492
+  metadata.gz: dc791cdb0b95ae60507e9052e96b8c0c44550a1cde4ac88a5ab9be6661102044
+  data.tar.gz: bf20ee14175b42f5ae9e4675ca50d2c76937e1cc09493e7420a78eaf8885aa79
 SHA512:
-  metadata.gz: c785bb5d7b83a53db61c03ffff2b6a26c17659eb9f79868e4882c884d0e97339b8748d32778bd2e73bb5293b5dd3a9a9adfef22ff38ab9e0f2c1c660dc0dd09c
-  data.tar.gz: f042503d2a4d65f6f9ed4cce56e6ba94623ef6e57e73b306a690edce5d2276aa01a7e211d83a2d2aec096a85def0923e4c8da350eb417a37101217764c84c18e
+  metadata.gz: 3fba37c004a711c3ed33f6966853724023b5c1dbbe61d596342fa91259a46b490153147f16b12e01f8f9b5cc66156f34197fd91ff357c50e765afb8c8571f564
+  data.tar.gz: 0c18db46c410650ba81c4e90c891b1bedb19d0eb3e92079d68c709055883ac12b231162cd8235cbdb81fa4b7ab1bc7f4ad3d2281c0944a5c35387b2a8dc609c4

data/.gitignore

@@ -11,3 +11,4 @@
 .rspec_status
 /Gemfile.lock
 /vendor
+coverage

data/.rubocop.yml

@@ -1,3 +1,6 @@
+AllCops:
+  TargetRubyVersion: 2.3
+
 Metrics/BlockLength:
   Exclude:
     - 'spec/*_spec.rb'

data/Gemfile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 source 'https://rubygems.org'
 
 git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }

data/Rakefile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'bundler/setup'
 require 'bundler/gem_tasks'
 

data/bin/console

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 require 'bundler/setup'
 require 'tangle'

data/lib/tangle.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 require 'tangle/version'
 require 'tangle/errors'
-require 'tangle/graph'
-require 'tangle/simple/graph'
+require 'tangle/undirected/graph'
+require 'tangle/undirected/simple/graph'
 require 'tangle/directed/graph'
 require 'tangle/directed/acyclic/graph'
 
@@ -20,8 +22,9 @@ require 'tangle/directed/acyclic/graph'
 # => Directed graph with no edge cycles
 #
 module Tangle
-  MultiGraph = Tangle::Graph
-  SimpleGraph = Tangle::Simple::Graph
+  Graph = Tangle::Undirected::Graph
+  MultiGraph = Tangle::Undirected::Graph
+  SimpleGraph = Tangle::Undirected::Simple::Graph
   DiGraph = Tangle::Directed::Graph
   DAG = Tangle::Directed::Acyclic::Graph
 end

data/lib/tangle/base_graph.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require_relative 'currify'
+require_relative 'mixin'
+require_relative 'base_graph_protected'
+require_relative 'base_graph_private'
+
+module Tangle
+  #
+  # Abstract base class for (un)directed graphs
+  #
+  class BaseGraph
+    include Tangle::Currify
+    include Tangle::Mixin::Initialize
+    include Tangle::BaseGraphProtected
+    include Tangle::BaseGraphPrivate
+
+    # Initialize a new graph, preloading it with vertices and edges
+    #
+    # Graph[+vertices+] => Graph
+    # Graph[+vertices+, +edges+) => Graph
+    #
+    # When +vertices+ is a hash, it contains initialization kwargs as
+    # values and vertex names as keys. When +vertices+ is an array of
+    # initialization kwargs, the vertices will be be anonymous.
+    #
+    # +edges+ can contain an array of exactly two, either names of vertices
+    # or vertices.
+    #
+    # Any kwarg supported by Graph.new is also allowed.
+    #
+    def self.[](vertices, edges = {}, **kwargs)
+      graph = new(**kwargs)
+      vertices.each { |vertex| graph.add_vertex(vertex) }
+      edges.each { |from, to| graph.add_edge(from, to) }
+      graph
+    end
+
+    # Initialize a new graph, optionally preloading it with vertices and edges
+    #
+    # Graph.new() => Graph
+    # Graph.new(mixins: [MixinModule, ...], ...) => Graph
+    #
+    # +mixins+ is an array of modules that can be mixed into the various
+    # classes that makes up a graph. Initialization of a Graph, Vertex or Edge
+    # looks for submodules in each mixin, with the same name and extends
+    # any created object. Defaults to [Tangle::Mixin::Connectedness].
+    #
+    # Any subclass of Graph should also subclass Edge to manage its unique
+    # constraints.
+    #
+    def initialize(currify: false, mixins: [], **kwargs)
+      @currify = currify
+      initialize_vertices
+      initialize_edges
+      initialize_mixins(mixins: mixins, **kwargs)
+    end
+
+    # Return a subgraph, optionally filtered by a vertex selector block
+    #
+    # subgraph => Graph
+    # subgraph { |vertex| ... } => Graph
+    #
+    # Unless a selector is provided, the subgraph contains the entire graph.
+    #
+    def subgraph(included = nil, &selector)
+      result = clone
+      result.select_vertices!(included) unless included.nil?
+      result.select_vertices!(&selector) if block_given?
+      result
+    end
+
+    def to_s
+      "#<#{self.class}: #{vertices.count} vertices, #{edges.count} edges>"
+    end
+    alias inspect to_s
+
+    # Fetch a vertex by its name
+    def fetch(name)
+      @vertices_by_name.fetch(name)
+    end
+
+    # Return a named vertex
+    def [](name)
+      @vertices_by_name[name]
+    end
+
+    # Return all vertices in the graph
+    def vertices
+      @vertices.keys
+    end
+
+    # Select vertices in the graph
+    def select(&selector)
+      @vertices.each_key.select(&selector)
+    end
+
+    # Add a vertex into the graph
+    #
+    # If a name: is given, or the vertex responds to :name,
+    # it will be registered by name in the graph
+    def add_vertex(vertex, name: nil)
+      name ||= callback(vertex, :name)
+      insert_vertex(vertex, name)
+      define_currified_methods(vertex, :vertex) if @currify
+      callback(vertex, :added_to_graph, self)
+      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
+      delete_vertex(vertex)
+      callback(vertex, :removed_from_graph, self)
+    end
+
+    # Get all edges.
+    #
+    # edges => Array
+    #
+    def edges(vertex = nil)
+      return @edges if vertex.nil?
+      @vertices.fetch(vertex)
+    end
+    currify :vertex, :edges
+
+    # Add a new edge to the graph
+    #
+    # add_edge(vtx1, vtx2, ...) => Edge
+    #
+    def add_edge(*vertices, **kvargs)
+      edge = new_edge(*vertices, mixins: @mixins, **kvargs)
+      insert_edge(edge)
+      vertices.each { |vertex| callback(vertex, :edge_added, edge) }
+      edge
+    end
+
+    # Remove an edge from the graph
+    def remove_edge(edge)
+      delete_edge(edge)
+      edge.each_vertex { |vertex| callback(vertex, :edge_removed, edge) }
+    end
+  end
+end

data/lib/tangle/base_graph_private.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Tangle
+  #
+  # Private methods of BaseGraph
+  #
+  module BaseGraphPrivate
+    private
+
+    def callback(receiver, method, *args)
+      receiver.send(method, *args) if receiver.respond_to?(method)
+    end
+
+    # Initialize vertex related attributes
+    def initialize_vertices
+      @vertices = {}
+      @vertices_by_name = {}
+    end
+
+    def initialize_edges
+      @edges = Set[]
+    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/base_graph_protected.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Tangle
+  #
+  # Protected methods of BaseGraph
+  #
+  module BaseGraphProtected
+    protected
+
+    def select_vertices!(selected = nil)
+      vertices.each do |vertex|
+        delete_vertex(vertex) if block_given? && !yield(vertex)
+        next if selected.nil?
+        delete_vertex(vertex) unless selected.any? { |vtx| vtx.eql?(vertex) }
+      end
+    end
+
+    def insert_vertex(vertex, name = nil)
+      @vertices[vertex] = Set[]
+      @vertices_by_name[name] = vertex unless name.nil?
+    end
+
+    def delete_vertex(vertex)
+      @vertices[vertex].each do |edge|
+        delete_edge(edge) if edge.include?(vertex)
+      end
+      @vertices.delete(vertex)
+      @vertices_by_name.delete_if { |_, vtx| vtx.eql?(vertex) }
+    end
+
+    # Insert a prepared edge into the graph
+    #
+    def insert_edge(edge)
+      @edges << edge
+      edge.each_vertex { |vertex| @vertices.fetch(vertex) << edge }
+    end
+
+    def delete_edge(edge)
+      edge.each_vertex { |vertex| @vertices.fetch(vertex).delete(edge) }
+      @edges.delete(edge)
+    end
+  end
+end

data/lib/tangle/currify.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Tangle
+  # Currification of instance methods, for adding callbacks to other objects
+  module Currify
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    # Class method extensions for currification of instance methods
+    module ClassMethods
+      # Return a list of currified methods for a given tag.
+      #
+      # :call-seq:
+      #   self.class.currified_methods(tag) => Array of Symbol
+      def currified_methods(tag)
+        mine = @currified_methods&.[](tag) || []
+        return mine unless superclass.respond_to?(:currified_methods)
+        superclass.currified_methods(tag) + mine
+      end
+
+      private
+
+      # Add a symbol to the list of currified methods for a tag.
+      #
+      # :call-seq:
+      #   class X
+      #     currify :tag, :method
+      def currify(tag, method)
+        @currified_methods ||= {}
+        @currified_methods[tag] ||= []
+        @currified_methods[tag] << method
+      end
+    end
+
+    private
+
+    def define_currified_methods(obj, tag)
+      self.class.currified_methods(tag)&.each do |name|
+        obj.instance_exec(name, method(name).curry) do |method_name, method|
+          define_singleton_method(method_name) do |*args|
+            method.call(self, *args)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'tangle/directed/graph'
 require 'tangle/directed/acyclic/partial_order'
 

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Tangle
   module Directed
     module Acyclic

data/lib/tangle/directed/edge.rb

@@ -1,4 +1,6 @@
-require 'tangle/edge'
+# frozen_string_literal: true
+
+require_relative '../edge'
 
 module Tangle
   module Directed
@@ -31,7 +33,7 @@ module Tangle
         super
         @tail = tail
         @head = head
-        @vertices = { tail => head }
+        @vertices = { tail => head }.freeze
       end
     end
   end

data/lib/tangle/directed/graph.rb

@@ -1,103 +1,125 @@
-require 'tangle/graph'
-require 'tangle/directed/edge'
+# frozen_string_literal: true
+
+require_relative '../base_graph'
+require_relative 'edge'
 
 module Tangle
   module Directed
     #
     # A directed graph
-    class Graph < Tangle::Graph
-      Edge = Tangle::Directed::Edge
-      DEFAULT_MIXINS = [].freeze
-
+    class Graph < Tangle::BaseGraph
       # Return the incoming edges for +vertex+
       def in_edges(vertex)
         edges(vertex).select { |edge| edge.head?(vertex) }
       end
+      currify :vertex, :in_edges
 
       # Return the direct predecessors of +vertex+
       def direct_predecessors(vertex)
         in_edges(vertex).map(&:tail).to_set
       end
+      currify :vertex, :direct_predecessors
 
       # Is +other+ a direct predecessor of +vertex+?
       def direct_predecessor?(vertex, other)
         direct_predecessors(vertex).include?(other)
       end
+      currify :vertex, :direct_predecessor?
 
       # Return a breadth first enumerator for all predecessors
       def predecessors(vertex)
         vertex_enumerator(vertex, :direct_predecessors)
       end
+      currify :vertex, :predecessors
 
       # Is +other+ a predecessor of +vertex+?
       def predecessor?(vertex, other)
         predecessors(vertex).any? { |vtx| other.eql?(vtx) }
       end
+      currify :vertex, :predecessor?
 
       # Return a subgraph with all predecessors of a +vertex+
       def predecessor_subgraph(vertex, &selector)
         subgraph(predecessors(vertex), &selector)
       end
+      currify :vertex, :predecessor_subgraph
 
       # Return the outgoing edges for +vertex+
       def out_edges(vertex)
         edges(vertex).select { |edge| edge.tail?(vertex) }
       end
+      currify :vertex, :out_edges
 
       # Return the direct successors of +vertex+
       def direct_successors(vertex)
         out_edges(vertex).map(&:head).to_set
       end
+      currify :vertex, :direct_successors
 
       # Is +other+ a direct successor of +vertex+?
       def direct_successor?(vertex, other)
         direct_successors(vertex).include?(other)
       end
+      currify :vertex, :direct_successor?
 
       # Return a breadth first enumerator for all successors
       def successors(vertex)
         vertex_enumerator(vertex, :direct_successors)
       end
+      currify :vertex, :successors
 
       # Is +other+ a successor of +vertex+?
       def successor?(vertex, other)
         successors(vertex).any? { |vtx| other.eql?(vtx) }
       end
+      currify :vertex, :successor?
 
       # Return a subgraph with all successors of a +vertex+
       def successor_subgraph(vertex, &selector)
         subgraph(successors(vertex), &selector)
       end
+      currify :vertex, :successor_subgraph
 
       # Return the in degree for +vertex+
       def in_degree(vertex)
         in_edges(vertex).count
       end
+      currify :vertex, :in_degree
 
       # Return the out degree for +vertex+
       def out_degree(vertex)
         out_edges(vertex).count
       end
+      currify :vertex, :out_degree
 
       # Is +vertex+ a sink in the graph?
       def sink?(vertex)
         out_degree(vertex).zero?
       end
+      currify :vertex, :sink?
 
       # Is +vertex+ a source in the graph?
       def source?(vertex)
         in_degree(vertex).zero?
       end
+      currify :vertex, :source?
 
       # Is +vertex+ internal in the graph?
       def internal?(vertex)
         !(sink?(vertex) || source?(vertex))
       end
+      currify :vertex, :internal?
 
       # Is the graph balanced?
       def balanced?
         vertices.all? { |vertex| in_degree(vertex) == out_degree(vertex) }
       end
+
+      private
+
+      def new_edge(*args)
+        Edge.new(*args)
+      end
     end
   end
 end

data/lib/tangle/edge.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 require 'forwardable'
-require 'tangle/errors'
+require_relative 'mixin'
 
 module Tangle
   #
-  # An edge in a graph, connecting two vertices
+  # An edge in an undirected graph, connecting two vertices
   #
   class Edge
     include Tangle::Mixin::Initialize
@@ -31,16 +33,6 @@ module Tangle
       @vertices.fetch(from_vertex)
     end
 
-    def to_s
-      vertex1, vertex2 = @vertices.keys
-      "{#{vertex1}<->#{vertex2}}"
-    end
-    alias inspect to_s
-
-    def each_vertex(&block)
-      @vertices.each_key(&block)
-    end
-
     def include?(vertex)
       each_vertex.include?(vertex)
     end
@@ -51,9 +43,8 @@ module Tangle
 
     private
 
-    def initialize_vertices(vertex1, vertex2 = vertex1)
+    def initialize_vertices(vertex1, vertex2)
       @loop = vertex1 == vertex2
-      @vertices = { vertex1 => vertex2, vertex2 => vertex1 }.freeze
     end
   end
 end

data/lib/tangle/errors.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Tangle
   #
   # LoopError is raised when a looped edge is disallowed.

data/lib/tangle/mixin.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Tangle
   module Mixin
     #
@@ -10,7 +12,6 @@ module Tangle
 
       def initialize_mixins(mixins: nil, **kwargs)
         @mixins = mixins
-
         extend_with_mixins unless @mixins.nil?
         initialize_kwargs(**kwargs) unless kwargs.empty?
       end

data/lib/tangle/mixin/directory.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Tangle
   module Mixin
     # Tangle mixin for loading a directory structure as a graph

data/lib/tangle/undirected/edge.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require_relative '../edge'
+
+module Tangle
+  module Undirected
+    #
+    # An edge in an undirected graph, connecting two vertices
+    #
+    class Edge < Tangle::Edge
+      def each_vertex(&block)
+        @vertices.each_key(&block)
+      end
+
+      def to_s
+        vertex1, vertex2 = @vertices.keys
+        "{#{vertex1}<->#{vertex2}}"
+      end
+      alias inspect to_s
+
+      private
+
+      def initialize_vertices(vertex1, vertex2 = vertex1)
+        super
+        @vertices = { vertex1 => vertex2, vertex2 => vertex1 }.freeze
+      end
+    end
+  end
+end

data/lib/tangle/undirected/graph.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require_relative '../base_graph'
+require_relative 'edge'
+
+module Tangle
+  module Undirected
+    #
+    # Undirected graph
+    #
+    class Graph < Tangle::BaseGraph
+      # 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| connected_vertices?(vertex, other) }
+      end
+      alias component connected_subgraph
+      alias connected_component connected_subgraph
+
+      # Get the largest subgraph that is not connected to a vertex, or what's
+      # left after removing the connected subgraph.
+      #
+      def disconnected_subgraph(vertex)
+        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?(*tested_vertices)
+        tested_vertices = vertices if tested_vertices.empty?
+        return false if tested_vertices.empty?
+
+        tested_vertices.combination(2).all? do |pair|
+          this, that = pair.to_a
+          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?(*tested_vertices)
+        !connected?(*tested_vertices)
+      end
+
+      # Return a breadth-first Enumerator for all reachable vertices,
+      # by transitive adjacency.
+      def reachable(start_vertex)
+        vertex_enumerator(start_vertex, :adjacent)
+      end
+
+      private
+
+      def new_edge(*args)
+        Edge.new(*args)
+      end
+    end
+  end
+end

data/lib/tangle/undirected/simple/graph.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative '../graph'
+
+module Tangle
+  module Undirected
+    module Simple
+      #
+      # A simple graph, without loops and multiple edges
+      class Graph < Tangle::Undirected::Graph
+        protected
+
+        def insert_edge(edge)
+          raise LoopError if edge.loop?
+          raise MultiEdgeError if adjacent?(*edge.each_vertex)
+          super
+        end
+      end
+    end
+  end
+end

data/lib/tangle/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'git-version-bump'
 
 module Tangle

data/tangle.gemspec

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 
 lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
@@ -21,6 +22,9 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
+  spec.platform = Gem::Platform::RUBY
+  spec.required_ruby_version = '~> 2.3'
+
   spec.add_dependency 'git-version-bump', '~> 0.15'
 
   spec.add_development_dependency 'bundler', '~> 1.16'
@@ -28,4 +32,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rake', '~> 10.0'
   spec.add_development_dependency 'rspec', '~> 3.0'
   spec.add_development_dependency 'rubocop', '~> 0.52'
+  spec.add_development_dependency 'simplecov', '~> 0.16'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tangle
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Calle Englund
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-05-25 00:00:00.000000000 Z
+date: 2018-06-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: git-version-bump
@@ -94,6 +94,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.52'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.16'
 description: 
 email:
 - calle@discord.bofh.se
@@ -113,19 +127,21 @@ files:
 - bin/console
 - bin/setup
 - lib/tangle.rb
+- lib/tangle/base_graph.rb
+- lib/tangle/base_graph_private.rb
+- lib/tangle/base_graph_protected.rb
+- lib/tangle/currify.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_edges.rb
-- lib/tangle/graph_vertices.rb
 - lib/tangle/mixin.rb
-- lib/tangle/mixin/connectedness.rb
 - lib/tangle/mixin/directory.rb
-- lib/tangle/simple/graph.rb
+- lib/tangle/undirected/edge.rb
+- lib/tangle/undirected/graph.rb
+- lib/tangle/undirected/simple/graph.rb
 - lib/tangle/version.rb
 - tangle.gemspec
 homepage: https://github.com/notcalle/ruby-tangle
@@ -138,9 +154,9 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - "~>"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/lib/tangle/graph.rb

@@ -1,83 +0,0 @@
-require 'tangle/mixin'
-require 'tangle/mixin/connectedness'
-require 'tangle/edge'
-require 'tangle/graph_vertices'
-require 'tangle/graph_edges'
-
-module Tangle
-  #
-  # Base class for all kinds of graphs
-  #
-  class Graph
-    include Tangle::GraphVertices
-    include Tangle::GraphEdges
-    include Tangle::Mixin::Initialize
-    Edge = Tangle::Edge
-    DEFAULT_MIXINS = Tangle::Mixin::Connectedness::MIXINS
-
-    # Initialize a new graph, preloading it with vertices and edges
-    #
-    # Graph[+vertices+] => Graph
-    # Graph[+vertices+, +edges+) => Graph
-    #
-    # When +vertices+ is a hash, it contains initialization kwargs as
-    # values and vertex names as keys. When +vertices+ is an array of
-    # initialization kwargs, the vertices will be be anonymous.
-    #
-    # +edges+ can contain an array of exactly two, either names of vertices
-    # or vertices.
-    #
-    # Any kwarg supported by Graph.new is also allowed.
-    #
-    def self.[](vertices, edges = {}, **kwargs)
-      graph = new(**kwargs)
-      vertices.each { |vertex| graph.add_vertex(vertex) }
-      edges.each { |from, to| graph.add_edge(from, to) }
-      graph
-    end
-
-    # Initialize a new graph, optionally preloading it with vertices and edges
-    #
-    # Graph.new() => Graph
-    # Graph.new(mixins: [MixinModule, ...], ...) => Graph
-    #
-    # +mixins+ is an array of modules that can be mixed into the various
-    # classes that makes up a graph. Initialization of a Graph, Vertex or Edge
-    # looks for submodules in each mixin, with the same name and extends
-    # any created object. Defaults to [Tangle::Mixin::Connectedness].
-    #
-    # Any subclass of Graph should also subclass Edge to manage its unique
-    # constraints.
-    #
-    def initialize(mixins: self.class::DEFAULT_MIXINS, **kwargs)
-      initialize_vertices
-      initialize_edges
-      initialize_mixins(mixins: mixins, **kwargs)
-    end
-
-    # Return a subgraph, optionally filtered by a vertex selector block
-    #
-    # subgraph => Graph
-    # subgraph { |vertex| ... } => Graph
-    #
-    # Unless a selector is provided, the subgraph contains the entire graph.
-    #
-    def subgraph(included = nil, &selector)
-      result = clone
-      result.select_vertices!(included) unless included.nil?
-      result.select_vertices!(&selector) if block_given?
-      result
-    end
-
-    def to_s
-      "#<#{self.class}: #{vertices.count} vertices, #{edges.count} edges>"
-    end
-    alias inspect to_s
-
-    private
-
-    def callback(receiver, method, *args)
-      receiver.send(method, *args) if receiver.respond_to?(method)
-    end
-  end
-end

data/lib/tangle/graph_edges.rb

@@ -1,52 +0,0 @@
-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)
-      edge = self.class::Edge.new(*vertices, mixins: @mixins, **kvargs)
-      insert_edge(edge)
-      vertices.each { |vertex| callback(vertex, :edge_added, edge) }
-      edge
-    end
-
-    # Remove an edge from the graph
-    def remove_edge(edge)
-      delete_edge(edge)
-      edge.each_vertex { |vertex| callback(vertex, :edge_removed, edge) }
-    end
-
-    protected
-
-    # Insert a prepared edge into the graph
-    #
-    def insert_edge(edge)
-      @edges << edge
-      edge.each_vertex { |vertex| @vertices.fetch(vertex) << edge }
-    end
-
-    def delete_edge(edge)
-      edge.each_vertex { |vertex| @vertices.fetch(vertex).delete(edge) }
-      @edges.delete(edge)
-    end
-
-    private
-
-    def initialize_edges
-      @edges = Set[]
-    end
-  end
-end

data/lib/tangle/graph_vertices.rb

@@ -1,98 +0,0 @@
-require 'set'
-
-module Tangle
-  # Vertex related methods in a graph
-  module GraphVertices
-    # Fetch a vertex by its name
-    def fetch(name)
-      @vertices_by_name.fetch(name)
-    end
-
-    # Return a named vertex
-    def [](name)
-      @vertices_by_name[name]
-    end
-
-    # Return all vertices in the graph
-    def vertices
-      @vertices.keys
-    end
-
-    # Select vertices in the graph
-    def select(&selector)
-      @vertices.each_key.select(&selector)
-    end
-
-    # Add a vertex into the graph
-    #
-    # If a name: is given, or the vertex responds to :name,
-    # it will be registered by name in the graph
-    def add_vertex(vertex, name: nil)
-      name ||= callback(vertex, :name)
-      insert_vertex(vertex, name)
-      callback(vertex, :added_to_graph, self)
-      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
-      delete_vertex(vertex)
-      callback(vertex, :removed_from_graph, self)
-    end
-
-    protected
-
-    def select_vertices!(selected = nil)
-      vertices.each do |vertex|
-        delete_vertex(vertex) if block_given? && !yield(vertex)
-        next if selected.nil?
-        delete_vertex(vertex) unless selected.any? { |vtx| vtx.eql?(vertex) }
-      end
-    end
-
-    def insert_vertex(vertex, name = nil)
-      @vertices[vertex] = Set[]
-      @vertices_by_name[name] = vertex unless name.nil?
-    end
-
-    def delete_vertex(vertex)
-      @vertices[vertex].each do |edge|
-        delete_edge(edge) if edge.include?(vertex)
-      end
-      @vertices.delete(vertex)
-      @vertices_by_name.delete_if { |_, vtx| vtx.eql?(vertex) }
-    end
-
-    private
-
-    # Initialize vertex related attributes
-    def initialize_vertices
-      @vertices = {}
-      @vertices_by_name = {}
-    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

@@ -1,68 +0,0 @@
-module Tangle
-  module Mixin
-    #
-    # 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| connected_vertices?(vertex, other) }
-        end
-        alias component connected_subgraph
-        alias connected_component connected_subgraph
-
-        # Get the largest subgraph that is not connected to a vertex, or what's
-        # left after removing the connected subgraph.
-        #
-        def disconnected_subgraph(vertex)
-          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?(*tested_vertices)
-          tested_vertices = vertices if tested_vertices.empty?
-          return false if tested_vertices.empty?
-
-          tested_vertices.combination(2).all? do |pair|
-            this, that = pair.to_a
-            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?(*tested_vertices)
-          !connected?(*tested_vertices)
-        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
-  end
-end

data/lib/tangle/simple/graph.rb

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