tangle 0.8.2 → 0.11.0

data/lib/tangle/base_graph_protected.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Tangle
+  #
+  # Protected methods of BaseGraph
+  #
+  module BaseGraphProtected
+    protected
+
+    def copy_vertices_and_edges(from)
+      @vertices = from.instance_variable_get(:@vertices).dup
+      @vertices_by_name = from.instance_variable_get(:@vertices_by_name).dup
+      @edges = from.instance_variable_get(:@edges).dup
+    end
+
+    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,58 @@
+# frozen_string_literal: true
+
+module Tangle
+  # Raised for zero arity of a currified method, subclass of ArgumentError
+  class CurrifyError < ArgumentError
+    def initialize(msg = 'method accepts no arguments', *)
+      super
+    end
+  end
+
+  # 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)
+        raise CurrifyError if instance_method(method).arity.zero?
+
+        @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'
 
@@ -17,6 +19,7 @@ module Tangle
         def insert_edge(edge)
           raise CyclicError if successor?(edge.head, edge.tail) ||
                                predecessor?(edge.tail, edge.head)
+
           super
         end
       end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Tangle
   module Directed
     module Acyclic
@@ -29,6 +31,7 @@ module Tangle
           raise GraphError unless graph == other.graph
           return 0 if vertex == other.vertex
           return -1 if graph.successor?(vertex, other.vertex)
+
           1
         end
       end

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, **kwargs)
+        Edge.new(*args, **kwargs)
+      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
@@ -7,17 +9,25 @@ module Tangle
     # options are:
     #   root:           root directory for the structure (mandatory)
     #   loaders:        list of object loader lambdas (mandatory)
+    #                     ->(graph, **) { ... } => finished?
     #   follow_links:   bool for following symlinks to directories
-    #                   (default false)
+    #   exclude_root:   bool for excluding the root directory
+    #
+    # All bool options default to false.
+    #
+    # A loader lambda is called with the graph as only positional
+    # argument, and a number of keyword arguments:
     #
-    # A loader lambda will be called like
-    #   ->(graph, path, parent_path) { ... }
+    #   path:     Path of current filesystem object
+    #   parent:   Path of filesystem parent object
+    #   lstat:    File.lstat for path
+    #   stat:     File.stat for path, if lstat.symlink?
     #
-    # The lambdas are called in order until one returns true
+    # The lambdas are called in order until one returns true.
     #
     # Example:
-    #   loader = lambda do |g, path, parent|
-    #       vertex = File::Stat.new(path)
+    #   loader = lambda do |g, path:, parent:, lstat:, **|
+    #       vertex = kwargs[:lstat]
     #       g.add_vertex(vertex, name: path)
     #       g.add_edge(g[parent], vertex) unless parent.nil?
     #     end
@@ -30,25 +40,50 @@ module Tangle
 
         private
 
-        def initialize_kwarg_directory(**options)
+        def initialize_kwarg_directory(options)
           @root_directory = options.fetch(:root)
           @directory_loaders = options.fetch(:loaders)
           @follow_directory_links = options[:follow_links]
+          @exclude_root = options[:exclude_root]
           load_directory_graph(@root_directory)
         end
 
         def load_directory_graph(path, parent = nil)
-          @directory_loaders.any? do |loader|
-            loader.to_proc.call(self, path, parent)
-          end
-
-          return if File.symlink?(path) && !@follow_directory_links
-          return unless File.directory?(path)
+          return unless load_directory_object(path, parent)
 
           Dir.each_child(path) do |file|
             load_directory_graph(File.join(path, file), path)
           end
         end
+
+        # Load a filesystem object into the graph, returning
+        # +true+ if the object was a directory (or link to one,
+        # and we're following links).
+        def load_directory_object(path, parent = nil)
+          if @exclude_root
+            return true if path == @root_directory
+
+            parent = nil if parent == @root_directory
+          end
+
+          try_directory_loaders(path, parent)
+        end
+
+        # Try each directory loader, returning true if the object has
+        # children to follow
+        def try_directory_loaders(path, parent)
+          stat = lstat = File.lstat(path)
+          stat = File.stat(path) if lstat.symlink?
+
+          @directory_loaders.any? do |loader|
+            loader.to_proc.call(self, path: path, parent: parent,
+                                      lstat: lstat, stat: stat)
+          end
+
+          return if lstat.symlink? && !@follow_directory_links
+
+          stat.directory?
+        end
       end
     end
   end