callable_tree 0.3.7 → 0.3.9

data/README.md

@@ -21,10 +21,10 @@ 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.
+Builds a tree by linking `CallableTree` node instances. The `call` methods of the nodes where the `match?` method returns a truthy value are 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. An instance of this node has several strategies. The strategy can be changed by calling the method of the instance.
+  - This `module` is used to define a node that can have child nodes. This node has several strategies (`seekable`, `broadcastable`, `composable`).
 - `CallableTree::Node::External`
   - This `module` is used to define a leaf node that cannot have child nodes.
 - `CallableTree::Node::Root`
@@ -32,11 +32,15 @@ Builds a tree by linking instances of the nodes. The `call` method of the node w
 
 ### Basic
 
-#### `CallableTree::Node::Internal#seekable` (default)
+There are two ways to define the nodes: class style and builder style.
+
+#### `CallableTree::Node::Internal#seekable` (default strategy)
 
 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-seekable.rb`:
+##### Class style
+
+`examples/class/internal-seekable.rb`:
 ```ruby
 module Node
   module JSON
@@ -77,8 +81,7 @@ module Node
 
       def call(input, **_options)
         input[@type.to_s]
-          .map { |element| [element['name'], element['emoji']] }
-          .to_h
+          .to_h { |element| [element['name'], element['emoji']] }
       end
     end
   end
@@ -122,8 +125,7 @@ module Node
         input
           .get_elements("//#{@type}")
           .first
-          .map { |element| [element['name'], element['emoji']] }
-          .to_h
+          .to_h { |element| [element['name'], element['emoji']] }
       end
     end
   end
@@ -148,9 +150,109 @@ Dir.glob("#{__dir__}/docs/*") do |file|
 end
 ```
 
-Run `examples/internal-seekable.rb`:
+Run `examples/class/internal-seekable.rb`:
+```sh
+% ruby examples/class/internal-seekable.rb
+{"Dog"=>"🐶", "Cat"=>"🐱"}
+---
+{"Dog"=>"🐶", "Cat"=>"🐱"}
+---
+{"Red Apple"=>"🍎", "Green Apple"=>"🍏"}
+---
+{"Red Apple"=>"🍎", "Green Apple"=>"🍏"}
+---
+```
+
+##### Builder style
+
+`examples/builder/internal-seekable.rb`:
+```ruby
+JSONParser =
+  CallableTree::Node::Internal::Builder
+  .new
+  .matcher do |input, **_options|
+    File.extname(input) == '.json'
+  end
+  .caller do |input, **options, &original|
+    File.open(input) do |file|
+      json = ::JSON.load(file)
+      # The following block call is equivalent to calling `super` in the class style.
+      original.call(json, **options)
+    end
+  end
+  .terminator { true }
+  .build
+
+XMLParser =
+  CallableTree::Node::Internal::Builder
+  .new
+  .matcher do |input, **_options|
+    File.extname(input) == '.xml'
+  end
+  .caller do |input, **options, &original|
+    File.open(input) do |file|
+      # The following block call is equivalent to calling `super` in the class style.
+      original.call(REXML::Document.new(file), **options)
+    end
+  end
+  .terminator { true }
+  .build
+
+def build_json_scraper(type)
+  CallableTree::Node::External::Builder
+    .new
+    .matcher do |input, **_options|
+      !!input[type.to_s]
+    end
+    .caller do |input, **_options|
+      input[type.to_s]
+        .to_h { |element| [element['name'], element['emoji']] }
+    end
+    .build
+end
+
+AnimalsJSONScraper = build_json_scraper(:animals)
+FruitsJSONScraper = build_json_scraper(:fruits)
+
+def build_xml_scraper(type)
+  CallableTree::Node::External::Builder
+    .new
+    .matcher do |input, **_options|
+      !input.get_elements("//#{type}").empty?
+    end
+    .caller do |input, **_options|
+      input
+        .get_elements("//#{type}")
+        .first
+        .to_h { |element| [element['name'], element['emoji']] }
+    end
+    .build
+end
+
+AnimalsXMLScraper = build_xml_scraper(:animals)
+FruitsXMLScraper = build_xml_scraper(:fruits)
+
+tree = CallableTree::Node::Root.new.seekable.append(
+  JSONParser.new.seekable.append(
+    AnimalsJSONScraper.new,
+    FruitsJSONScraper.new
+  ),
+  XMLParser.new.seekable.append(
+    AnimalsXMLScraper.new,
+    FruitsXMLScraper.new
+  )
+)
+
+Dir.glob("#{__dir__}/../docs/*") do |file|
+  options = { foo: :bar }
+  pp tree.call(file, **options)
+  puts '---'
+end
+```
+
+Run `examples/builder/internal-seekable.rb`:
 ```sh
-% ruby examples/internal-seekable.rb
+% ruby examples/builder/internal-seekable.rb
 {"Dog"=>"🐶", "Cat"=>"🐱"}
 ---
 {"Dog"=>"🐶", "Cat"=>"🐱"}
@@ -163,9 +265,11 @@ Run `examples/internal-seekable.rb`:
 
 #### `CallableTree::Node::Internal#broadcastable`
 
-This strategy calls all child nodes of the internal node and ignores their `terminate?` methods, and then outputs their results as array.
+This strategy broadcasts to output a result of the child nodes as array. It also ignores their `terminate?` methods by default.
 
-`examples/internal-broadcastable.rb`:
+##### Class style
+
+`examples/class/internal-broadcastable.rb`:
 ```ruby
 module Node
   class LessThan
@@ -199,9 +303,99 @@ end
 
 ```
 
-Run `examples/internal-broadcastable.rb`:
+Run `examples/class/internal-broadcastable.rb`:
+```sh
+% ruby examples/class/internal-broadcastable.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]
+```
+
+##### Builder style
+
+`examples/builder/internal-broadcastable.rb`:
+```ruby
+def less_than(num)
+  # The following block call is equivalent to calling `super` in the class style.
+  proc { |input, &original| original.call(input) && input < num }
+end
+
+LessThan5 =
+  CallableTree::Node::Internal::Builder
+  .new
+  .matcher(&method(:less_than).call(5))
+  .build
+
+LessThan10 =
+  CallableTree::Node::Internal::Builder
+  .new
+  .matcher(&method(:less_than).call(10))
+  .build
+
+def add(num)
+  proc { |input| input + num }
+end
+
+Add1 =
+  CallableTree::Node::External::Builder
+  .new
+  .caller(&method(:add).call(1))
+  .build
+
+def subtract(num)
+  proc { |input| input - num }
+end
+
+Subtract1 =
+  CallableTree::Node::External::Builder
+  .new
+  .caller(&method(:subtract).call(1))
+  .build
+
+def multiply(num)
+  proc { |input| input * num }
+end
+
+Multiply2 =
+  CallableTree::Node::External::Builder
+  .new
+  .caller(&method(:multiply).call(2))
+  .build
+
+Multiply3 =
+  CallableTree::Node::External::Builder
+  .new
+  .caller(&method(:multiply).call(3))
+  .build
+
+tree = CallableTree::Node::Root.new.broadcastable.append(
+  LessThan5.new.broadcastable.append(
+    Multiply2.new,
+    Add1.new
+  ),
+  LessThan10.new.broadcastable.append(
+    Multiply3.new,
+    Subtract1.new
+  )
+)
+
+(0..10).each do |input|
+  output = tree.call(input)
+  puts "#{input} -> #{output}"
+end
+```
+
+Run `examples/builder/internal-broadcastable.rb`:
 ```sh
-% ruby examples/internal-broadcastable.rb
+% ruby examples/builder/internal-broadcastable.rb
 0 -> [[0, 1], [0, -1]]
 1 -> [[2, 2], [3, 0]]
 2 -> [[4, 3], [6, 1]]
@@ -217,9 +411,12 @@ Run `examples/internal-broadcastable.rb`:
 
 #### `CallableTree::Node::Internal#composable`
 
-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.
+This strategy composes the child nodes to input the output of the previous node into the next node and to output a result.
+It also ignores their `terminate?` methods by default.
+
+##### Class style
 
-`examples/internal-composable.rb`:
+`examples/class/internal-composable.rb`:
 ```ruby
 module Node
   class LessThan
@@ -253,9 +450,99 @@ end
 
 ```
 
-Run `examples/internal-composable.rb`:
+Run `examples/class/internal-composable.rb`:
+```sh
+% ruby examples/class/internal-composable.rb
+0 -> 2
+1 -> 8
+2 -> 14
+3 -> 20
+4 -> 26
+5 -> 14
+6 -> 17
+7 -> 20
+8 -> 23
+9 -> 26
+10 -> 10
+```
+
+##### Builder style
+
+`examples/builder/internal-composable.rb`:
+```ruby
+def less_than(num)
+  # The following block call is equivalent to calling `super` in the class style.
+  proc { |input, &original| original.call(input) && input < num }
+end
+
+LessThan5 =
+  CallableTree::Node::Internal::Builder
+  .new
+  .matcher(&method(:less_than).call(5))
+  .build
+
+LessThan10 =
+  CallableTree::Node::Internal::Builder
+  .new
+  .matcher(&method(:less_than).call(10))
+  .build
+
+def add(num)
+  proc { |input| input + num }
+end
+
+Add1 =
+  CallableTree::Node::External::Builder
+  .new
+  .caller(&method(:add).call(1))
+  .build
+
+def subtract(num)
+  proc { |input| input - num }
+end
+
+Subtract1 =
+  CallableTree::Node::External::Builder
+  .new
+  .caller(&method(:subtract).call(1))
+  .build
+
+def multiply(num)
+  proc { |input| input * num }
+end
+
+Multiply2 =
+  CallableTree::Node::External::Builder
+  .new
+  .caller(&method(:multiply).call(2))
+  .build
+
+Multiply3 =
+  CallableTree::Node::External::Builder
+  .new
+  .caller(&method(:multiply).call(3))
+  .build
+
+tree = CallableTree::Node::Root.new.composable.append(
+  LessThan5.new.composable.append(
+    Multiply2.new,
+    Add1.new
+  ),
+  LessThan10.new.composable.append(
+    Multiply3.new,
+    Subtract1.new
+  )
+)
+
+(0..10).each do |input|
+  output = tree.call(input)
+  puts "#{input} -> #{output}"
+end
+```
+
+Run `examples/builder/internal-composable.rb`:
 ```sh
-% ruby examples/internal-composable.rb
+% ruby examples/builder/internal-composable.rb
 0 -> 2
 1 -> 8
 2 -> 14
@@ -275,350 +562,247 @@ Run `examples/internal-composable.rb`:
 
 If you want verbose output results, call this method.
 
-`examples/external-verbosify.rb`:
+`examples/builder/external-verbosify.rb`:
 ```ruby
 ...
 
-tree = CallableTree::Node::Root.new.append(
-  Node::JSON::Parser.new.append(
-    Node::JSON::Scraper.new(type: :animals).verbosify,
-    Node::JSON::Scraper.new(type: :fruits).verbosify
+tree = CallableTree::Node::Root.new.seekable.append(
+  JSONParser.new.seekable.append(
+    AnimalsJSONScraper.new.verbosify,
+    FruitsJSONScraper.new.verbosify
   ),
-  Node::XML::Parser.new.append(
-    Node::XML::Scraper.new(type: :animals).verbosify,
-    Node::XML::Scraper.new(type: :fruits).verbosify
+  XMLParser.new.seekable.append(
+    AnimalsXMLScraper.new.verbosify,
+    FruitsXMLScraper.new.verbosify
   )
 )
 
 ...
 ```
 
-Run `examples/external-verbosify.rb`:
+Run `examples/builder/external-verbosify.rb`:
 ```sh
-% ruby examples/external-verbosify.rb
+% ruby examples/class/external-verbosify.rb
 #<struct CallableTree::Node::External::Output
- value={"Dog"=>"🐶", "Cat"=>"🐱"},
- options={:foo=>:bar},
- routes=[Node::JSON::Scraper, Node::JSON::Parser, CallableTree::Node::Root]>
+  value={"Dog"=>"🐶", "Cat"=>"🐱"},
+  options={:foo=>:bar},
+  routes=[AnimalsJSONScraper, JSONParser, CallableTree::Node::Root]>
 ---
 #<struct CallableTree::Node::External::Output
- value={"Dog"=>"🐶", "Cat"=>"🐱"},
- options={:foo=>:bar},
- routes=[Node::XML::Scraper, Node::XML::Parser, CallableTree::Node::Root]>
+  value={"Dog"=>"🐶", "Cat"=>"🐱"},
+  options={:foo=>:bar},
+  routes=[AnimalsXMLScraper, XMLParser, CallableTree::Node::Root]>
 ---
 #<struct CallableTree::Node::External::Output
- value={"Red Apple"=>"🍎", "Green Apple"=>"🍏"},
- options={:foo=>:bar},
- routes=[Node::JSON::Scraper, Node::JSON::Parser, CallableTree::Node::Root]>
+  value={"Red Apple"=>"🍎", "Green Apple"=>"🍏"},
+  options={:foo=>:bar},
+  routes=[FruitsJSONScraper, JSONParser, CallableTree::Node::Root]>
 ---
 #<struct CallableTree::Node::External::Output
- value={"Red Apple"=>"🍎", "Green Apple"=>"🍏"},
- options={:foo=>:bar},
- routes=[Node::XML::Scraper, Node::XML::Parser, CallableTree::Node::Root]>
+  value={"Red Apple"=>"🍎", "Green Apple"=>"🍏"},
+  options={:foo=>:bar},
+  routes=[FruitsXMLScraper, XMLParser, CallableTree::Node::Root]>
 ---
 ```
 
-At first glance, this looks good, but the `routes` are ambiguous when there are multiple nodes of the same class.
-You can work around it by overriding the `identity` method of the node.
-
-#### `CallableTree::Node#identity`
+#### Logging
 
-If you want to customize the node identity, override this method.
+This is an example of logging.
 
-`examples/identity.rb`:
+`examples/builder/logging.rb`:
 ```ruby
-module Node
-  class Identity
-    attr_reader :klass, :type
-
-    def initialize(klass:, type:)
-      @klass = klass
-      @type = type
-    end
+JSONParser =
+  CallableTree::Node::Internal::Builder
+  .new
+  ...
+  .hookable
+  .build
 
-    def to_s
-      "#{klass}(#{type})"
-    end
-  end
+XMLParser =
+  CallableTree::Node::Internal::Builder
+  .new
+  ...
+  .hookable
+  .build
 
-  module JSON
+def build_json_scraper(type)
+  CallableTree::Node::External::Builder
+    .new
     ...
+    .hookable
+    .build
+end
 
-    class Scraper
-      include CallableTree::Node::External
+...
 
-      def initialize(type:)
-        @type = type
-      end
+def build_xml_scraper(type)
+  CallableTree::Node::External::Builder
+    .new
+    ...
+    .hookable
+    .build
+end
 
-      def identity
-        Identity.new(klass: super, type: @type)
-      end
+...
 
-      ...
+module Logging
+  INDENT_SIZE = 2
+  BLANK = ' '
+  LIST_STYLE = '*'
+  INPUT_LABEL  = 'Input :'
+  OUTPUT_LABEL = 'Output:'
+
+  def self.loggable(node)
+    node.after_matcher! do |matched, _node_:, **|
+      prefix = LIST_STYLE.rjust((_node_.depth * INDENT_SIZE) - INDENT_SIZE + LIST_STYLE.length, BLANK)
+      puts "#{prefix} #{_node_.identity}: [matched: #{matched}]"
+      matched
     end
-  end
-
-  module XML
-     ...
-
-    class Scraper
-      include CallableTree::Node::External
-
-      def initialize(type:)
-        @type = type
-      end
-
-      def identity
-        Identity.new(klass: super, type: @type)
-      end
 
-      ...
+    if node.external?
+      node
+        .before_caller! do |input, *, _node_:, **|
+          input_prefix = INPUT_LABEL.rjust((_node_.depth * INDENT_SIZE) + INPUT_LABEL.length, BLANK)
+          puts "#{input_prefix} #{input}"
+          input
+        end
+        .after_caller! do |output, _node_:, **|
+          output_prefix = OUTPUT_LABEL.rjust((_node_.depth * INDENT_SIZE) + OUTPUT_LABEL.length, BLANK)
+          puts "#{output_prefix} #{output}"
+          output
+        end
     end
   end
 end
 
+loggable = Logging.method(:loggable)
+
+tree = CallableTree::Node::Root.new.seekable.append(
+  JSONParser.new.tap(&loggable).seekable.append(
+    AnimalsJSONScraper.new.tap(&loggable).verbosify,
+    FruitsJSONScraper.new.tap(&loggable).verbosify
+  ),
+  XMLParser.new.tap(&loggable).seekable.append(
+    AnimalsXMLScraper.new.tap(&loggable).verbosify,
+    FruitsXMLScraper.new.tap(&loggable).verbosify
+  )
+)
+
 ...
 ```
 
-Run `examples/identity.rb`:
+Also, see `examples/builder/hooks.rb` for detail about `CallableTree::Node::Hooks::*`.
+
+Run `examples/builder/logging.rb`:
 ```sh
-% ruby examples/identity.rb
+% ruby examples/builder/logging.rb
+* JSONParser: [matched: true]
+  * AnimalsJSONScraper: [matched: true]
+    Input : {"animals"=>[{"name"=>"Dog", "emoji"=>"🐶"}, {"name"=>"Cat", "emoji"=>"🐱"}]}
+    Output: {"Dog"=>"🐶", "Cat"=>"🐱"}
 #<struct CallableTree::Node::External::Output
  value={"Dog"=>"🐶", "Cat"=>"🐱"},
  options={:foo=>:bar},
- routes=
-  [#<Node::Identity:0x00007fb4378a9718
-    @klass=Node::JSON::Scraper,
-    @type=:animals>,
-   Node::JSON::Parser,
-   CallableTree::Node::Root]>
+ routes=[AnimalsJSONScraper, JSONParser, CallableTree::Node::Root]>
 ---
+* JSONParser: [matched: false]
+* XMLParser: [matched: true]
+  * AnimalsXMLScraper: [matched: true]
+    Input : <root><animals><animal emoji='🐶' name='Dog'/><animal emoji='🐱' name='Cat'/></animals></root>
+    Output: {"Dog"=>"🐶", "Cat"=>"🐱"}
 #<struct CallableTree::Node::External::Output
  value={"Dog"=>"🐶", "Cat"=>"🐱"},
  options={:foo=>:bar},
- routes=
-  [#<Node::Identity:0x00007fb41002b6d0
-    @klass=Node::XML::Scraper,
-    @type=:animals>,
-   Node::XML::Parser,
-   CallableTree::Node::Root]>
+ routes=[AnimalsXMLScraper, XMLParser, CallableTree::Node::Root]>
 ---
+* JSONParser: [matched: true]
+  * AnimalsJSONScraper: [matched: false]
+  * FruitsJSONScraper: [matched: true]
+    Input : {"fruits"=>[{"name"=>"Red Apple", "emoji"=>"🍎"}, {"name"=>"Green Apple", "emoji"=>"🍏"}]}
+    Output: {"Red Apple"=>"🍎", "Green Apple"=>"🍏"}
 #<struct CallableTree::Node::External::Output
  value={"Red Apple"=>"🍎", "Green Apple"=>"🍏"},
  options={:foo=>:bar},
- routes=
-  [#<Node::Identity:0x00007fb41001b3e8
-    @klass=Node::JSON::Scraper,
-    @type=:fruits>,
-   Node::JSON::Parser,
-   CallableTree::Node::Root]>
+ routes=[FruitsJSONScraper, JSONParser, CallableTree::Node::Root]>
 ---
+* JSONParser: [matched: false]
+* XMLParser: [matched: true]
+  * AnimalsXMLScraper: [matched: false]
+  * FruitsXMLScraper: [matched: true]
+    Input : <root><fruits><fruit emoji='🍎' name='Red Apple'/><fruit emoji='🍏' name='Green Apple'/></fruits></root>
+    Output: {"Red Apple"=>"🍎", "Green Apple"=>"🍏"}
 #<struct CallableTree::Node::External::Output
  value={"Red Apple"=>"🍎", "Green Apple"=>"🍏"},
  options={:foo=>:bar},
- routes=
-  [#<Node::Identity:0x00007fb410049d38
-    @klass=Node::XML::Scraper,
-    @type=:fruits>,
-   Node::XML::Parser,
-   CallableTree::Node::Root]>
----
+ routes=[FruitsXMLScraper, XMLParser, CallableTree::Node::Root]>
 ```
 
-#### Logging
+#### `CallableTree::Node#identity`
 
-This is an example of logging.
+If you want to customize the node identity, specify identifier.
 
-`examples/logging.rb`:
+`examples/builder/identity.rb`:
 ```ruby
-module Node
-  module Logging
-    INDENT_SIZE = 2
-    BLANK = ' '
-
-    module Match
-      LIST_STYLE = '*'
-
-      def match?(_input, **_options)
-        super.tap do |matched|
-          prefix = LIST_STYLE.rjust(depth * INDENT_SIZE - INDENT_SIZE + LIST_STYLE.length, BLANK)
-          puts "#{prefix} #{identity}: [matched: #{matched}]"
-        end
-      end
-    end
-
-    module Call
-      INPUT_LABEL  = 'Input :'
-      OUTPUT_LABEL = 'Output:'
-
-      def call(input, **_options)
-        super.tap do |output|
-          input_prefix = INPUT_LABEL.rjust(depth * INDENT_SIZE + INPUT_LABEL.length, BLANK)
-          puts "#{input_prefix} #{input}"
-          output_prefix = OUTPUT_LABEL.rjust(depth * INDENT_SIZE + OUTPUT_LABEL.length, BLANK)
-          puts "#{output_prefix} #{output}"
-        end
-      end
-    end
-  end
-
+JSONParser =
+  CallableTree::Node::Internal::Builder
+  .new
   ...
+  .identifier { |_node_:| _node_.object_id }
+  .build
 
-  module JSON
-    class Parser
-      include CallableTree::Node::Internal
-      prepend Logging::Match
-
-      ...
-    end
-
-    class Scraper
-      include CallableTree::Node::External
-      prepend Logging::Match
-      prepend Logging::Call
-
-      ...
-    end
-  end
-
-  module XML
-    class Parser
-      include CallableTree::Node::Internal
-      prepend Logging::Match
+XMLParser =
+  CallableTree::Node::Internal::Builder
+  .new
+  ...
+  .identifier { |_node_:| _node_.object_id }
+  .build
 
-      ...
-    end
+def build_json_scraper(type)
+  CallableTree::Node::External::Builder
+    .new
+    ...
+    .identifier { |_node_:| _node_.object_id }
+    .build
+end
 
-    class Scraper
-      include CallableTree::Node::External
-      prepend Logging::Match
-      prepend Logging::Call
+...
 
-      ...
-    end
-  end
+def build_xml_scraper(type)
+  CallableTree::Node::External::Builder
+    .new
+    ...
+    .identifier { |_node_:| _node_.object_id }
+    .build
 end
 
 ...
 ```
 
-Run `examples/logging.rb`:
+Run `examples/class/identity.rb`:
 ```sh
-% ruby examples/logging.rb
-* Node::JSON::Parser: [matched: true]
-  * Node::JSON::Scraper(animals): [matched: true]
-    Input : {"animals"=>[{"name"=>"Dog", "emoji"=>"🐶"}, {"name"=>"Cat", "emoji"=>"🐱"}]}
-    Output: {"Dog"=>"🐶", "Cat"=>"🐱"}
+ % ruby examples/builder/identity.rb
 #<struct CallableTree::Node::External::Output
- value={"Dog"=>"🐶", "Cat"=>"🐱"},
- options={:foo=>:bar},
- routes=
-  [#<Node::Identity:0x00007ffd840347b8
-    @klass=Node::JSON::Scraper,
-    @type=:animals>,
-   Node::JSON::Parser,
-   CallableTree::Node::Root]>
+  value={"Dog"=>"🐶", "Cat"=>"🐱"},
+  options={:foo=>:bar},
+  routes=[60, 80, CallableTree::Node::Root]>
 ---
-* Node::JSON::Parser: [matched: false]
-* Node::XML::Parser: [matched: true]
-  * Node::XML::Scraper(animals): [matched: true]
-    Input : <root><animals><animal emoji='🐶' name='Dog'/><animal emoji='🐱' name='Cat'/></animals></root>
-    Output: {"Dog"=>"🐶", "Cat"=>"🐱"}
 #<struct CallableTree::Node::External::Output
- value={"Dog"=>"🐶", "Cat"=>"🐱"},
- options={:foo=>:bar},
- routes=
-  [#<Node::Identity:0x00007ffd7403f1f0
-    @klass=Node::XML::Scraper,
-    @type=:animals>,
-   Node::XML::Parser,
-   CallableTree::Node::Root]>
+  value={"Dog"=>"🐶", "Cat"=>"🐱"},
+  options={:foo=>:bar},
+  routes=[220, 240, CallableTree::Node::Root]>
 ---
-* Node::JSON::Parser: [matched: true]
-  * Node::JSON::Scraper(animals): [matched: false]
-  * Node::JSON::Scraper(fruits): [matched: true]
-    Input : {"fruits"=>[{"name"=>"Red Apple", "emoji"=>"🍎"}, {"name"=>"Green Apple", "emoji"=>"🍏"}]}
-    Output: {"Red Apple"=>"🍎", "Green Apple"=>"🍏"}
 #<struct CallableTree::Node::External::Output
  value={"Red Apple"=>"🍎", "Green Apple"=>"🍏"},
  options={:foo=>:bar},
- routes=
-  [#<Node::Identity:0x00007ffd8512bdf0
-    @klass=Node::JSON::Scraper,
-    @type=:fruits>,
-   Node::JSON::Parser,
-   CallableTree::Node::Root]>
+ routes=[260, 80, CallableTree::Node::Root]>
 ---
-* Node::JSON::Parser: [matched: false]
-* Node::XML::Parser: [matched: true]
-  * Node::XML::Scraper(animals): [matched: false]
-  * Node::XML::Scraper(fruits): [matched: true]
-    Input : <root><fruits><fruit emoji='🍎' name='Red Apple'/><fruit emoji='🍏' name='Green Apple'/></fruits></root>
-    Output: {"Red Apple"=>"🍎", "Green Apple"=>"🍏"}
 #<struct CallableTree::Node::External::Output
  value={"Red Apple"=>"🍎", "Green Apple"=>"🍏"},
  options={:foo=>:bar},
- routes=
-  [#<Node::Identity:0x00007ffd8407a740
-    @klass=Node::XML::Scraper,
-    @type=:fruits>,
-   Node::XML::Parser,
-   CallableTree::Node::Root]>
+ routes=[400, 240, CallableTree::Node::Root]>
 ---
 ```
 
-#### `CallableTree::Node::Hooks::Caller` (experimental)
-
-`examples/hooks-call.rb`:
-```ruby
-module Node
-  class HooksSample
-    include CallableTree::Node::Internal
-    prepend CallableTree::Node::Hooks::Caller
-  end
-end
-
-Node::HooksSample.new
-  .before_caller do |input, **_options|
-    puts "before_caller input: #{input}";
-    input + 1
-  end
-  .append(
-    # anonymous external node
-    lambda do |input, **_options|
-      puts "external input: #{input}"
-      input * 2
-    end
-  )
-  .around_caller do |input, **_options, &block|
-    puts "around_caller input: #{input}"
-    output = block.call
-    puts "around_caller output: #{output}"
-    output * input
-  end
-  .after_caller do |output, **_options|
-    puts "after_caller output: #{output}"
-    output * 2
-  end
-  .tap do |tree|
-    options = { foo: :bar }
-    output = tree.call(1, **options)
-    puts "result: #{output}"
-  end
-```
-
-Run `examples/hooks-caller.rb`:
-```sh
-% ruby examples/hooks-caller.rb
-before_caller input: 1
-external input: 2
-around_caller input: 2
-around_caller output: 4
-after_caller output: 8
-result: 16
-```
-
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/jsmmr/ruby_callable_tree.