callable_tree 0.3.4 → 0.3.7

data/lib/callable_tree/node/builder.rb

@@ -14,7 +14,13 @@ module CallableTree
       end
 
       def terminater(&block)
-        @terminater = block
+        warn 'Use CallableTree::Node::Internal::Builder#terminator instead.'
+        @terminator = block
+        self
+      end
+
+      def terminator(&block)
+        @terminator = block
         self
       end
 
@@ -26,23 +32,26 @@ module CallableTree
       def build(node_type:)
         matcher = @matcher
         caller = @caller
-        terminater = @terminater
+        terminator = @terminator
         hookable = @hookable
 
         validate(
           matcher: matcher,
           caller: caller,
-          terminater: terminater
+          terminator: terminator
         )
 
         ::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|
-                matcher.call(*inputs, **options) do |*inputs, **options|
+                matcher.call(*inputs, **options, _node_: self) do |*inputs, **options|
                   super(*inputs, **options)
                 end
               end
@@ -50,15 +59,15 @@ module CallableTree
 
             if caller
               define_method(:call) do |*inputs, **options|
-                caller.call(*inputs, **options) do |*inputs, **options|
+                caller.call(*inputs, **options, _node_: self) do |*inputs, **options|
                   super(*inputs, **options)
                 end
               end
             end
 
-            if terminater
+            if terminator
               define_method(:terminate?) do |output, *inputs, **options|
-                terminater.call(output, *inputs, **options) do |output, *inputs, **options|
+                terminator.call(output, *inputs, **options, _node_: self) do |output, *inputs, **options|
                   super(output, *inputs, **options)
                 end
               end
@@ -68,7 +77,7 @@ module CallableTree
 
       private
 
-      def validate(matcher:, caller:, terminater:)
+      def validate(matcher:, caller:, terminator:)
         raise ::CallableTree::Error, 'Not implemented'
       end
     end

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

@@ -14,8 +14,8 @@ module CallableTree
 
         private
 
-        def validate(matcher:, caller:, terminater:)
-          raise Error 'caller is required' unless caller
+        def validate(matcher:, caller:, terminator:)
+          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
@@ -13,6 +12,7 @@ module CallableTree
 
         def call(*inputs, **options)
           output = super(*inputs, **options)
+          options.delete(:_node_)
           routes = self.routes
 
           Output.new(output, options, routes)

data/lib/callable_tree/node/external.rb

@@ -5,6 +5,13 @@ module CallableTree
     module External
       include Node
 
+      def self.included(mod)
+        if mod.include?(Internal)
+          raise ::CallableTree::Error,
+                "#{mod} cannot include #{self} together with #{Internal}"
+        end
+      end
+
       def self.proxify(callable)
         Proxy.new(callable)
       end
@@ -41,6 +48,14 @@ module CallableTree
         { identity => nil }
       end
 
+      def internal?
+        false
+      end
+
+      def external?
+        true
+      end
+
       private
 
       def initialize_copy(_node)

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/builder.rb

@@ -12,7 +12,7 @@ module CallableTree
 
         private
 
-        def validate(matcher:, caller:, terminater:)
+        def validate(matcher:, caller:, terminator:)
           # noop
         end
       end

data/lib/callable_tree/node/internal.rb

@@ -6,6 +6,13 @@ module CallableTree
       extend ::Forwardable
       include Node
 
+      def self.included(mod)
+        if mod.include?(External)
+          raise ::CallableTree::Error,
+                "#{mod} cannot include #{self} together with #{External}"
+        end
+      end
+
       def_delegators :child_nodes, :[], :at
 
       def children
@@ -35,7 +42,7 @@ module CallableTree
         if recursive
           child_nodes
             .lazy
-            .select { |node| node.is_a?(Internal) }
+            .select { |node| node.internal? }
             .map { |node| node.find(recursive: true, &block) }
             .reject(&:nil?)
             .first
@@ -51,7 +58,7 @@ module CallableTree
 
         if recursive
           child_nodes.each do |node|
-            node.reject!(recursive: true, &block) if node.is_a?(Internal)
+            node.reject!(recursive: true, &block) if node.internal?
           end
         end
 
@@ -66,7 +73,7 @@ module CallableTree
         reject!(&block) if block_given?
 
         reject! do |node|
-          node.is_a?(Internal) && node.shake!(&block).child_nodes.empty?
+          node.internal? && node.shake!(&block).child_nodes.empty?
         end
       end
 
@@ -98,6 +105,10 @@ module CallableTree
         end
       end
 
+      alias seekable? seek?
+      alias seekable seek
+      alias seekable! seek!
+
       def broadcast?
         strategy.is_a?(Strategy::Broadcast)
       end
@@ -118,6 +129,10 @@ module CallableTree
         end
       end
 
+      alias broadcastable? broadcast?
+      alias broadcastable broadcast
+      alias broadcastable! broadcast!
+
       def compose?
         strategy.is_a?(Strategy::Compose)
       end
@@ -138,12 +153,24 @@ module CallableTree
         end
       end
 
+      alias composable? compose?
+      alias composable compose
+      alias composable! compose!
+
       def outline(&block)
         key = block ? block.call(self) : identity
         value = child_nodes.reduce({}) { |memo, node| memo.merge!(node.outline(&block)) }
         { key => value }
       end
 
+      def internal?
+        true
+      end
+
+      def external?
+        false
+      end
+
       protected
 
       attr_writer :strategy

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/node.rb

@@ -46,6 +46,14 @@ module CallableTree
       !output.nil?
     end
 
+    def internal?
+      raise ::CallableTree::Error, 'Not implemented'
+    end
+
+    def external?
+      raise ::CallableTree::Error, 'Not implemented'
+    end
+
     protected
 
     attr_writer :parent

data/lib/callable_tree/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CallableTree
-  VERSION = '0.3.4'
+  VERSION = '0.3.7'
 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.4
+  version: 0.3.7
 platform: ruby
 authors:
 - jsmmr
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-03-13 00:00:00.000000000 Z
+date: 2022-04-09 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,20 +33,21 @@ files:
 - bin/console
 - bin/setup
 - callable_tree.gemspec
-- examples/builder/hooks-call.rb
-- examples/builder/internal-broadcast.rb
-- examples/builder/internal-compose.rb
-- examples/builder/internal-seek.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-broadcast.rb
-- examples/internal-compose.rb
-- examples/internal-seek.rb
+- examples/internal-broadcastable.rb
+- examples/internal-composable.rb
+- examples/internal-seekable.rb
 - examples/logging.rb
 - lib/callable_tree.rb
 - lib/callable_tree/node.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.4/CHANGELOG.md
+  changelog_uri: https://github.com/jsmmr/ruby_callable_tree/blob/v0.3.7/CHANGELOG.md
 post_install_message:
 rdoc_options: []
 require_paths:

data/examples/builder/internal-seek.rb

@@ -1,97 +0,0 @@
-# frozen_string_literal: true
-
-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
-      .terminater do
-        true
-      end
-      .build
-  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
-      .terminater do
-        true
-      end
-      .build
-  end
-end
-
-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
-  end
-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
-end
-
-tree = CallableTree::Node::Root.new.append(
-  JSONParser.build.new.append(
-    JSONScraper.build(:animals).new,
-    JSONScraper.build(:fruits).new
-  ),
-  XMLParser.build.new.append(
-    XMLScraper.build(:animals).new,
-    XMLScraper.build(:fruits).new
-  )
-)
-
-Dir.glob("#{__dir__}/../docs/*") do |file|
-  options = { foo: :bar }
-  pp tree.call(file, **options)
-  puts '---'
-end