callable_tree 0.3.5 → 0.3.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 83716fbdef2881db33e8f046f056a17d8a8866423951493902088bf1af53218f
-  data.tar.gz: 8906217b71482e1717798329d172640a50f7cc73613a2187beba0702bf8b8d74
+  metadata.gz: 2a83d353d4049c06aa0a0d5f18f56c5c6d0d909cd4a54f6bbcba7faf4e835c0f
+  data.tar.gz: ab803f4e8b613a0ceb5e4d3ca21d38e1a5cf2a238db61384c0ec85b437fd7d73
 SHA512:
-  metadata.gz: 5e5ece858eb3347c41ea5f573e37c972d1a127d9fa234cd2512b18ef9e882b33d0da900b46c8f8e539fcee36fccb6643d21bb0945169019e7734232907c412c1
-  data.tar.gz: ce58af4b926c9201f4133f02da848dcfff7962f9fa08588c1d4b4b61765b9c5ffaf03f2cfb4367da7d14a80bc1dcd55ea4b53de39d4075be25ef6e2abaf9ae7e
+  metadata.gz: 27dd59b36d4ebc99395df901a900d72510928f5f4a9603405b83f54d0566652fda2253bcda7bf6efee1ad0363919c5ec7bb63a1ec1e0efc488e656d6ff1bce3a
+  data.tar.gz: 3029f92901053688715cffce367d0e44f01402743413dfd38dc52c6c63221094fe2d3774cf2b1b98d66b84dd6837c8d6e6430c228ce3f196e60f9222286a3a56

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 ## [Unreleased]
 
+## [0.3.6] - 2022-03-29
+
+- (Experimental) Add `CallableTree::Node::Hooks::Matcher`.
+  Using this together with `CallableTree::Node::Hooks::Caller` helps to output logs. See `examples/builder/logging.rb` for details.
+
 ## [0.3.5] - 2022-03-20
 
 - Add `CallableTree::Node::Internal#seekable?` as an alias for `CallableTree::Node::Internal#seek?`.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    callable_tree (0.3.5)
+    callable_tree (0.3.6)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -568,20 +568,20 @@ Run `examples/logging.rb`:
 ---
 ```
 
-#### `CallableTree::Node::Hooks::Call` (experimental)
+#### `CallableTree::Node::Hooks::Caller` (experimental)
 
 `examples/hooks-call.rb`:
 ```ruby
 module Node
   class HooksSample
     include CallableTree::Node::Internal
-    prepend CallableTree::Node::Hooks::Call
+    prepend CallableTree::Node::Hooks::Caller
   end
 end
 
 Node::HooksSample.new
-  .before_call do |input, **_options|
-    puts "before_call input: #{input}";
+  .before_caller do |input, **_options|
+    puts "before_caller input: #{input}";
     input + 1
   end
   .append(
@@ -591,14 +591,14 @@ Node::HooksSample.new
       input * 2
     end
   )
-  .around_call do |input, **_options, &block|
-    puts "around_call input: #{input}"
+  .around_caller do |input, **_options, &block|
+    puts "around_caller input: #{input}"
     output = block.call
-    puts "around_call output: #{output}"
+    puts "around_caller output: #{output}"
     output * input
   end
-  .after_call do |output, **_options|
-    puts "after_call output: #{output}"
+  .after_caller do |output, **_options|
+    puts "after_caller output: #{output}"
     output * 2
   end
   .tap do |tree|
@@ -608,14 +608,14 @@ Node::HooksSample.new
   end
 ```
 
-Run `examples/hooks-call.rb`:
+Run `examples/hooks-caller.rb`:
 ```sh
-% ruby examples/hooks-call.rb
-before_call input: 1
+% ruby examples/hooks-caller.rb
+before_caller input: 1
 external input: 2
-around_call input: 2
-around_call output: 4
-after_call output: 8
+around_caller input: 2
+around_caller output: 4
+after_caller output: 8
 result: 16
 ```
 

data/examples/builder/{hooks-call.rb → hooks-caller.rb}

@@ -10,8 +10,8 @@ Root =
 
 Root
   .new
-  .before_call do |input, **_options|
-    puts "before_call input: #{input}"
+  .before_caller do |input, **_options|
+    puts "before_caller input: #{input}"
     input + 1
   end
   .append(
@@ -21,14 +21,14 @@ Root
       input * 2
     end
   )
-  .around_call do |input, **_options, &block|
-    puts "around_call input: #{input}"
+  .around_caller do |input, **_options, &block|
+    puts "around_caller input: #{input}"
     output = block.call
-    puts "around_call output: #{output}"
+    puts "around_caller output: #{output}"
     output * input
   end
-  .after_call do |output, **_options|
-    puts "after_call output: #{output}"
+  .after_caller do |output, **_options|
+    puts "after_caller output: #{output}"
     output * 2
   end
   .tap do |tree|

data/examples/builder/internal-seekable.rb

@@ -4,89 +4,85 @@ require 'callable_tree'
 require 'json'
 require 'rexml/document'
 
-module JSONParser
-  def self.build
-    CallableTree::Node::Internal::Builder
-      .new
-      .matcher do |input, **_options|
-        File.extname(input) == '.json'
-      end
-      .caller do |input, **options, &block|
-        File.open(input) do |file|
-          json = ::JSON.load(file)
-          # The following block call is equivalent to calling `super` in the class style.
-          block.call(json, **options)
-        end
-      end
-      .terminator do
-        true
-      end
-      .build
+JSONParser =
+  CallableTree::Node::Internal::Builder
+  .new
+  .matcher do |input, **_options|
+    File.extname(input) == '.json'
   end
-end
-
-module XMLParser
-  def self.build
-    CallableTree::Node::Internal::Builder
-      .new
-      .matcher do |input, **_options|
-        File.extname(input) == '.xml'
-      end
-      .caller do |input, **options, &block|
-        File.open(input) do |file|
-          # The following block call is equivalent to calling `super` in the class style.
-          block.call(REXML::Document.new(file), **options)
-        end
-      end
-      .terminator do
-        true
-      end
-      .build
+  .caller do |input, **options, &block|
+    File.open(input) do |file|
+      json = ::JSON.load(file)
+      # The following block call is equivalent to calling `super` in the class style.
+      block.call(json, **options)
+    end
   end
-end
+  .terminator do
+    true
+  end
+  .build
 
-module JSONScraper
-  def self.build(type)
-    CallableTree::Node::External::Builder
-      .new
-      .matcher do |input, **_options|
-        !!input[type.to_s]
-      end
-      .caller do |input, **_options|
-        input[type.to_s]
-          .map { |element| [element['name'], element['emoji']] }
-          .to_h
-      end
-      .build
+XMLParser =
+  CallableTree::Node::Internal::Builder
+  .new
+  .matcher do |input, **_options|
+    File.extname(input) == '.xml'
+  end
+  .caller do |input, **options, &block|
+    File.open(input) do |file|
+      # The following block call is equivalent to calling `super` in the class style.
+      block.call(REXML::Document.new(file), **options)
+    end
   end
+  .terminator do
+    true
+  end
+  .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]
+        .map { |element| [element['name'], element['emoji']] }
+        .to_h
+    end
+    .build
 end
 
-module XMLScraper
-  def self.build(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
-          .map { |element| [element['name'], element['emoji']] }
-          .to_h
-      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
+        .map { |element| [element['name'], element['emoji']] }
+        .to_h
+    end
+    .build
 end
 
+AnimalsXMLScraper = build_xml_scraper(:animals)
+FruitsXMLScraper = build_xml_scraper(:fruits)
+
 tree = CallableTree::Node::Root.new.seekable.append(
-  JSONParser.build.new.seekable.append(
-    JSONScraper.build(:animals).new,
-    JSONScraper.build(:fruits).new
+  JSONParser.new.seekable.append(
+    AnimalsJSONScraper.new,
+    FruitsJSONScraper.new
   ),
-  XMLParser.build.new.seekable.append(
-    XMLScraper.build(:animals).new,
-    XMLScraper.build(:fruits).new
+  XMLParser.new.seekable.append(
+    AnimalsXMLScraper.new,
+    FruitsXMLScraper.new
   )
 )
 

data/examples/builder/logging.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require 'callable_tree'
+require 'json'
+require 'rexml/document'
+
+JSONParser =
+  CallableTree::Node::Internal::Builder
+  .new
+  .matcher do |input, **_options|
+    File.extname(input) == '.json'
+  end
+  .caller do |input, **options, &block|
+    File.open(input) do |file|
+      json = ::JSON.load(file)
+      # The following block call is equivalent to calling `super` in the class style.
+      block.call(json, **options)
+    end
+  end
+  .terminator do
+    true
+  end
+  .hookable
+  .build
+
+XMLParser =
+  CallableTree::Node::Internal::Builder
+  .new
+  .matcher do |input, **_options|
+    File.extname(input) == '.xml'
+  end
+  .caller do |input, **options, &block|
+    File.open(input) do |file|
+      # The following block call is equivalent to calling `super` in the class style.
+      block.call(REXML::Document.new(file), **options)
+    end
+  end
+  .terminator do
+    true
+  end
+  .hookable
+  .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]
+        .map { |element| [element['name'], element['emoji']] }
+        .to_h
+    end
+    .hookable
+    .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
+        .map { |element| [element['name'], element['emoji']] }
+        .to_h
+    end
+    .hookable
+    .build
+end
+
+AnimalsXMLScraper = build_xml_scraper(:animals)
+FruitsXMLScraper = build_xml_scraper(:fruits)
+
+loggable = proc do |node|
+  indent_size = 2
+  blank = ' '
+  list_style = '*'
+
+  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
+
+  if node.is_a?(CallableTree::Node::External)
+    input_label  = 'Input :'
+    output_label = 'Output:'
+
+    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
+
+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
+  )
+)
+
+Dir.glob("#{__dir__}/../docs/*") do |file|
+  options = { foo: :bar }
+  pp tree.call(file, **options)
+  puts '---'
+end

data/examples/{hooks-call.rb → hooks-caller.rb}

@@ -5,14 +5,14 @@ require 'callable_tree'
 module Node
   class HooksSample
     include CallableTree::Node::Internal
-    prepend CallableTree::Node::Hooks::Call
+    prepend CallableTree::Node::Hooks::Caller
   end
 end
 
 Node::HooksSample
   .new
-  .before_call do |input, **_options|
-    puts "before_call input: #{input}"
+  .before_caller do |input, **_options|
+    puts "before_caller input: #{input}"
     input + 1
   end
   .append(
@@ -22,14 +22,14 @@ Node::HooksSample
       input * 2
     end
   )
-  .around_call do |input, **_options, &block|
-    puts "around_call input: #{input}"
+  .around_caller do |input, **_options, &block|
+    puts "around_caller input: #{input}"
     output = block.call
-    puts "around_call output: #{output}"
+    puts "around_caller output: #{output}"
     output * input
   end
-  .after_call do |output, **_options|
-    puts "after_call output: #{output}"
+  .after_caller do |output, **_options|
+    puts "after_caller output: #{output}"
     output * 2
   end
   .tap do |tree|

data/lib/callable_tree/node/builder.rb

@@ -44,7 +44,10 @@ module CallableTree
         ::Class
           .new do
             include node_type
-            prepend Hooks::Call if hookable
+            if hookable
+              prepend Hooks::Matcher
+              prepend Hooks::Caller
+            end
 
             if matcher
               define_method(:match?) do |*inputs, **options|

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

@@ -15,7 +15,7 @@ module CallableTree
         private
 
         def validate(matcher:, caller:, terminator:)
-          raise Error 'caller is required' unless caller
+          raise Error, 'caller is required' unless caller
         end
       end
     end

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

@@ -3,7 +3,6 @@
 module CallableTree
   module Node
     module External
-      # TODO: Add :inputs
       Output = Struct.new(:value, :options, :routes)
 
       module Verbose

data/lib/callable_tree/node/hooks/caller.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module CallableTree
+  module Node
+    module Hooks
+      module Caller
+        def self.included(_subclass)
+          raise ::CallableTree::Error, "#{self} must be prepended"
+        end
+
+        def before_call(&block)
+          clone.before_call!(&block)
+        end
+
+        def before_call!(&block)
+          before_caller_callbacks << block
+          self
+        end
+
+        def around_call(&block)
+          clone.around_call!(&block)
+        end
+
+        def around_call!(&block)
+          around_caller_callbacks << block
+          self
+        end
+
+        def after_call(&block)
+          clone.after_call!(&block)
+        end
+
+        def after_call!(&block)
+          after_caller_callbacks << block
+          self
+        end
+
+        alias before_caller before_call
+        alias before_caller! before_call!
+        alias around_caller around_call
+        alias around_caller! around_call!
+        alias after_caller after_call
+        alias after_caller! after_call!
+
+        def call(*inputs, **options)
+          input_head, *input_tail = inputs
+
+          input_head = before_caller_callbacks.reduce(input_head) do |input_head, callable|
+            callable.call(input_head, *input_tail, **options, _node_: self)
+          end
+
+          output =
+            if around_caller_callbacks.empty?
+              super(input_head, *input_tail, **options)
+            else
+              around_caller_callbacks_head, *around_caller_callbacks_tail = around_caller_callbacks
+              caller = proc { super(input_head, *input_tail, **options) }
+
+              output =
+                around_caller_callbacks_head
+                .call(
+                  input_head,
+                  *input_tail,
+                  **options,
+                  _node_: self
+                ) { caller.call }
+
+              around_caller_callbacks_tail.reduce(output) do |output, callable|
+                callable.call(
+                  input_head,
+                  *input_tail,
+                  **options,
+                  _node_: self
+                ) { output }
+              end
+            end
+
+          after_caller_callbacks.reduce(output) do |output, callable|
+            callable.call(output, **options, _node_: self)
+          end
+        end
+
+        def before_caller_callbacks
+          @before_caller_callbacks ||= []
+        end
+
+        def around_caller_callbacks
+          @around_caller_callbacks ||= []
+        end
+
+        def after_caller_callbacks
+          @after_caller_callbacks ||= []
+        end
+
+        private
+
+        attr_writer :before_caller_callbacks, :around_caller_callbacks, :after_caller_callbacks
+
+        def initialize_copy(_node)
+          super
+          self.before_caller_callbacks = before_caller_callbacks.map(&:itself)
+          self.around_caller_callbacks = around_caller_callbacks.map(&:itself)
+          self.after_caller_callbacks = after_caller_callbacks.map(&:itself)
+        end
+      end
+
+      Call = Caller # backward compatibility
+    end
+  end
+end

data/lib/callable_tree/node/hooks/matcher.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module CallableTree
+  module Node
+    module Hooks
+      module Matcher
+        def self.included(_subclass)
+          raise ::CallableTree::Error, "#{self} must be prepended"
+        end
+
+        def before_matcher(&block)
+          clone.before_matcher!(&block)
+        end
+
+        def before_matcher!(&block)
+          before_matcher_callbacks << block
+          self
+        end
+
+        def around_matcher(&block)
+          clone.around_matcher!(&block)
+        end
+
+        def around_matcher!(&block)
+          around_matcher_callbacks << block
+          self
+        end
+
+        def after_matcher(&block)
+          clone.after_matcher!(&block)
+        end
+
+        def after_matcher!(&block)
+          after_matcher_callbacks << block
+          self
+        end
+
+        def match?(*inputs, **options)
+          input_head, *input_tail = inputs
+
+          input_head = before_matcher_callbacks.reduce(input_head) do |input_head, callable|
+            callable.call(input_head, *input_tail, **options, _node_: self)
+          end
+
+          matched =
+            if around_matcher_callbacks.empty?
+              super(input_head, *input_tail, **options)
+            else
+              around_matcher_callbacks_head, *around_matcher_callbacks_tail = around_matcher_callbacks
+              matcher = proc { super(input_head, *input_tail, **options) }
+
+              matched =
+                around_matcher_callbacks_head
+                .call(
+                  input_head,
+                  *input_tail,
+                  **options,
+                  _node_: self
+                ) { matcher.call }
+
+              around_matcher_callbacks_tail.reduce(matched) do |matched, callable|
+                callable.call(
+                  input_head,
+                  *input_tail,
+                  **options,
+                  _node_: self
+                ) { matched }
+              end
+            end
+
+          after_matcher_callbacks.reduce(matched) do |matched, callable|
+            callable.call(matched, **options, _node_: self)
+          end
+        end
+
+        def before_matcher_callbacks
+          @before_matcher_callbacks ||= []
+        end
+
+        def around_matcher_callbacks
+          @around_matcher_callbacks ||= []
+        end
+
+        def after_matcher_callbacks
+          @after_matcher_callbacks ||= []
+        end
+
+        private
+
+        attr_writer :before_matcher_callbacks, :around_matcher_callbacks, :after_matcher_callbacks
+
+        def initialize_copy(_node)
+          super
+          self.before_matcher_callbacks = before_matcher_callbacks.map(&:itself)
+          self.around_matcher_callbacks = around_matcher_callbacks.map(&:itself)
+          self.after_matcher_callbacks = after_matcher_callbacks.map(&:itself)
+        end
+      end
+    end
+  end
+end

data/lib/callable_tree/node/internal.rb

@@ -98,9 +98,9 @@ module CallableTree
         end
       end
 
-      alias_method :seekable?, :seek?
-      alias_method :seekable, :seek
-      alias_method :seekable!, :seek!
+      alias seekable? seek?
+      alias seekable seek
+      alias seekable! seek!
 
       def broadcast?
         strategy.is_a?(Strategy::Broadcast)
@@ -122,9 +122,9 @@ module CallableTree
         end
       end
 
-      alias_method :broadcastable?, :broadcast?
-      alias_method :broadcastable, :broadcast
-      alias_method :broadcastable!, :broadcast!
+      alias broadcastable? broadcast?
+      alias broadcastable broadcast
+      alias broadcastable! broadcast!
 
       def compose?
         strategy.is_a?(Strategy::Compose)
@@ -146,9 +146,9 @@ module CallableTree
         end
       end
 
-      alias_method :composable?, :compose?
-      alias_method :composable, :compose
-      alias_method :composable!, :compose!
+      alias composable? compose?
+      alias composable compose
+      alias composable! compose!
 
       def outline(&block)
         key = block ? block.call(self) : identity

data/lib/callable_tree/node/root.rb

@@ -4,7 +4,8 @@ module CallableTree
   module Node
     class Root
       include Internal
-      prepend Hooks::Call
+      prepend Hooks::Matcher
+      prepend Hooks::Caller
 
       def self.inherited(subclass)
         raise ::CallableTree::Error, "#{subclass} cannot inherit #{self}"

data/lib/callable_tree/version.rb

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

data/lib/callable_tree.rb

@@ -7,7 +7,8 @@ end
 require 'forwardable'
 require_relative 'callable_tree/version'
 require_relative 'callable_tree/node'
-require_relative 'callable_tree/node/hooks/call'
+require_relative 'callable_tree/node/hooks/matcher'
+require_relative 'callable_tree/node/hooks/caller'
 require_relative 'callable_tree/node/internal/strategy'
 require_relative 'callable_tree/node/internal/strategy/broadcast'
 require_relative 'callable_tree/node/internal/strategy/seek'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: callable_tree
 version: !ruby/object:Gem::Version
-  version: 0.3.5
+  version: 0.3.6
 platform: ruby
 authors:
 - jsmmr
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-03-20 00:00:00.000000000 Z
+date: 2022-03-29 00:00:00.000000000 Z
 dependencies: []
 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
@@ -33,16 +33,17 @@ files:
 - bin/console
 - bin/setup
 - callable_tree.gemspec
-- examples/builder/hooks-call.rb
+- examples/builder/hooks-caller.rb
 - examples/builder/internal-broadcastable.rb
 - examples/builder/internal-composable.rb
 - examples/builder/internal-seekable.rb
+- examples/builder/logging.rb
 - examples/docs/animals.json
 - examples/docs/animals.xml
 - examples/docs/fruits.json
 - examples/docs/fruits.xml
 - examples/external-verbosify.rb
-- examples/hooks-call.rb
+- examples/hooks-caller.rb
 - examples/identity.rb
 - examples/internal-broadcastable.rb
 - examples/internal-composable.rb
@@ -54,7 +55,8 @@ files:
 - lib/callable_tree/node/external.rb
 - lib/callable_tree/node/external/builder.rb
 - lib/callable_tree/node/external/verbose.rb
-- lib/callable_tree/node/hooks/call.rb
+- lib/callable_tree/node/hooks/caller.rb
+- lib/callable_tree/node/hooks/matcher.rb
 - lib/callable_tree/node/internal.rb
 - lib/callable_tree/node/internal/builder.rb
 - lib/callable_tree/node/internal/strategy.rb
@@ -69,7 +71,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.3.5/CHANGELOG.md
+  changelog_uri: https://github.com/jsmmr/ruby_callable_tree/blob/v0.3.6/CHANGELOG.md
 post_install_message:
 rdoc_options: []
 require_paths:

data/lib/callable_tree/node/hooks/call.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-module CallableTree
-  module Node
-    module Hooks
-      module Call
-        def self.included(_subclass)
-          raise ::CallableTree::Error, "#{self} must be prepended"
-        end
-
-        def before_call(&block)
-          clone.before_call!(&block)
-        end
-
-        def before_call!(&block)
-          before_callbacks << block
-          self
-        end
-
-        def around_call(&block)
-          clone.around_call!(&block)
-        end
-
-        def around_call!(&block)
-          around_callbacks << block
-          self
-        end
-
-        def after_call(&block)
-          clone.after_call!(&block)
-        end
-
-        def after_call!(&block)
-          after_callbacks << block
-          self
-        end
-
-        def call(*inputs, **options)
-          input_head, *input_tail = inputs
-
-          input_head = before_callbacks.reduce(input_head) do |input_head, callable|
-            callable.call(input_head, *input_tail, self, **options)
-          end
-
-          output = super(input_head, *input_tail, **options)
-
-          output = around_callbacks.reduce(output) do |output, callable|
-            callable.call(input_head, *input_tail, self, **options) { output }
-          end
-
-          after_callbacks.reduce(output) do |output, callable|
-            callable.call(output, self, **options)
-          end
-        end
-
-        def before_callbacks
-          @before_callbacks ||= []
-        end
-
-        def around_callbacks
-          @around_callbacks ||= []
-        end
-
-        def after_callbacks
-          @after_callbacks ||= []
-        end
-
-        private
-
-        attr_writer :before_callbacks, :around_callbacks, :after_callbacks
-
-        def initialize_copy(_node)
-          super
-          self.before_callbacks = before_callbacks.map(&:itself)
-          self.around_callbacks = around_callbacks.map(&:itself)
-          self.after_callbacks = after_callbacks.map(&:itself)
-        end
-      end
-    end
-  end
-end