modular_tree 0.0.1 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 87b4426ea3d2f00ff5959831b0297d21190fee942d720f9e239cccc74e02ddcb
-  data.tar.gz: feb82cbe67f18d2f0855f041a4612fbe023ae5564706123dee7bbef1e0d39b4a
+  metadata.gz: 1b145f3b7daeb0bddc2a2415e3a98d6d6232d95afeca8147908bffa2089ff412
+  data.tar.gz: 68271887a655b0196e5f9819f72ee80ca9e853c15568ab48cc1d7e15c4a29d22
 SHA512:
-  metadata.gz: ef3db04b865ec12612ccae42104bad67344892857f3bed8b523cc70b4aaab9ace7675cbb30bfab751143c741d0e45c13157cc6f8594b90f296fb4e2fb0efe15a
-  data.tar.gz: dc1b4179bf2f46d3506af4c8660d71d552ff07567dda93403a5eca618744ca1a2aa53f8adf7f89d251d9b9f3ea4acb3080df4bd0933b4b33840656e8f874fc00
+  metadata.gz: b9a39254ef102c23dbba9445b5b95b3d925d0954ef28de91107318c24ce9c450dd1fc2612cae18fc2c4033314bcd85b14a7126eb09e01daee076e380b05fe54c
+  data.tar.gz: 3b84c591c7816199835041074b6fb8b9506c5b85b438000045ce4d21627559835edeadf0336ca6635d76cef563082254318a1cf13d15342c431f407f51868615

data/lib/modular_tree/algorithms.rb

@@ -63,11 +63,21 @@ module Tree
     # 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)
+    def each(*filter, this: true, &block) = common_each(*filter, :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
+    def select(filter = nil, this: true, &block)
+      if block_given?
+        each(block, true, this: this).to_a
+      else
+        each(filter || true, true, this: this)
+      end
+    end
 
     # 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)
+    def nodes(*filter, this: true, &block) = common_each(*filter, :node, :do_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)

data/lib/modular_tree/filter.rb

@@ -6,9 +6,9 @@ module Tree
     # 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:
+    # 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:
     #
     #   when +select+ is
     #     true    Select always. This is the default
@@ -17,14 +17,17 @@ module Tree
     #     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
+    #             used when +select+ is true. TODO: Explain
     #
     # 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
+    # It is not an error if the method doesn't exists on the a given node but
+    # 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
     #
     # Filters should not have side-effects because they can be used in
     # enumerators that doesn't execute the filter unless the enumerator is

data/lib/modular_tree/implementations.rb

@@ -69,7 +69,7 @@ module Tree
 
     def node = array
     def this = array.first
-    def value = array.first
+    def 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/properties.rb

@@ -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.1"
+  VERSION = "0.0.3"
 end

data/lib/modular_tree.rb

@@ -39,9 +39,10 @@ module Tree
   class ArrayTree < AbstractTree # Aka. SetTree aka. Tree
     include InternalParentImplementation
     include InternalChildrenArrayImplementation
-    include InternalParentChildImplementation
+    include InternalParentChildArrayImplementation
     include UpTreeAlgorithms
     include DownTreeAlgorithms
+    include DownTreeFilteredAlgorithms
 
     def self.filter(*args) = DownTreeAlgorithms.filter(*args)
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: modular_tree
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.3
 platform: ruby
 authors:
 - Claus Rasmussen