modular_tree 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ab7be4bf786460addacf0cabad30d5b8c0f5a0aa00900e894f933fd6f53230be
-  data.tar.gz: 6b9c53ba9e2edccaa298bf1696e466dccfec7262c0cb5190bd82e1cf3055d60f
+  metadata.gz: a3644f92428a2febb9c5eae96e14a4fb560f4661bf7b16234779dfa00f56395c
+  data.tar.gz: 527392507133a17f32e157e26f6ab670998d157858efbc8e7b31dbc892ab0128
 SHA512:
-  metadata.gz: 471dc9d79129be7692a3442a72ad03da18203461a7741a3815d2cb71a69c93ae68c5af787769cee2c6af14a8d787b5a1867551d681b8a88826be05227c47b2d1
-  data.tar.gz: 1b676cc1284e7bd48611da0cf99912262ca7f9eb4cfd8edd801e4f1ecbd5ec73941bd8cfebd069242024f71993302aa1766ef44cc38278fd0659d5791c2bec8b
+  metadata.gz: 339ac6d0bcdb76f76234db24f166755bbf3ab5760acf9288a790f1db047f36ad9202aad55af4304b1e72abacd1a18d106d0e046de1671821fd619df9857fdbec
+  data.tar.gz: b2953433442cfd6eb6beba7ab2fb6940d1031b8b13bf6ee0ce7eece775895c69ed059573b931c05738627089717c5aed4423f872c9c4529ff9cfb3efd46c4f37

data/lib/modular_tree/algorithms.rb

@@ -61,9 +61,10 @@ module Tree
     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, :do_each_preorder, this, &block)
+    # called with value, key, and parent as arguments but it may choose to
+    # ignore the key and/or parent argument. Returns an enumerator of values
+    # without a block
+    def each(*filter, this: true, &block) = common_each(*filter, :node_value, :do_each_preorder, this, &block)
 
     # Implementation of Enumerable#select extended with a single filter. As
     # #each, the block is called with value, key, and parent arguments
@@ -83,22 +84,49 @@ module Tree
     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)
+    def postorder(*filter, this: true) = common_each(*filter, :node_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
     #
+    # FIXME: Not working right now. Not sure how #edges relates to #pairs
     def edges(*filter, this: true, &block)
-      if block_given
+      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
+    # Find nodes matching +filter+ and call +traverse_block+ with a node and a
+    # block argument. +traverse_block+ can recurse into children by calling the
+    # supplied inner block
+    #
+    # An example of how to create a nested array implementation:
+    #
+    #   root.traverse(true) { |node, inner| [node, inner.call(node)] }
+    #
+    def traverse(*filter, this: true, &traverse_block)
+      filter = self.class.filter(*filter)
+      inner_block_proxy = [nil] # Hack because you can't refer to a lambda within its declaration
+      inner_block = inner_block_proxy[0] = lambda { |node|
+        node.nodes(filter, this: false).map { |n| traverse_block.call(n, inner_block_proxy.first) }
+      }
+      nodes(filter, this: this).map { |node| traverse_block.call(node, inner_block) }
+    end
+    
+    # Return array of [previous-matching-node, matching-node] tuples
+    def pairs(first_matcher_expr, second_matcher_expr, this: true)
+      first_matcher = Matcher.new(first_matcher_expr)
+      second_matcher = Matcher.new(second_matcher_expr)
+      or_matcher = first_matcher | second_matcher # avoids re-computing this value over and over
+      result = []
+      nodes(first_matcher, false, this: this) { |node|
+        node.do_pairs(result, first_matcher, or_matcher)
+      }
+      result
+    end
 
     # Traverse the tree top-down while accumulating information in an
     # accumulator object. The block takes a [accumulator, node] tuple and is
@@ -126,10 +154,7 @@ module Tree
       do_aggregate(filter, this, &block)
     end
 
-    # Stops further recursion if the block returns truthy
-    def propagate(*filter, this: true, &block)
-      
-    end
+#   def propagate(*filter, this: true, &block) raise NotImplemented end
 
     # tree.each(DocumentNode).select(BriefNode).each { |doc, brief| ... }
     # tree.edges(DocumentNode, BriefNode).group.all? { |doc, briefs| briefs.size <= 1 }
@@ -142,7 +167,7 @@ module Tree
         args.size == 1 or raise ArgumentError
         args.first
       else
-        Filter.new(*args) 
+        Filter.new(*args)
       end
     end
 
@@ -156,6 +181,16 @@ module Tree
       end
     end
 
+    def do_pairs(acc, first_matcher, or_matcher) # self is matched by first_matcher
+      nodes(or_matcher, false, this: false) { |node|
+        if first_matcher.match?(node)
+          node.do_pairs(acc, first_matcher, or_matcher)
+        else
+          acc << [self, node]
+        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)
@@ -192,15 +227,15 @@ module Tree
       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_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)
@@ -214,9 +249,8 @@ module Tree
       values = traverse ? each_branch { |branch| 
         r = branch.do_aggregate(filter, true, &block) 
       }.to_a : []
-      yield(self.value, values)
+      yield(self.node_value, values)
     end
-
   end
 
   module DownTreeAlgorithms

data/lib/modular_tree/filter.rb

@@ -1,86 +1,62 @@
 module Tree
   class Filter
+    # :call-seq:
+    #   Filter.new(select_expr, traverse_expr)
+    #   Filter.new(select_expr, &block)
+    #   Filter.new(&block)
+    #
     # 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, Class, or an array of classes. In
-    # addition, +select+ can be true, and +traverse+ can be true, false, or
-    # nil. These values have special meanings:
+    # The expressions can be a Matcher object or one of Matcher's initializers:
+    # Proc, Symbol, Class, or an array of classes. In addition, +select+ can be
+    # true, and +traverse+ can be true, false, or nil. These values have
+    # special meanings:
     #
     #   when +select+ is
     #     true    Select always. This is the default
+    #     false   This is an allowed value but it doesn't select any node
     #
     #   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. TODO: Explain
+    #     nil     Expects +select+ to be a Proc object that returns a [select,
+    #             traverse] tuple of booleans
     #
     # 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 on the a given node but
-    # the node is not selected/traversed
+    # the node is not selected/traversed. If the expression is a class or an
+    # array of classes, a given node matches if it is an instance of one of the
+    # classes or any subclass
     #
-    # If the expression is a class or an array of classes, a given node matches
-    # if it is an instance of one of the classes or any subclass
+    # If a block is given, it is supposed to return a [select, traverse] tuple
+    # of booleans
     #
     # 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
+    def initialize(select_expr = nil, traverse_expr = nil, &block)
+      if select_expr.nil? && block_given?
+        @matcher = block
+      else
+        select_expr = true if select_expr.nil?
+        select = Matcher.new(select_expr)
+        traverse_expr = (block_given? ? block : true) if traverse_expr.nil?
+        traverse = traverse_expr ? Matcher.new(traverse_expr) : !select
+        @matcher = lambda { |node| [select.match?(node), traverse.match?(node)] }
+      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

@@ -29,7 +29,7 @@ module Tree
     include Implementation
     def node = self
     def this = self
-    def value = self
+    def node_value = self
   end
 
   module ParentImplementation
@@ -69,7 +69,7 @@ module Tree
 
     def node = array
     def this = array.first
-    def value = array.first # FIXME What is this? It is a problem several places
+    def node_value = array.first # FIXME What is this? It is a problem several places
 
     attr_accessor :array
 
@@ -167,6 +167,33 @@ module Tree
 
     def each_child(&block) = @children.map(&block)
     def attach(child) = @children << child
+
+    # Can be used with any array implementation
+    def insert(where, child) = insert_append(:insert, where, child)
+    def append(where, child) = insert_append(:append, where, child)
+
+    def replace(where, *children)
+      children = Array(children).flatten
+      case where
+        when Integer
+          subject = @children[where] or raise ArgumentError
+          index = where
+        else
+          subject = where
+          index = @children.index(where) or raise ArgumentError
+      end
+      @children = @children[0...index] + children + @children[index + 1..-1]
+      subject
+    end
+
+  protected
+    def insert_append(which, where, child)
+      if !where.is_a?(Integer)
+        where = @children.index(where) or raise ArgumentError, "Can't find object"
+      end
+      where += 1 if which == :append
+      @children.insert(where, child)
+    end
   end
 
   module InternalChildrenHashImplementation
@@ -198,5 +225,28 @@ module Tree
       child.send(:parent=, self)
     end
   end
+
+  module InternalParentChildArrayImplementation
+    include InternalParentChildImplementation
+
+    def insert(where, child)
+      super
+      child.send(:parent=, self)
+    end
+
+    def append(where, child)
+      super
+      child.send(:parent=, self)
+    end
+
+    # Requires that Child classes already has defined this
+    def replace(where, *children)
+      children = Array(children).flatten
+      subject = super(where, children)
+      subject.send(:parent=, nil)
+      children.each { |child| child.send(:parent=, self) }
+      subject
+    end
+  end
 end
 

data/lib/modular_tree/matcher.rb

@@ -0,0 +1,64 @@
+module Tree
+  class AbstractMatcher
+    def match(node) = abstract_method
+
+    def |(other) = MatchExpression::OrExpr.new(self, other)
+    def &(other) = MatchExpression::AndExpr.new(self, other)
+    def !() = MatchExpression::NegationExpr.new(self)
+  end
+  
+  class Matcher < AbstractMatcher
+    def match(node) = match?(node)
+
+    def match?(node)
+      case @expr
+        when Proc
+          @expr.call(node)
+        when Symbol
+          node.respond_to?(@expr) && node.send(@expr)
+        when Class
+          node.is_a? @expr
+        when Array
+          @expr.any? { |klass| node.is_a? klass }
+        when true, false
+          @expr
+      else
+        raise ArgumentError, @expr.inspect
+      end
+    end
+
+    def initialize(expr = nil, &block)
+      constrain expr, Proc, Symbol, Class, [Class], true, false, nil
+      expr.nil? == block_given? or raise ArgumentError
+      @expr = (expr.nil? ? block : expr)
+    end
+
+    def self.new(expr = nil, *args, &block)
+      expr.is_a?(AbstractMatcher) ? expr : super
+    end
+  end
+
+  module MatchExpression
+    class BinaryExpr < AbstractMatcher
+      def initialize(left, right)
+        constrain left, Matcher
+        constrain right, Matcher
+        @left, @right = left, right
+      end
+    end
+
+    class AndExpr < BinaryExpr
+      def match?(node) = @left.match?(node) && @right.match?(node)
+    end
+
+    class OrExpr < BinaryExpr
+      def match?(node) = @left.match?(node) || @right.match?(node) ? true : false
+    end
+
+    class NegationExpr < AbstractMatcher
+      def initialize(matcher) = @matcher = matcher
+      def match?(node) = !@matcher.match?(node)
+    end
+  end
+end
+

data/lib/modular_tree/properties.rb

@@ -13,7 +13,7 @@ module Tree
     def node = abstract_method
 
     # FIXME: What is this. Also describe all properties in this file
-    def value = abstract_method
+    def node_value = abstract_method
   end
 
   module StemProperty # Aka. 'parent'
@@ -36,6 +36,10 @@ module Tree
     def attach(child) = abstract_method
   end
 
+  # TODO
+  module ParentChildProperty
+  end
+
   module KeyProperty # Set
     def key = abstract_method
   end

data/lib/modular_tree/version.rb

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

data/lib/modular_tree.rb

@@ -10,6 +10,7 @@ include ForwardTo
 
 require_relative "modular_tree/version"
 require_relative "modular_tree/separator"
+require_relative "modular_tree/matcher"
 require_relative "modular_tree/filter"
 require_relative "modular_tree/pairs"
 
@@ -39,7 +40,7 @@ module Tree
   class ArrayTree < AbstractTree # Aka. SetTree aka. Tree
     include InternalParentImplementation
     include InternalChildrenArrayImplementation
-    include InternalParentChildImplementation
+    include InternalParentChildArrayImplementation
     include UpTreeAlgorithms
     include DownTreeAlgorithms
     include DownTreeFilteredAlgorithms

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: modular_tree
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors:
 - Claus Rasmussen
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-12-04 00:00:00.000000000 Z
+date: 2022-12-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: constrain
@@ -82,6 +82,7 @@ files:
 - lib/modular_tree/algorithms.rb
 - lib/modular_tree/filter.rb
 - lib/modular_tree/implementations.rb
+- lib/modular_tree/matcher.rb
 - lib/modular_tree/pairs.rb
 - lib/modular_tree/pool.rb
 - lib/modular_tree/properties.rb