modular_tree 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 87b4426ea3d2f00ff5959831b0297d21190fee942d720f9e239cccc74e02ddcb
+  data.tar.gz: feb82cbe67f18d2f0855f041a4612fbe023ae5564706123dee7bbef1e0d39b4a
+SHA512:
+  metadata.gz: ef3db04b865ec12612ccae42104bad67344892857f3bed8b523cc70b4aaab9ace7675cbb30bfab751143c741d0e45c13157cc6f8594b90f296fb4e2fb0efe15a
+  data.tar.gz: dc1b4179bf2f46d3506af4c8660d71d552ff07567dda93403a5eca618744ca1a2aa53f8adf7f89d251d9b9f3ea4acb3080df4bd0933b4b33840656e8f874fc00

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.ruby-version

@@ -0,0 +1 @@
+ruby-3.1.2

data/Gemfile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in modular_tree.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "rspec", "~> 3.0"

data/README.md

@@ -0,0 +1,155 @@
+# ModularTree
+
+A modular tree implementation for Ruby
+
+## Usage
+
+```ruby
+require "modular_tree"
+
+class Node < Tree::Tree
+  attr_reader :name
+  def initialize(parent, name)
+    @name = name
+    super(parent)
+  end
+  def to_s(name)
+end
+
+root = Node.new(nil, "root")
+a = Node.new(root, "a")
+b = Node.new(root, "b")
+
+puts root.children.join(', ') # a, b
+puts a.parent                 # root
+
+
+## Description
+
+ModularTree classes are defined by using a set of modules that can be divided
+into the following categories:
+
+  * Property modules
+  * Implementation modules
+  * Algorithms modules
+
+Property modules defines abstract properties that are defined by the
+implementation modules while algorithms are defined in terms of properties.
+This decouples algorithms and implementations and makes it possible to use the
+same algorithms on different tree implementations
+
+## Block arguments
+
+Blocks are called with three arguments - value, key, and parent - but
+usually only 'value' is used (Ruby allows you to ignore the remaining
+arguments)
+
+Keys may be nil if the underlying data structure doesn't support
+them efficiently. Keys for array implementations are the node indexes. Note
+that keys are only unique if you don't apply filters because filters may
+combine nodes from different parents
+
+Algorithms are supposed to take care of traversing the tree so blocks are
+called with the values and not the tree node. This makes a difference for
+external implementations where the values don't know their position in
+the tree
+
+If you don't need the keys, then the node/parent combination is already covered
+by #edges
+
+## External data structures
+
+### Hash
+
+```ruby
+  {
+    "root" => {
+      "a" => {
+        "b" => {},
+        "c" => {}
+      },
+      "d" => {
+        "e" => {}
+      }
+    }
+  }
+```
+
+`#value` returns the hash value of a node. Eg. {"e"=>{}} if called on the "d" node
+
+\#each_branch & #each_child will be called with
+
+```ruby
+  {...}, "root"
+  {...}, "a"
+  {}, "b"
+  {}, "c"
+  {...}, "d"
+  {}, "e"
+```
+
+### Nested Array
+
+```ruby
+  [
+    ["root", [
+      ["a", [
+        ["b", []],
+        ["c", []]
+      ]],
+      ["d", [
+        ["e", []]
+      ]]
+    ]]
+  ]
+```
+
+`#value` returns first element in each node tuple. Eg. "d" if called on the "d" node
+
+
+\#each_child will be called with
+
+```ruby
+"root", 0
+"a", 0
+"b", 0
+"c", 1
+"d", 1
+"e", 0
+```
+
+\#each_branch will be called with
+
+```ruby
+["root", [...]], 0
+["a", [...]], 0
+["b", []], 0
+["c", []], 1
+["d", [...]], 1
+["e", []], 0
+
+
+Note that nested arrays is a structural representation where the "key" is the
+real objects the tree is made of while hashes are maps from a value to the
+object modelled as a hash. Hash trees have keys (typically strings) while
+nested arrays has integer indexes as keys
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add modular_tree
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install modular_tree
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/modular_tree.

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lib/modular_tree/algorithms.rb

@@ -0,0 +1,255 @@
+
+module Tree
+
+  # A down tree can only be traversed bottom-up
+  #
+  # TODO: Add FilteredUpTreeAlgorithms
+  #
+  module UpTreeAlgorithms
+    include NodeProperty
+    include BranchesProperty
+
+    # Bottom-up
+    def ancestors
+      curr = self
+      a = []
+      a.push curr.node while curr = curr.branch
+      a
+    end
+
+    # Top-down 
+    def ancestry
+      curr = self
+      a = []
+      a.unshift curr.node while curr = curr.branch
+      a
+    end
+
+    def depth = @depth ||= ancestors.size
+  end
+
+  # IDEA
+  #
+  #   tree.forrest -> Forrest
+  #   tree.nodes -> Use node instead of value
+  #   tree.forrest.nodes -> both
+
+
+  # A down tree can only be traversed top-down as it has no reference to its
+  # parent. It is also a kind of a graph node
+  #
+  # TODO: Turn into class methods to implement array/hash/other adaptors.
+  #       #children should then be called as 'children(node)' everywhere
+  #
+  #       A #node method should also be defined at the top-most level
+  #
+  # TODO: Better split between DownTreeAlgorithms and DownTreeFilteredAlgorithms
+  #
+  module DownTreeFilteredAlgorithms
+    include NodeProperty
+    include BranchesProperty
+
+    # True if the node doesn't contain any branches (#empty? for trees)
+    def bare? = raise NotImplemented
+
+    # The number of nodes in the tree. Note that this can be an expensive
+    # operation because every node has to be visited
+    def size = 1 + descendants.to_a.size
+
+    # Enumerator of descendant nodes matching filter. Same as #preorder with
+    # :this set to false. TODO: Maybe introduce forrests: tree.forrest.each
+    def descendants(*filter) = each(filter, this: false)
+
+    # Implementation of Enumerable#each extended with filters. The block is
+    # called with value, key, and parent as arguments (it may choose to
+    # ignore key and/or parent). Returns an enumerator of values without a block
+    def each(*filter, this: true, &block) = common_each(*filter, :value, :each_preorder, this, &block)
+
+    # Like #each but the block is called with node, key, and parent instead of
+    # value, key, and parent
+    def nodes(*filter, this: true, &block) = common_each(*filter, :node, :each_preorder, this, &block)
+
+    # Pre-order enumerator of selected nodes. Same as #each without a block
+    def preorder(*filter, this: true) = each(*filter, this: this)
+
+    # Post-order enumerator of selected nodes
+    def postorder(*filter, this: true) = common_each(*filter, :value, :each_postorder, this)
+
+    # Enumerator of edges in the tree. Edges are [previous-matching-node,
+    # matching-node] tuples. Top-level nodes have previous-matching-node set to
+    # nil
+    #
+    def edges(*filter, this: true, &block)
+      if block_given
+        each(*filter, this: this) { |node, _, parent| yield parent, node }
+      else
+        Pairs.new { |enum| each(*filter, this: this) { |node, _, parent| enum << [parent, node] } }
+      end
+    end
+
+#   def pairs(filter, filter, &block)
+#   end
+
+    # Traverse the tree top-down while accumulating information in an
+    # accumulator object. The block takes a [accumulator, node] tuple and is
+    # responsible for adding itself to the accumulator. The return value from
+    # the block is then used as the accumulator for the branch nodes. Note that
+    # it returns the original accumulator and not the final result - this makes
+    # it different from #inject
+    #
+    # #accumulate is a kind of "preorder" algorithm
+    def accumulate(*filter, accumulator, this: true, &block)
+      filter = self.class.filter(*filter)
+      block_given? or raise ArgumentError, "Block is required"
+      do_accumulate(filter, this, accumulator, &block)
+      accumulator
+    end
+
+    # Traverse the tree bottom-up while aggregating information. The block is
+    # called with a [current-node, branch-node-results] tuple
+    #
+    # #aggregate is a kind of "postorder" algorithm
+    #
+    # TODO: Remove +this+ flag - it not used and doesn't make sense
+    def aggregate(*filter, this: true, &block)
+      filter = self.class.filter(*filter)
+      do_aggregate(filter, this, &block)
+    end
+
+    # Stops further recursion if the block returns truthy
+    def propagate(*filter, this: true, &block)
+      
+    end
+
+    # tree.each(DocumentNode).select(BriefNode).each { |doc, brief| ... }
+    # tree.edges(DocumentNode, BriefNode).group.all? { |doc, briefs| briefs.size <= 1 }
+    # tree.map(DocumentNode) { |doc| doc.select(BriefNode).size <= 1 or raise }
+
+    # Create a Tree::Filter object. Can also take an existing filter as
+    # argument in which case the given filter will just be passed through
+    def self.filter(*args)
+      if args.first.is_a?(Filter)
+        args.size == 1 or raise ArgumentError
+        args.first
+      else
+        Filter.new(*args) 
+      end
+    end
+
+  protected
+    def common_each(*filter, value_method, each_method, this, &block)
+      filter = self.class.filter(*filter)
+      if block_given?
+        self.send(each_method, nil, filter, value_method, nil, nil, this, &block)
+      else
+        Enumerator.new { |enum| self.send(each_method, enum, filter, value_method, nil, nil, this) }
+      end
+    end
+
+    # TODO: Split into automatically generated variants
+    def do_each_preorder(enum, filter, value_method, key, parent, this, &block)
+      select, traverse = filter.match(self)
+      if select && this
+        value = self.send(value_method)
+        if block_given?
+          yield(value, key, parent)
+        else
+          enum << value
+        end
+        parent = value
+      end
+      if !this || traverse
+        each_branch { |branch, key| 
+          branch.do_each_preorder(enum, filter, value_method, key, parent, true, &block) 
+        }
+      end
+    end
+
+    def do_each_postorder(enum, filter, value_method, key, parent, this, &block)
+      select, traverse = filter.match(self)
+      if !this || traverse
+        each_branch { |branch, key| 
+          branch.do_each_postorder(enum, filter, value_method, key, p, true, &block) 
+        }
+      end
+      if select && this
+        value = self.send(value_method)
+        if block_given?
+          yield(value, key, parent)
+        else
+          enum << value
+        end
+      end
+    end
+
+    def do_propagate(filter, this, key, parent, &block)
+      select, traverse = filter.match(self)
+      if select && this
+        return if yield(self, key, parent)
+      end
+      if !this || traverse
+        each_branch { |branch, key| branch.do_propagate(filter, key, self.value) }
+      end
+    end
+
+    def do_accumulate(filter, this, acc, &block)
+      select, traverse = filter.match(self)
+      acc = yield(acc, self.value) if this && select
+      each_branch.each { |branch| branch.do_accumulate(filter, true, acc, &block) } if traverse || !this
+    end
+
+    def do_aggregate(filter, this, &block) # TODO: use select-status
+      block_given? or raise ArgumentError
+      select, traverse = filter.match(self)
+      values = traverse ? each_branch { |branch| 
+        r = branch.do_aggregate(filter, true, &block) 
+      }.to_a : []
+      yield(self.value, values)
+    end
+
+  end
+
+  module DownTreeAlgorithms
+    include DownTreeFilteredAlgorithms
+
+#   def self.included(other)
+#     other.include DownTreeFilteredAlgorithms
+#     super
+#   end
+
+    def self.filter(*args) = DownTreeFilteredAlgorithms.filter(*args)
+
+#   include DownTreeFilteredAlgorithms
+
+    # Very lazy implementation
+#   def descendants = preorder(Filter::ALL, this: false)
+#   def filter(*args) = abstract_method
+#   alias_method :nodes, :each
+#   def edges(*args, **opts, &block) = super(Filter::ALL, *args, **opts, &block)
+#   def pairs(*args, **opts, &block) = super(Filter::ALL, *args, **opts, &block)
+#   def preorder(*args, **opts, &block) = super(Filter::ALL, *args, **opts, &block)
+#   def postorder(*args, **opts, &block) = super(Filter::ALL, *args, **opts, &block)
+#   def visit(*args, **opts, &block) = super(Filter::ALL, *args, **opts, &block)
+#   def accumulate(*args, **opts, &block) = super(Filter::ALL, *args, **opts, &block)
+#   def aggregate(*args, **opts, &block) = super(Filter::ALL, *args, **opts, &block)
+#   def find(*args, **opts, &block) = super(Filter::ALL, *args, **opts, &block)
+  end
+
+  module PathAlgorithms
+    include KeyProperty
+    include UpTreeAlgorithms
+
+    def separator = @separator ||= parent&.separator || ::Tree.separator
+    def separator=(s) @separator = s end
+
+    def path = @path ||= ancestry[1..-1]&.map(&:key)&.join(separator) || ""
+    def uid() @uid ||= [parent&.uid, key].compact.join(separator) end
+  end
+
+  module DotAlgorithms
+    include KeysProperty
+
+    def dot(path) = Separator.split(path).keys.each.inject(self) { |a,e| a[e] }
+  end
+end
+

data/lib/modular_tree/filter.rb

@@ -0,0 +1,84 @@
+module Tree
+  class Filter
+    # Create a node filter. The filter is initialized by a select expression
+    # and a traverse expression.  The select expression decides if the node
+    # should be given to the block (or submitted to an enumerator) and the
+    # traverse expression decides if the child nodes should be traversed
+    # recursively
+    #
+    # The expressions can be a Proc, Symbol, or an array of classes. In
+    # addition, +select+ can also be true, and +traverse+ can be true,
+    # false, or nil. True, false, and nil have special meanings:
+    #
+    #   when +select+ is
+    #     true    Select always. This is the default
+    #
+    #   when +traverse+ is
+    #     true    Traverse always. This is the default
+    #     false   Traverse only if select didn't match
+    #     nil     Expects +select+ to return a two-tuple of booleans. Can't be
+    #             used when +select+ is true
+    #
+    # If the expression is a Proc object, it will be called with the current
+    # node as argument. If the return value is true, the node is
+    # selected/traversed and skipped otherwise. If the expression is a method
+    # name (Symbol), the method will be called on each node with no arguments.
+    # It is not an error if the method doesn't exists but the node is not
+    # selected/traversed
+    #
+    # Filters should not have side-effects because they can be used in
+    # enumerators that doesn't execute the filter unless the enumerator is
+    # evaluated
+    #
+    # TODO: block argument
+    #
+    def initialize(select_expr = true, traverse_expr = true, &block)
+      constrain select_expr, Proc, Symbol, Class, [Class], true
+      constrain traverse_expr, Proc, Symbol, Class, [Class], true, false, nil
+      select = mk_lambda(select_expr)
+      traverse = mk_lambda(traverse_expr)
+      @matcher = 
+          case select
+            when Proc
+              case traverse
+                when Proc; lambda { |node| [select.call(node), traverse.call(node)] }
+                when true; lambda { |node| [select.call(node), true] }
+                when false; lambda { |node| r = select.call(node); [r, !r] }
+                when nil; lambda { |node| select.call(node) }
+              end
+            when true
+              case traverse
+                when Proc; lambda { |node| [true, traverse.call(node)] }
+                when true; lambda { |_| [true, true] }
+                when false; lambda { |_| [true, false] } # effectively same as #children.each
+                when nil; raise ArgumentError
+              end
+          end
+    end
+
+    # Match +node+ against the filter and return a [select, traverse] tuple of booleans
+    def match(node) = @matcher.call(node)
+
+    # Create a proc if arg is a Symbol or an Array of classes. Pass through
+    # Proc objects, true, false, and nil
+    def mk_lambda(arg) = self.class.mk_lambda(arg)
+    def self.mk_lambda(arg)
+      case arg
+        when Proc, true, false, nil
+          arg
+        when Symbol
+          lambda { |node| node.respond_to?(arg) && node.send(arg) }
+        when Class
+          lambda { |node| node.is_a? arg }
+        when Array
+          arg.all? { |a| a.is_a? Class } or raise ArgumentError, "Array elements should be classes"
+          lambda { |node| arg.any? { |a| node.is_a? a } }
+      else
+        raise ArgumentError
+      end
+    end
+
+    ALL = Filter.new
+  end
+end
+

data/lib/modular_tree/implementations.rb

@@ -0,0 +1,202 @@
+
+# TODO TODO TODO IDEA 
+#
+# External trees
+#   node/branch/branches
+#     returns tree
+#
+#   this/parent/children
+#     returns data field
+#
+# Internal trees
+#   Unifies node and this
+#
+# Both of internal and external trees have branch/branches relations. 
+#
+# Internal trees adds a parent/children relation
+#
+#
+#
+# Only internal trees have parent/child relations. External trees have only branch/branches relations
+
+module Tree
+  module Implementation
+    include NodeProperty
+    def initialize(_arg) end
+  end
+
+  module InternalImplementation
+    include Implementation
+    def node = self
+    def this = self
+    def value = self
+  end
+
+  module ParentImplementation
+    include ParentProperty
+    include StemProperty
+    include Implementation
+  end
+
+  module InternalParentImplementation
+    include InternalImplementation
+    include ParentImplementation
+
+    attr_reader :parent
+    alias_method :branch, :parent
+
+    def initialize(parent) = @parent = parent
+
+# protected
+    attr_writer :parent
+  end
+
+  module ExternalParentImplementation
+    include ParentImplementation
+  end
+
+  module ChildrenImplementation
+    include ChildrenProperty
+    include BranchesProperty
+    include Implementation
+# protected
+    def attach(child) = abstract_method
+  end
+
+  module ExternalChildrenArrayImplementation
+    include NodeProperty
+    include ChildrenImplementation
+
+    def node = array
+    def this = array.first
+    def value = array.first
+
+    attr_accessor :array
+
+    def children = @array.last.map(&:first)
+    def branches = Enumerator.new { |enum| each_branch { |branch| enum << branch } }
+
+    # FIXME: each_child/branch/etc. are actually map methods
+    def each_child(&block) = @array.last.map { |*node| yield(*node) }
+#   def each_child(&block) = array.second.each { |node| yield(*node, self) } # Actually possible
+#   def each_child(&block) = array.last.each(&:first)
+
+    def each_branch(&block)
+      block_given? or raise ArgumentError
+#     impl = self.class.new(nil)
+      @array.last.map { |node| yield self.class.new(node) }
+    end
+
+    def each_edge(&block)
+      @array.last.map { |node| yield self, self.class.new(node) }
+    end
+
+    def each(&block)
+      @array.last.map.with_index { |node, i| yield i, self.class.new(node) }
+    end
+
+    def each_node(&block)
+      @array.last.map.with_index { |node, i| yield self, i, self.class.new(node) }
+    end
+
+    def self.new(array)
+      object = super(nil)
+      object.array = array
+      object
+    end
+
+# protected
+    def attach(child) = array.last << child
+  end
+
+  module InternalChildrenImplementation
+    include InternalImplementation
+    include ChildrenImplementation
+
+#   def children = abstract_method # Repeated here because provide_module is not executed yet
+#   def each_child = abstract_method
+
+#   alias_method :branches, :children
+#   alias_method :each_branch, :each_child
+
+    def branches = children
+    def each_branch(&block) = each_child(&block)
+
+    def attach(child) = abstract_method
+  end
+
+  # Demonstrates a linked list implementation
+  module InternalChildrenListImplementation
+    include InternalChildrenImplementation
+
+    attr_reader :first_child
+    attr_reader :next_sibling
+
+    def children
+      n = self.first_child or return []
+      a = [n]
+      a << n while n = n.next_sibling
+      a
+    end
+
+    def each_child(&block)
+      curr = first_child or return
+      yield(curr)
+      yield curr while curr = next_sibling
+    end
+
+    def attach(child)
+      child.instance_variable_set(:@next_sibling, first_child)
+      @first_child = child
+    end
+
+# protected
+    attr_writer :first_child
+    attr_writer :next_sibling
+  end
+
+  module InternalChildrenArrayImplementation
+    include InternalChildrenImplementation
+
+    attr_reader :children
+
+    def initialize(_parent)
+      @children = []
+      super
+    end
+
+    def each_child(&block) = @children.map(&block)
+    def attach(child) = @children << child
+  end
+
+  module InternalChildrenHashImplementation
+    include InternalChildrenImplementation
+
+    attr_reader :hash
+
+    def children = hash.values
+
+    def initialize
+      @hash = {}
+      super
+    end
+  end
+
+  module InternalParentChildImplementation
+#   include InternalParentImplementation
+#   include InternalChildrenImplementation
+    include ParentProperty
+    include ChildrenProperty
+
+    def initialize(parent)
+      super
+      parent&.attach(self)
+    end
+
+    def attach(child)
+      super(child)
+      child.send(:parent=, self)
+    end
+  end
+end
+

data/lib/modular_tree/pairs.rb

@@ -0,0 +1,14 @@
+module Tree
+  class Pairs < Enumerator
+    def group
+      h = {}
+      each { |first, last| (h[first] ||= []) << last }
+      h.each
+    end
+
+    # Turn into a nested array tree
+    def fold = abstract_method
+
+    def to_h = abstract_method
+  end
+end

data/lib/modular_tree/pool.rb

@@ -0,0 +1,26 @@
+module Tree
+  # For internal trees with a global namespace for nodes
+  module Pool
+    include PathAlgorithms
+
+    def self.included(other)
+      other.extend(ClassMethods)
+      other.instance_variable_set(:@pool, {})
+      super
+    end
+
+    def initialize(_parent)
+      super
+      self.class[self.uid] = self
+    end
+
+    module ClassMethods
+      def key?(uid) = @pool.key?(uid)
+      def keys = @pool.keys
+      def nodes = @pool.values
+      def [](uid) = @pool[uid]
+      def []=(uid, node) @pool[uid] = node end
+    end
+  end
+end
+

data/lib/modular_tree/properties.rb

@@ -0,0 +1,53 @@
+
+module Tree
+  # A child node is not necessarily a tree, branches are, but they have to use
+  # #node to get the data
+  #
+  # Internal trees have child == branch
+
+  module Property
+    def initialize(_arg) end
+  end
+
+  module NodeProperty
+    def node = abstract_method
+
+    # FIXME: What is this. Also describe all properties in this file
+    def value = abstract_method
+  end
+
+  module StemProperty # Aka. 'parent'
+    def stem = abstract_method
+  end
+
+  module BranchesProperty
+    def branches = abstract_method
+    def each_branch(&block) = branches.each(&block)
+  end
+
+  module ParentProperty
+    def parent = abstract_method
+    def parent=(arg) abstract_method end
+  end
+
+  module ChildrenProperty
+    def children = abstract_method
+    def each_child(&block) = children.each(&block)
+    def attach(child) = abstract_method
+  end
+
+  module KeyProperty # Set
+    def key = abstract_method
+  end
+
+  module KeysProperty # Map
+    def keys = abstract_method
+    def key?(k) = keys.include? k
+    def [](key) = abstract_method
+  end
+
+  module RootProperty
+    def root = abstract_method # @root ||= parent&.root
+  end
+end
+

data/lib/modular_tree/separator.rb

@@ -0,0 +1,21 @@
+module Tree
+  module Separator
+    DEFAULT_SEPARATOR = "."
+
+    def self.included(other)
+      puts "including Separator"
+      super(other)
+      other.instance_variable_set(:@separator, DEFAULT_SEPARATOR)
+      other.extend(ClassMethods)
+    end
+
+    def separator
+      self.class.instance_variable_get(:@separator)
+    end
+
+    module ClassMethods
+      attr_accessor :separator
+      def split(s) = s.split /#{separator}/
+    end
+  end
+end

data/lib/modular_tree/tree_array.rb

@@ -0,0 +1,19 @@
+
+module ModularTree
+  # Doesn't work atm. because DownTreeAlgorithms methods are implemented as
+  # members and not as class methods and perhaps because of other stuff
+  class TreeArray < AbstractTree
+    include DownTreeAlgorithms
+
+    attr_reader :array
+
+    def node = array.first
+    def children = array[1..-1]
+
+    def initialize(array)
+      @array = array
+    end
+
+    def self.filter(*args) = DownTreeAlgorithms.filter(*args)
+  end
+end

data/lib/modular_tree/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Tree
+  VERSION = "0.0.1"
+end

data/lib/modular_tree.rb

@@ -0,0 +1,137 @@
+require 'abstract_method_error'
+
+require "indented_io"
+
+require 'constrain'
+include Constrain
+
+require 'forward_to'
+include ForwardTo
+
+require_relative "modular_tree/version"
+require_relative "modular_tree/separator"
+require_relative "modular_tree/filter"
+require_relative "modular_tree/pairs"
+
+# Order is important here
+require_relative "modular_tree/properties"
+require_relative "modular_tree/implementations"
+require_relative "modular_tree/algorithms"
+
+# Should be after the above group
+require_relative "modular_tree/pool"
+
+module Tree
+  DEFAULT_SEPARATOR = "."
+
+  # TODO: Move to algorithms
+  @separator = nil
+  def Tree.separator = @separator ||= DEFAULT_SEPARATOR
+  def Tree.separator=(s) @separator = s end
+
+  class AbstractTree
+    def empty? = abstract_method
+    def size = abstract_method
+  end
+
+  # A regular tree
+  #
+  class ArrayTree < AbstractTree # Aka. SetTree aka. Tree
+    include InternalParentImplementation
+    include InternalChildrenArrayImplementation
+    include InternalParentChildImplementation
+    include UpTreeAlgorithms
+    include DownTreeAlgorithms
+
+    def self.filter(*args) = DownTreeAlgorithms.filter(*args)
+  end
+
+  class FilteredArrayTree < ArrayTree
+    include DownTreeFilteredAlgorithms
+
+    def self.filter(*args) = FilteredDownTreeAlgorithms.filter(*args)
+  end
+
+  # TODO: Hide
+  class NestedArrayTree < AbstractTree
+    include ExternalChildrenArrayImplementation
+    include DownTreeAlgorithms
+
+    def initialize(array)
+      super(nil)
+      self.array = array
+    end
+
+    def self.filter(*args) = DownTreeAlgorithms.filter(*args)
+  end
+
+  # Module level algorithms on nested array trees
+  #
+  def self.aggregate(arg, *args, &block)
+    case arg
+      when Array; NestedArrayTree.new(arg).aggregate(*args, &block)
+    else
+      raise ArgumentError
+    end
+  end
+
+  def self.aggregate(arg, *args, &block) = class_of(arg).new(arg).aggregate(*args, &block)
+
+  # TODO: Hide
+  def self.class_of(arg)
+    constrain arg, Array
+    if arg.size == 2 && arg.last.is_a?(Array)
+      NestedArrayTree
+    else
+      raise "Oops"
+    end
+  end
+
+# data = 
+#   ["root", [
+#     ["a", [
+#       ["b", []],
+#       ["c", []]
+#     ]],
+#     ["d", [
+#       ["e", []],
+#     ]]
+#   ]]
+#
+# tree = NestedArrayTree.new(data)
+# tree.visit { ... }
+#
+# tree.traverse { before(); yield; after() }
+#
+# NestedArrayTree.visit(data) { ... }
+#
+# NestedArrayTree.adapt(data)
+# data.visit { ... }
+#       
+
+
+# p Tree.ancestors
+# exit
+
+# module KeyedUpTreeAlgorithmsRoot
+#   include KeyedUpTreeAlgorithms
+#
+#   def initialize
+#     super
+#     @pool = {}
+#
+# end
+
+# class TreeAdapter < AbstractTree
+#   attr_reader :parent_method
+#   attr_reader :children_method
+#   def parent = self.send(parent_method)
+#   def children = self.send(children_method)
+#
+#   def initialize(root, parent_method, children_method)
+#     @parent_method = parent_method
+#     @children_method = children_method
+#   end
+# end
+end
+

data/modular_tree.gemspec

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "lib/modular_tree/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "modular_tree"
+  spec.version = Tree::VERSION
+  spec.authors = ["Claus Rasmussen"]
+  spec.email = ["claus.l.rasmussen@gmail.com"]
+
+  spec.summary = "Gem modular_tree"
+  spec.description = "Gem modular_tree"
+  spec.homepage = "http://www.nowhere.com/"
+  spec.required_ruby_version = ">= 2.6.0"
+
+
+  spec.metadata["homepage_uri"] = spec.homepage
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Uncomment to register a new dependency of your gem
+  # spec.add_dependency "example-gem", "~> 1.0"
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+
+  # Add your production dependencies here
+  # spec.add_dependency GEM [, VERSION]
+
+  # Add your development dependencies here
+  # spec.add_development_dependency GEM [, VERSION]
+
+  # Also un-comment in spec/spec_helper to use simplecov
+  # spec.add_development_dependency "simplecov"
+
+  spec.add_dependency 'constrain'
+  spec.add_dependency 'forward_to'
+  spec.add_dependency 'abstract_method_error'
+  spec.add_development_dependency 'indented_io'
+end

data/sig/modular_tree.rbs

@@ -0,0 +1,4 @@
+module ModularTree
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: modular_tree
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Claus Rasmussen
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2022-12-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: constrain
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: forward_to
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: abstract_method_error
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: indented_io
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Gem modular_tree
+email:
+- claus.l.rasmussen@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".ruby-version"
+- Gemfile
+- README.md
+- Rakefile
+- lib/modular_tree.rb
+- lib/modular_tree/algorithms.rb
+- lib/modular_tree/filter.rb
+- lib/modular_tree/implementations.rb
+- lib/modular_tree/pairs.rb
+- lib/modular_tree/pool.rb
+- lib/modular_tree/properties.rb
+- lib/modular_tree/separator.rb
+- lib/modular_tree/tree_array.rb
+- lib/modular_tree/version.rb
+- modular_tree.gemspec
+- sig/modular_tree.rbs
+homepage: http://www.nowhere.com/
+licenses: []
+metadata:
+  homepage_uri: http://www.nowhere.com/
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.18
+signing_key:
+specification_version: 4
+summary: Gem modular_tree
+test_files: []