callable_tree 0.1.2 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 822f8080ff2652895cd3cb7255d856eea72290564dbe7054d93c2fca01ac6149
-  data.tar.gz: 783496e58325e0d5be2595b3c33b0acd1095c61400b89addc0ce9d8fc8e845db
+  metadata.gz: 8e5f087271cbaf840a0cb6557126331b67487c4f87e5843e3bcf900c54dc6e84
+  data.tar.gz: d1d1e0ac4a085dc26d1a2f6bec141ea92ea80efbfb43c8738e34d9ae9280836c
 SHA512:
-  metadata.gz: '0381d33a9f1a82b524aa176574d24961e7585ebb4ea76185759be2d17d739b9c84612b0ed9f7f2323083a71515acbf6fa622b65528c5a903dd911147bebfb7c7'
-  data.tar.gz: 9b715d2b2fd6ca25c1bf8c446574a2097271525facc306198695d01fbadffd2e7823866e16c58c83cb8a7f08dc8047909023ecc8256d083f07854b9c714a57ac
+  metadata.gz: 0a342b5fff3ce51c36bd4e4e1977f2023db7045bab0f19e794bc8a1c48442c184cedfcadad5a0b9956fe146a0904aaca584a6d23c5ac23c063dc53d8d260978a
+  data.tar.gz: 6fd3e33d25e549774488967d600ef236bff9e74bc750741eff9e5c6d3e5c59b15f2c956c1f25b97f5e9cd16becb7004e6df298adf04c01844aa300dc1e2e42b3

data/.ruby-version

@@ -1 +1 @@
-3.0.0
+3.0.2

data/CHANGELOG.md

@@ -1,5 +1,25 @@
 ## [Unreleased]
 
+## [0.2.2] - 2021-10-24
+- Add `CallableTree::Node::Internal#reject` to return a new node instance without rejected child nodes.
+- Add `CallableTree::Node::Internal#reject!` to destructively reject child nodes.
+
+## [0.2.1] - 2021-07-24
+- Add `CallableTree::Node#root?`.
+- Add `CallableTree::Node::Internal#seek!` that make destructive change.
+- Add `CallableTree::Node::Internal#broadcast!` that make destructive change.
+- Add `CallableTree::Node::Internal#compose!` that make destructive change.
+
+## [0.2.0] - 2021-06-15
+- Change `CallableTree::Node::Internal#append` to return a new instance.
+  To keep the same behavior as the older version, use `CallableTree::Node::External#append!` that make destructive change.
+- Remove `CallableTree::Node::Internal#<<`. Use `CallableTree::Node::External#append!` instead.
+- Change `CallableTree::Node::External#verbosify` to return a new instance.
+  To keep the same behavior as the older version, use `CallableTree::Node::External#verbosify!` that make destructive change.
+
+## [0.1.3] - 2021-06-12
+- Minor improvements
+
 ## [0.1.2] - 2021-05-29
 
 - Add `CallableTree::Node::Internal#compose` (experimental)

data/Gemfile.lock

@@ -1,13 +1,13 @@
 PATH
   remote: .
   specs:
-    callable_tree (0.1.2)
+    callable_tree (0.2.2)
 
 GEM
   remote: https://rubygems.org/
   specs:
     diff-lcs (1.4.4)
-    rake (13.0.3)
+    rake (13.0.6)
     rspec (3.10.0)
       rspec-core (~> 3.10.0)
       rspec-expectations (~> 3.10.0)
@@ -32,4 +32,4 @@ DEPENDENCIES
   rspec (~> 3.0)
 
 BUNDLED WITH
-   2.2.17
+   2.2.22

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2021 　
+Copyright (c) 2021 jsmmr
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -1,5 +1,7 @@
 # CallableTree
 
+[![build](https://github.com/jsmmr/ruby_callable_tree/actions/workflows/build.yml/badge.svg)](https://github.com/jsmmr/ruby_callable_tree/actions/workflows/build.yml)
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -18,19 +20,22 @@ Or install it yourself as:
 
 ## Usage
 
+Builds a tree by linking instances of the nodes. The `call` method of the node where the `match?` method returns a truthy value is called in a chain from the root node to the leaf node.
+
 - `CallableTree::Node::Internal`
-  - This `module` is used to define a node that can have child nodes.
+  - This `module` is used to define a node that can have child nodes. An instance of this node has several strategies. The strategy can be changed by calling the method of the instance.
 - `CallableTree::Node::External`
   - This `module` is used to define a leaf node that cannot have child nodes.
 - `CallableTree::Node::Root`
   - This `class` includes `CallableTree::Node::Internal`. When there is no need to customize the internal node, use this `class`.
 
-Builds a tree by linking instances of the nodes. The `call` method of the node where the `match?` method returns a truthy value is called in a chain from the root node to the leaf node.
-If the `call` method returns a value other than `nil`, the next sibling node does not be called. This behavior is changeable by overriding the `terminate?` method.
-
 ### Basic
 
-`examples/example1.rb`:
+#### `CallableTree::Node::Internal#seek` (default)
+
+This strategy does not call the next sibling node if the `call` method of the current node returns a value other than `nil`. This behavior is changeable by overriding the `terminate?` method.
+
+`examples/internal-seek.rb`:
 ```ruby
 module Node
   module JSON
@@ -123,16 +128,17 @@ module Node
   end
 end
 
+# The `seek` method call can be omitted since it is the default strategy.
 tree = CallableTree::Node::Root.new.append(
   Node::JSON::Parser.new.append(
     Node::JSON::Scraper.new(type: :animals),
     Node::JSON::Scraper.new(type: :fruits)
-  ),
+  ),#.seek,
   Node::XML::Parser.new.append(
     Node::XML::Scraper.new(type: :animals),
     Node::XML::Scraper.new(type: :fruits)
-  )
-)
+  )#.seek
+)#.seek
 
 Dir.glob(__dir__ + '/docs/*') do |file|
   options = { foo: :bar }
@@ -141,9 +147,9 @@ Dir.glob(__dir__ + '/docs/*') do |file|
 end
 ```
 
-Run `examples/example1.rb`:
+Run `examples/internal-seek.rb`:
 ```sh
-% ruby examples/example1.rb
+% ruby examples/internal-seek.rb
 {"Dog"=>"🐶", "Cat"=>"🐱"}
 ---
 {"Dog"=>"🐶", "Cat"=>"🐱"}
@@ -154,13 +160,121 @@ Run `examples/example1.rb`:
 ---
 ```
 
+#### `CallableTree::Node::Internal#broadcast`
+
+This strategy calls all child nodes of the internal node and ignores their `terminate?` methods, and then outputs their results as array.
+
+`examples/internal-broadcast.rb`:
+```ruby
+module Node
+  class LessThan
+    include CallableTree::Node::Internal
+
+    def initialize(num)
+      @num = num
+    end
+
+    def match?(input)
+      super && input < @num
+    end
+  end
+end
+
+tree = CallableTree::Node::Root.new.append(
+  Node::LessThan.new(5).append(
+    lambda { |input, **| input * 2 }, # anonymous external node
+    lambda { |input, **| input + 1 }  # anonymous external node
+  ).broadcast,
+  Node::LessThan.new(10).append(
+    lambda { |input, **| input * 3 }, # anonymous external node
+    lambda { |input, **| input - 1 }  # anonymous external node
+  ).broadcast
+).broadcast
+
+(0..10).each do |input|
+  output = tree.call(input)
+  puts "#{input} -> #{output}"
+end
+
+```
+
+Run `examples/internal-broadcast.rb`:
+```sh
+% ruby examples/internal-broadcast.rb
+0 -> [[0, 1], [0, -1]]
+1 -> [[2, 2], [3, 0]]
+2 -> [[4, 3], [6, 1]]
+3 -> [[6, 4], [9, 2]]
+4 -> [[8, 5], [12, 3]]
+5 -> [nil, [15, 4]]
+6 -> [nil, [18, 5]]
+7 -> [nil, [21, 6]]
+8 -> [nil, [24, 7]]
+9 -> [nil, [27, 8]]
+10 -> [nil, nil]
+```
+
+#### `CallableTree::Node::Internal#compose`
+
+This strategy calls all child nodes of the internal node in order to input the output of the previous node to the next node and ignores their `terminate?` methods, and then outputs a single result.
+
+`examples/internal-compose.rb`:
+```ruby
+module Node
+  class LessThan
+    include CallableTree::Node::Internal
+
+    def initialize(num)
+      @num = num
+    end
+
+    def match?(input)
+      super && input < @num
+    end
+  end
+end
+
+tree = CallableTree::Node::Root.new.append(
+  Node::LessThan.new(5).append(
+    proc { |input| input * 2 }, # anonymous external node
+    proc { |input| input + 1 }  # anonymous external node
+  ).compose,
+  Node::LessThan.new(10).append(
+    proc { |input| input * 3 }, # anonymous external node
+    proc { |input| input - 1 }  # anonymous external node
+  ).compose
+).compose
+
+(0..10).each do |input|
+  output = tree.call(input)
+  puts "#{input} -> #{output}"
+end
+
+```
+
+Run `examples/internal-compose.rb`:
+```sh
+% ruby examples/internal-compose.rb
+0 -> 2
+1 -> 8
+2 -> 14
+3 -> 20
+4 -> 26
+5 -> 14
+6 -> 17
+7 -> 20
+8 -> 23
+9 -> 26
+10 -> 10
+```
+
 ### Advanced
 
 #### `CallableTree::Node::External#verbosify`
 
-If you want verbose result, call it.
+If you want verbose output results, call this method.
 
-`examples/example2.rb`:
+`examples/external-verbosify.rb`:
 ```ruby
 ...
 
@@ -178,9 +292,9 @@ tree = CallableTree::Node::Root.new.append(
 ...
 ```
 
-Run `examples/example2.rb`:
+Run `examples/external-verbosify.rb`:
 ```sh
-% ruby examples/example2.rb
+% ruby examples/external-verbosify.rb
 #<struct CallableTree::Node::External::Output
  value={"Dog"=>"🐶", "Cat"=>"🐱"},
  options={:foo=>:bar},
@@ -208,9 +322,9 @@ You can work around it by overriding the `identity` method of the node.
 
 #### `CallableTree::Node#identity`
 
-If you want to customize the node identity, override it.
+If you want to customize the node identity, override this method.
 
-`examples/example3.rb`:
+`examples/identity.rb`:
 ```ruby
 module Node
   class Identity
@@ -266,9 +380,9 @@ end
 ...
 ```
 
-Run `examples/example3.rb`:
+Run `examples/identity.rb`:
 ```sh
-% ruby examples/example3.rb
+% ruby examples/identity.rb
 #<struct CallableTree::Node::External::Output
  value={"Dog"=>"🐶", "Cat"=>"🐱"},
  options={:foo=>:bar},
@@ -315,7 +429,7 @@ Run `examples/example3.rb`:
 
 This is an example of logging.
 
-`examples/example4.rb`:
+`examples/logging.rb`:
 ```ruby
 module Node
   module Logging
@@ -388,9 +502,9 @@ end
 ...
 ```
 
-Run `examples/example4.rb`:
+Run `examples/logging.rb`:
 ```sh
-% ruby examples/example4.rb
+% ruby examples/logging.rb
 * Node::JSON::Parser: [matched: true]
   * Node::JSON::Scraper(animals): [matched: true]
     Input : {"animals"=>[{"name"=>"Dog", "emoji"=>"🐶"}, {"name"=>"Cat", "emoji"=>"🐱"}]}
@@ -455,7 +569,7 @@ Run `examples/example4.rb`:
 
 #### `CallableTree::Node::Hooks::Call` (experimental)
 
-`examples/example5.rb`:
+`examples/hooks-call.rb`:
 ```ruby
 module Node
   class HooksSample
@@ -493,9 +607,9 @@ Node::HooksSample.new
   end
 ```
 
-Run `examples/example5.rb`:
+Run `examples/hooks-call.rb`:
 ```sh
-% ruby examples/example5.rb
+% ruby examples/hooks-call.rb
 before_call input: 1
 external input: 2
 around_call input: 2
@@ -504,95 +618,6 @@ after_call output: 8
 result: 16
 ```
 
-#### `CallableTree::Node::Internal#broadcast` (experimental)
-
-If you want to call all child nodes of the internal node in order to output their results as array, call it. The `broadcast` strategy ignores the `terminate?` method of the nodes.
-
-`examples/example6.rb`:
-```ruby
-...
-
-tree = CallableTree::Node::Root.new.append(
-  Node::JSON::Parser.new.append(
-    Node::JSON::Scraper.new(type: :animals),
-    Node::JSON::Scraper.new(type: :fruits)
-  ).broadcast,
-  Node::XML::Parser.new.append(
-    Node::XML::Scraper.new(type: :animals),
-    Node::XML::Scraper.new(type: :fruits)
-  ).broadcast
-)
-
-...
-```
-
-Run `examples/example6.rb`:
-```sh
-% ruby examples/example6.rb
-[{"Dog"=>"🐶", "Cat"=>"🐱"}, nil]
----
-[{"Dog"=>"🐶", "Cat"=>"🐱"}, nil]
----
-[nil, {"Red Apple"=>"🍎", "Green Apple"=>"🍏"}]
----
-[nil, {"Red Apple"=>"🍎", "Green Apple"=>"🍏"}]
----
-```
-
-#### `CallableTree::Node::Internal#compose` (experimental)
-
-If you want to call all child nodes of the internal node in order to input the output of the previous node to the next node and output a single result , call it. The `compose` strategy ignores the `terminate?` method of the nodes.
-
-`examples/example7.rb`:
-```ruby
-module Node
-  class LessThan
-    include CallableTree::Node::Internal
-
-    def initialize(num)
-      @num = num
-    end
-
-    def match?(input)
-      super && input < @num
-    end
-  end
-end
-
-tree = CallableTree::Node::Root.new.append(
-  Node::LessThan.new(5).append(
-    proc { |input| input * 2 }, # anonymous external node
-    proc { |input| input + 1 }  # anonymous external node
-  ).compose,
-  Node::LessThan.new(10).append(
-    proc { |input| input * 3 }, # anonymous external node
-    proc { |input| input - 1 }  # anonymous external node
-  ).compose
-).compose
-
-(0..10).each do |input|
-  output = tree.call(input)
-  puts "#{input} -> #{output}"
-end
-
-```
-
-Run `examples/example7.rb`:
-```sh
-% ruby examples/example7.rb
-0 -> 2
-1 -> 8
-2 -> 14
-3 -> 20
-4 -> 26
-5 -> 14
-6 -> 17
-7 -> 20
-8 -> 23
-9 -> 26
-10 -> 10
-```
-
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/jsmmr/callable_tree.

data/callable_tree.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |spec|
   spec.authors       = ['jsmmr']
   spec.email         = ['jsmmr@icloud.com']
 
-  spec.summary       = 'Builds a tree by linking callable nodes. The nodes that match the calling condition are called in a chain from the root node to the leaf node. These are like nested `if` or `case` expressions.'
-  spec.description   = 'Builds a tree by linking callable nodes. The nodes that match the calling condition are called in a chain from the root node to the leaf node. These are like nested `if` or `case` expressions.'
+  spec.summary       = 'Builds a tree by linking callable nodes. The nodes that match the conditions are called in a chain from the root node to the leaf node. These are like nested `if` or `case` expressions.'
+  spec.description   = 'Builds a tree by linking callable nodes. The nodes that match the conditions are called in a chain from the root node to the leaf node. These are like nested `if` or `case` expressions.'
   spec.homepage      = 'https://github.com/jsmmr/ruby_callable_tree'
   spec.license       = 'MIT'
   spec.required_ruby_version = Gem::Requirement.new('>= 2.4.0')

data/examples/internal-broadcast.rb

@@ -0,0 +1,31 @@
+require 'callable_tree'
+
+module Node
+  class LessThan
+    include CallableTree::Node::Internal
+
+    def initialize(num)
+      @num = num
+    end
+
+    def match?(input)
+      super && input < @num
+    end
+  end
+end
+
+tree = CallableTree::Node::Root.new.append(
+  Node::LessThan.new(5).append(
+    lambda { |input, **| input * 2 }, # anonymous external node
+    lambda { |input, **| input + 1 }  # anonymous external node
+  ).broadcast,
+  Node::LessThan.new(10).append(
+    lambda { |input, **| input * 3 }, # anonymous external node
+    lambda { |input, **| input - 1 }  # anonymous external node
+  ).broadcast
+).broadcast
+
+(0..10).each do |input|
+  output = tree.call(input)
+  puts "#{input} -> #{output}"
+end

data/lib/callable_tree/node/external/verbose.rb

@@ -6,6 +6,10 @@ module CallableTree
       Output = Struct.new(:value, :options, :routes)
 
       module Verbose
+        def verbosified?
+          true
+        end
+
         def call(input = nil, **options)
           output = super(input, **options)
           routes = self.routes

data/lib/callable_tree/node/external.rb

@@ -9,38 +9,58 @@ module CallableTree
         Proxy.new(callable)
       end
 
-      def self.proxified?(node)
-        node.is_a?(Proxy)
+      def proxified?
+        false
       end
 
-      def self.unproxify(node)
-        node.callable
+      def verbosified?
+        false
       end
 
       def verbosify
+        clone.tap do |node|
+          node.extend Verbose
+        end
+      end
+
+      def verbosify!
         extend Verbose
         self
       end
 
       def identity
-        if External.proxified?(self)
-          External.unproxify(self)
+        if proxified?
+          unproxify
         else
           self
         end
           .class
       end
 
+      private
+
+      def initialize_copy(_node)
+        super
+        self.parent = nil
+      end
+
       class Proxy
         extend ::Forwardable
         include External
 
         def_delegators :@callable, :call
-        attr_reader :callable
 
         def initialize(callable)
           @callable = callable
         end
+
+        def proxified?
+          true
+        end
+
+        def unproxify
+          @callable
+        end
       end
 
       private_constant :Proxy

data/lib/callable_tree/node/internal/strategy/broadcast.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module CallableTree
+  module Node
+    module Internal
+      module Strategy
+        class Broadcast
+          def call(nodes, input:, options:)
+            nodes.map do |node|
+              node.call(input, **options) if node.match?(input, **options)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/callable_tree/node/internal/strategy/compose.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module CallableTree
+  module Node
+    module Internal
+      module Strategy
+        class Compose
+          def call(nodes, input:, options:)
+            nodes.reduce(input) do |input, node|
+              if node.match?(input, **options)
+                node.call(input, **options)
+              else
+                input
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/callable_tree/node/internal/strategy/seek.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module CallableTree
+  module Node
+    module Internal
+      module Strategy
+        class Seek
+          def call(nodes, input:, options:)
+            nodes
+              .lazy
+              .select { |node| node.match?(input, **options) }
+              .map do |node|
+                output = node.call(input, **options)
+                terminated = node.terminate?(output, **options)
+                [output, terminated]
+              end
+              .select { |_output, terminated| terminated }
+              .map { |output, _terminated| output }
+              .first
+          end
+        end
+      end
+    end
+  end
+end

data/lib/callable_tree/node/internal.rb

@@ -6,75 +6,113 @@ module CallableTree
       include Node
 
       def children
-        @children ||= []
+        # TODO: Change to return a new array instance.
+        child_nodes
       end
 
-      def <<(callable)
-        children <<
-          if callable.is_a?(Node)
-            callable.clone
-          else
-            External.proxify(callable)
-          end
-          .tap { |node| node.send(:parent=, self) }
+      def append(*callables)
+        clone.tap do |node|
+          node.append!(*callables)
+        end
+      end
+
+      def append!(*callables)
+        callables
+          .map { |callable| nodeify(callable) }
+          .tap { |nodes| child_nodes.push(*nodes) } # Use Array#push for Ruby 2.4
 
         self
       end
 
-      def append(*callables)
-        callables.each { |callable| self.<<(callable) }
+      def reject(&block)
+        clone.tap do |node|
+          node.reject!(&block)
+        end
+      end
+
+      def reject!(&block)
+        child_nodes.reject!(&block)
         self
       end
 
       def match?(_input = nil, **_options)
-        !children.empty?
+        !child_nodes.empty?
       end
 
       def call(input = nil, **options)
-        strategy.call(children, input: input, options: options)
+        strategy.call(child_nodes, input: input, options: options)
       end
 
       def seek
-        if strategy.is_a?(Seek)
+        if strategy.is_a?(Strategy::Seek)
           self
         else
           clone.tap do |node|
-            node.send(:strategy=, Seek.new)
+            node.send(:strategy=, Strategy::Seek.new)
           end
         end
       end
 
+      def seek!
+        self.strategy = Strategy::Seek.new unless strategy.is_a?(Strategy::Seek)
+        self
+      end
+
       def broadcast
-        if strategy.is_a?(Broadcast)
+        if strategy.is_a?(Strategy::Broadcast)
           self
         else
           clone.tap do |node|
-            node.send(:strategy=, Broadcast.new)
+            node.send(:strategy=, Strategy::Broadcast.new)
           end
         end
       end
 
+      def broadcast!
+        self.strategy = Strategy::Broadcast.new unless strategy.is_a?(Strategy::Broadcast)
+        self
+      end
+
       def compose
-        if strategy.is_a?(Compose)
+        if strategy.is_a?(Strategy::Compose)
           self
         else
           clone.tap do |node|
-            node.send(:strategy=, Compose.new)
+            node.send(:strategy=, Strategy::Compose.new)
           end
         end
       end
 
+      def compose!
+        self.strategy = Strategy::Compose.new unless strategy.is_a?(Strategy::Compose)
+        self
+      end
+
       private
 
-      attr_writer :children, :strategy
+      attr_writer :child_nodes, :strategy
+
+      def child_nodes
+        @child_nodes ||= []
+      end
+
+      def nodeify(callable)
+        if callable.is_a?(Node)
+          callable.clone
+        else
+          External.proxify(callable)
+        end
+        .tap { |node| node.send(:parent=, self) }
+      end
 
       def strategy
-        @strategy ||= Seek.new
+        @strategy ||= Strategy::Seek.new
       end
 
       def initialize_copy(_node)
         super
-        self.children = children.map do |node|
+        self.parent = nil
+        self.child_nodes = child_nodes.map do |node|
           node.clone.tap { |new_node| new_node.send(:parent=, self) }
         end
       end

data/lib/callable_tree/node.rb

@@ -4,12 +4,16 @@ module CallableTree
   module Node
     attr_reader :parent
 
+    def root?
+      parent.nil?
+    end
+
     def ancestors
       ::Enumerator.new do |y|
         node = self
         loop do
           y << node
-          break unless node = node&.parent
+          break unless node = node.parent
         end
       end
     end
@@ -23,7 +27,7 @@ module CallableTree
     end
 
     def depth
-      parent.nil? ? 0 : parent.depth + 1
+      root? ? 0 : parent.depth + 1
     end
 
     def match?(_input = nil, **_options)

data/lib/callable_tree/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CallableTree
-  VERSION = '0.1.2'
+  VERSION = '0.2.2'
 end

data/lib/callable_tree.rb

@@ -8,9 +8,9 @@ require 'forwardable'
 require_relative 'callable_tree/version'
 require_relative 'callable_tree/node'
 require_relative 'callable_tree/node/hooks/call'
-require_relative 'callable_tree/node/internal/broadcast'
-require_relative 'callable_tree/node/internal/seek'
-require_relative 'callable_tree/node/internal/compose'
+require_relative 'callable_tree/node/internal/strategy/broadcast'
+require_relative 'callable_tree/node/internal/strategy/seek'
+require_relative 'callable_tree/node/internal/strategy/compose'
 require_relative 'callable_tree/node/external/verbose'
 require_relative 'callable_tree/node/external'
 require_relative 'callable_tree/node/internal'

metadata

@@ -1,18 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: callable_tree
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.2
 platform: ruby
 authors:
 - jsmmr
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-05-29 00:00:00.000000000 Z
+date: 2021-10-24 00:00:00.000000000 Z
 dependencies: []
-description: Builds a tree by linking callable nodes. The nodes that match the calling
-  condition are called in a chain from the root node to the leaf node. These are like
-  nested `if` or `case` expressions.
+description: Builds a tree by linking callable nodes. The nodes that match the conditions
+  are called in a chain from the root node to the leaf node. These are like nested
+  `if` or `case` expressions.
 email:
 - jsmmr@icloud.com
 executables: []
@@ -36,22 +36,22 @@ files:
 - examples/docs/animals.xml
 - examples/docs/fruits.json
 - examples/docs/fruits.xml
-- examples/example1.rb
-- examples/example2.rb
-- examples/example3.rb
-- examples/example4.rb
-- examples/example5.rb
-- examples/example6.rb
-- examples/example7.rb
+- examples/external-verbosify.rb
+- examples/hooks-call.rb
+- examples/identity.rb
+- examples/internal-broadcast.rb
+- examples/internal-compose.rb
+- examples/internal-seek.rb
+- examples/logging.rb
 - lib/callable_tree.rb
 - lib/callable_tree/node.rb
 - lib/callable_tree/node/external.rb
 - lib/callable_tree/node/external/verbose.rb
 - lib/callable_tree/node/hooks/call.rb
 - lib/callable_tree/node/internal.rb
-- lib/callable_tree/node/internal/broadcast.rb
-- lib/callable_tree/node/internal/compose.rb
-- lib/callable_tree/node/internal/seek.rb
+- lib/callable_tree/node/internal/strategy/broadcast.rb
+- lib/callable_tree/node/internal/strategy/compose.rb
+- lib/callable_tree/node/internal/strategy/seek.rb
 - lib/callable_tree/node/root.rb
 - lib/callable_tree/version.rb
 homepage: https://github.com/jsmmr/ruby_callable_tree
@@ -60,7 +60,7 @@ licenses:
 metadata:
   homepage_uri: https://github.com/jsmmr/ruby_callable_tree
   source_code_uri: https://github.com/jsmmr/ruby_callable_tree
-  changelog_uri: https://github.com/jsmmr/ruby_callable_tree/blob/v0.1.2/CHANGELOG.md
+  changelog_uri: https://github.com/jsmmr/ruby_callable_tree/blob/v0.2.2/CHANGELOG.md
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -76,10 +76,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.16
+rubygems_version: 3.2.22
 signing_key:
 specification_version: 4
-summary: Builds a tree by linking callable nodes. The nodes that match the calling
-  condition are called in a chain from the root node to the leaf node. These are like
-  nested `if` or `case` expressions.
+summary: Builds a tree by linking callable nodes. The nodes that match the conditions
+  are called in a chain from the root node to the leaf node. These are like nested
+  `if` or `case` expressions.
 test_files: []

data/examples/example6.rb

@@ -1,101 +0,0 @@
-require 'callable_tree'
-require 'json'
-require 'rexml/document'
-
-module Node
-  module JSON
-    class Parser
-      include CallableTree::Node::Internal
-
-      def match?(input, **options)
-        File.extname(input) == '.json'
-      end
-
-      def call(input, **options)
-        File.open(input) do |file|
-          json = ::JSON.load(file)
-          super(json, **options)
-        end
-      end
-
-      def terminate?(_output, **)
-        true
-      end
-    end
-
-    class Scraper
-      include CallableTree::Node::External
-
-      def initialize(type:)
-        @type = type
-      end
-
-      def match?(input, **options)
-        !!input[@type.to_s]
-      end
-
-      def call(input, **options)
-        input[@type.to_s]
-          .map { |element| [element['name'], element['emoji']] }
-          .to_h
-      end
-    end
-  end
-
-  module XML
-    class Parser
-      include CallableTree::Node::Internal
-
-      def match?(input, **options)
-        File.extname(input) == '.xml'
-      end
-
-      def call(input, **options)
-        File.open(input) do |file|
-          super(REXML::Document.new(file), **options)
-        end
-      end
-
-      def terminate?(_output, **)
-        true
-      end
-    end
-
-    class Scraper
-      include CallableTree::Node::External
-
-      def initialize(type:)
-        @type = type
-      end
-
-      def match?(input, **options)
-        !input.get_elements("//#{@type}").empty?
-      end
-
-      def call(input, **options)
-        input
-          .get_elements("//#{@type}")
-          .first
-          .map { |element| [element['name'], element['emoji']] }
-          .to_h
-      end
-    end
-  end
-end
-
-tree = CallableTree::Node::Root.new.append(
-  Node::JSON::Parser.new.append(
-    Node::JSON::Scraper.new(type: :animals),
-    Node::JSON::Scraper.new(type: :fruits)
-  ).broadcast,
-  Node::XML::Parser.new.append(
-    Node::XML::Scraper.new(type: :animals),
-    Node::XML::Scraper.new(type: :fruits)
-  ).broadcast
-)
-
-Dir.glob(__dir__ + '/docs/*') do |file|
-  options = { foo: :bar }
-  pp tree.call(file, **options)
-  puts '---'
-end

data/lib/callable_tree/node/internal/broadcast.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module CallableTree
-  module Node
-    module Internal
-      class Broadcast
-        def call(nodes, input:, options:)
-          nodes.map do |node|
-            node.call(input, **options) if node.match?(input, **options)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/callable_tree/node/internal/compose.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module CallableTree
-  module Node
-    module Internal
-      class Compose
-        def call(nodes, input:, options:)
-          nodes.reduce(input) do |input, node|
-            if node.match?(input, **options)
-              node.call(input, **options)
-            else
-              input
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/callable_tree/node/internal/seek.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module CallableTree
-  module Node
-    module Internal
-      class Seek
-        def call(nodes, input:, options:)
-          nodes
-            .lazy
-            .select { |node| node.match?(input, **options) }
-            .map do |node|
-              output = node.call(input, **options)
-              terminated = node.terminate?(output, **options)
-              [output, terminated]
-            end
-            .select { |_output, terminated| terminated }
-            .map { |output, _terminated| output }
-            .first
-        end
-      end
-    end
-  end
-end