callable_tree 0.3.5 → 0.3.8

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/hooks/terminator.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module CallableTree
+  module Node
+    module Hooks
+      module Terminator
+        def self.included(_subclass)
+          raise ::CallableTree::Error, "#{self} must be prepended"
+        end
+
+        def before_terminator(&block)
+          clone.before_terminator!(&block)
+        end
+
+        def before_terminator!(&block)
+          before_terminator_callbacks << block
+          self
+        end
+
+        def around_terminator(&block)
+          clone.around_terminator!(&block)
+        end
+
+        def around_terminator!(&block)
+          around_terminator_callbacks << block
+          self
+        end
+
+        def after_terminator(&block)
+          clone.after_terminator!(&block)
+        end
+
+        def after_terminator!(&block)
+          after_terminator_callbacks << block
+          self
+        end
+
+        def terminate?(output, *inputs, **options)
+          output = before_terminator_callbacks.reduce(output) do |output, callable|
+            callable.call(output, *inputs, **options, _node_: self)
+          end
+
+          terminated =
+            if around_terminator_callbacks.empty?
+              super(output, *inputs, **options)
+            else
+              around_terminator_callbacks_head, *around_terminator_callbacks_tail = around_terminator_callbacks
+              terminator = proc { super(output, *inputs, **options) }
+
+              terminated =
+                around_terminator_callbacks_head
+                .call(
+                  output,
+                  *inputs,
+                  **options,
+                  _node_: self
+                ) { terminator.call }
+
+              around_terminator_callbacks_tail.reduce(terminated) do |terminated, callable|
+                callable.call(
+                  output,
+                  *inputs,
+                  **options,
+                  _node_: self
+                ) { terminated }
+              end
+            end
+
+          after_terminator_callbacks.reduce(terminated) do |terminated, callable|
+            callable.call(terminated, **options, _node_: self)
+          end
+        end
+
+        def before_terminator_callbacks
+          @before_terminator_callbacks ||= []
+        end
+
+        def around_terminator_callbacks
+          @around_terminator_callbacks ||= []
+        end
+
+        def after_terminator_callbacks
+          @after_terminator_callbacks ||= []
+        end
+
+        private
+
+        attr_writer :before_terminator_callbacks, :around_terminator_callbacks, :after_terminator_callbacks
+
+        def initialize_copy(_node)
+          super
+          self.before_terminator_callbacks = before_terminator_callbacks.map(&:itself)
+          self.around_terminator_callbacks = around_terminator_callbacks.map(&:itself)
+          self.after_terminator_callbacks = after_terminator_callbacks.map(&:itself)
+        end
+      end
+    end
+  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,9 +105,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 +129,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 +153,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
@@ -156,6 +163,14 @@ module CallableTree
         { 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,9 @@ module CallableTree
   module Node
     class Root
       include Internal
-      prepend Hooks::Call
+      prepend Hooks::Matcher
+      prepend Hooks::Caller
+      prepend Hooks::Terminator
 
       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.5'
+  VERSION = '0.3.8'
 end

data/lib/callable_tree.rb

@@ -7,7 +7,9 @@ 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/hooks/terminator'
 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.8
 platform: ruby
 authors:
 - jsmmr
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-03-20 00:00:00.000000000 Z
+date: 2022-05-05 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
@@ -23,6 +23,7 @@ files:
 - ".github/workflows/codeql-analysis.yml"
 - ".gitignore"
 - ".rspec"
+- ".rubocop.yml"
 - ".ruby-version"
 - CHANGELOG.md
 - Gemfile
@@ -33,28 +34,31 @@ files:
 - bin/console
 - bin/setup
 - callable_tree.gemspec
-- examples/builder/hooks-call.rb
+- examples/builder/hooks.rb
 - examples/builder/internal-broadcastable.rb
 - examples/builder/internal-composable.rb
 - examples/builder/internal-seekable.rb
+- examples/builder/logging.rb
+- examples/class/external-verbosify.rb
+- examples/class/hooks.rb
+- examples/class/identity.rb
+- examples/class/internal-broadcastable.rb
+- examples/class/internal-composable.rb
+- examples/class/internal-seekable.rb
+- examples/class/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/identity.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
 - lib/callable_tree/node/builder.rb
 - 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/hooks/terminator.rb
 - lib/callable_tree/node/internal.rb
 - lib/callable_tree/node/internal/builder.rb
 - lib/callable_tree/node/internal/strategy.rb
@@ -69,7 +73,8 @@ 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.8/CHANGELOG.md
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths:

data/examples/builder/hooks-call.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-require 'callable_tree'
-
-Root =
-  CallableTree::Node::Internal::Builder
-  .new
-  .hookable
-  .build
-
-Root
-  .new
-  .before_call do |input, **_options|
-    puts "before_call input: #{input}"
-    input + 1
-  end
-  .append(
-    # anonymous external node
-    lambda do |input, **_options|
-      puts "external input: #{input}"
-      input * 2
-    end
-  )
-  .around_call do |input, **_options, &block|
-    puts "around_call input: #{input}"
-    output = block.call
-    puts "around_call output: #{output}"
-    output * input
-  end
-  .after_call do |output, **_options|
-    puts "after_call output: #{output}"
-    output * 2
-  end
-  .tap do |tree|
-    options = { foo: :bar }
-    output = tree.call(1, **options)
-    puts "result: #{output}"
-  end

data/examples/hooks-call.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-require 'callable_tree'
-
-module Node
-  class HooksSample
-    include CallableTree::Node::Internal
-    prepend CallableTree::Node::Hooks::Call
-  end
-end
-
-Node::HooksSample
-  .new
-  .before_call do |input, **_options|
-    puts "before_call input: #{input}"
-    input + 1
-  end
-  .append(
-    # anonymous external node
-    lambda do |input, **_options|
-      puts "external input: #{input}"
-      input * 2
-    end
-  )
-  .around_call do |input, **_options, &block|
-    puts "around_call input: #{input}"
-    output = block.call
-    puts "around_call output: #{output}"
-    output * input
-  end
-  .after_call do |output, **_options|
-    puts "after_call output: #{output}"
-    output * 2
-  end
-  .tap do |tree|
-    options = { foo: :bar }
-    output = tree.call(1, **options)
-    puts "result: #{output}"
-  end