callable_tree 0.3.10 → 0.3.12

data/examples/factory/identity.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require_relative '../../lib/callable_tree'
+# require 'callable_tree'
+require 'json'
+require 'rexml/document'
+
+# Identity example using Factory style with pre-defined procs
+# Custom identity for each node - _node_: is used here
+
+# === Behavior Definitions ===
+
+json_matcher = ->(input, **) { File.extname(input) == '.json' }
+json_caller = lambda do |input, **options, &block|
+  File.open(input) do |file|
+    json = JSON.parse(file.read)
+    block.call(json, **options)
+  end
+end
+json_identifier = ->(_node_:) { _node_.object_id }
+
+xml_matcher = ->(input, **) { File.extname(input) == '.xml' }
+xml_caller = lambda do |input, **options, &block|
+  File.open(input) do |file|
+    block.call(REXML::Document.new(file), **options)
+  end
+end
+xml_identifier = ->(_node_:) { _node_.object_id }
+
+animals_json_matcher = ->(input, **) { !input['animals'].nil? }
+animals_json_caller = ->(input, **) { input['animals'].to_h { |e| [e['name'], e['emoji']] } }
+animals_json_identifier = ->(_node_:) { _node_.object_id }
+
+fruits_json_matcher = ->(input, **) { !input['fruits'].nil? }
+fruits_json_caller = ->(input, **) { input['fruits'].to_h { |e| [e['name'], e['emoji']] } }
+fruits_json_identifier = ->(_node_:) { _node_.object_id }
+
+animals_xml_matcher = ->(input, **) { !input.get_elements('//animals').empty? }
+animals_xml_caller = ->(input, **) { input.get_elements('//animals').first.to_h { |e| [e['name'], e['emoji']] } }
+animals_xml_identifier = ->(_node_:) { _node_.object_id }
+
+fruits_xml_matcher = ->(input, **) { !input.get_elements('//fruits').empty? }
+fruits_xml_caller = ->(input, **) { input.get_elements('//fruits').first.to_h { |e| [e['name'], e['emoji']] } }
+fruits_xml_identifier = ->(_node_:) { _node_.object_id }
+
+terminator_true = ->(*) { true }
+
+# === Tree Structure ===
+
+tree = CallableTree::Node::Root.new.seekable.append(
+  CallableTree::Node::Internal.create(
+    matcher: json_matcher,
+    caller: json_caller,
+    terminator: terminator_true,
+    identifier: json_identifier
+  ).seekable.append(
+    CallableTree::Node::External.create(
+      matcher: animals_json_matcher,
+      caller: animals_json_caller,
+      identifier: animals_json_identifier
+    ).verbosify,
+    CallableTree::Node::External.create(
+      matcher: fruits_json_matcher,
+      caller: fruits_json_caller,
+      identifier: fruits_json_identifier
+    ).verbosify
+  ),
+  CallableTree::Node::Internal.create(
+    matcher: xml_matcher,
+    caller: xml_caller,
+    terminator: terminator_true,
+    identifier: xml_identifier
+  ).seekable.append(
+    CallableTree::Node::External.create(
+      matcher: animals_xml_matcher,
+      caller: animals_xml_caller,
+      identifier: animals_xml_identifier
+    ).verbosify,
+    CallableTree::Node::External.create(
+      matcher: fruits_xml_matcher,
+      caller: fruits_xml_caller,
+      identifier: fruits_xml_identifier
+    ).verbosify
+  )
+)
+
+# === Execution ===
+
+Dir.glob("#{__dir__}/../docs/*") do |file|
+  options = { foo: :bar }
+  pp tree.call(file, **options)
+  puts '---'
+end

data/examples/factory/internal-broadcastable.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative '../../lib/callable_tree'
+# require 'callable_tree'
+
+# Broadcastable example using Factory style with pre-defined procs
+# All matching child nodes are called and results are collected
+
+# === Behavior Definitions ===
+
+less_than_5_matcher = ->(input, **, &original) { original.call(input) && input < 5 }
+less_than_10_matcher = ->(input, **, &original) { original.call(input) && input < 10 }
+
+multiply_2_caller = ->(input, **) { input * 2 }
+add_1_caller = ->(input, **) { input + 1 }
+multiply_3_caller = ->(input, **) { input * 3 }
+subtract_1_caller = ->(input, **) { input - 1 }
+
+# === Tree Structure ===
+
+tree = CallableTree::Node::Root.new.broadcastable.append(
+  CallableTree::Node::Internal.create(matcher: less_than_5_matcher).broadcastable.append(
+    CallableTree::Node::External.create(caller: multiply_2_caller),
+    CallableTree::Node::External.create(caller: add_1_caller)
+  ),
+  CallableTree::Node::Internal.create(matcher: less_than_10_matcher).broadcastable.append(
+    CallableTree::Node::External.create(caller: multiply_3_caller),
+    CallableTree::Node::External.create(caller: subtract_1_caller)
+  )
+)
+
+# === Execution ===
+
+(0..10).each do |input|
+  output = tree.call(input)
+  puts "#{input} -> #{output}"
+end

data/examples/factory/internal-composable.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative '../../lib/callable_tree'
+# require 'callable_tree'
+
+# Composable example using Factory style with pre-defined procs
+# Output of one node becomes input to the next (pipeline)
+
+# === Behavior Definitions ===
+
+less_than_5_matcher = ->(input, **, &original) { original.call(input) && input < 5 }
+less_than_10_matcher = ->(input, **, &original) { original.call(input) && input < 10 }
+
+multiply_2_caller = ->(input, **) { input * 2 }
+add_1_caller = ->(input, **) { input + 1 }
+multiply_3_caller = ->(input, **) { input * 3 }
+subtract_1_caller = ->(input, **) { input - 1 }
+
+# === Tree Structure ===
+
+tree = CallableTree::Node::Root.new.composable.append(
+  CallableTree::Node::Internal.create(matcher: less_than_5_matcher).composable.append(
+    CallableTree::Node::External.create(caller: multiply_2_caller),
+    CallableTree::Node::External.create(caller: add_1_caller)
+  ),
+  CallableTree::Node::Internal.create(matcher: less_than_10_matcher).composable.append(
+    CallableTree::Node::External.create(caller: multiply_3_caller),
+    CallableTree::Node::External.create(caller: subtract_1_caller)
+  )
+)
+
+# === Execution ===
+
+(0..10).each do |input|
+  output = tree.call(input)
+  puts "#{input} -> #{output}"
+end

data/examples/factory/internal-seekable.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative '../../lib/callable_tree'
+# require 'callable_tree'
+require 'json'
+require 'rexml/document'
+
+# Seekable example using Factory style with pre-defined procs
+# This demonstrates the key difference from Builder style:
+# - Behaviors are defined as procs first
+# - Tree structure is assembled separately, making it clearly visible
+
+# === Behavior Definitions ===
+
+json_matcher = ->(input, **) { File.extname(input) == '.json' }
+json_caller = lambda do |input, **options, &original|
+  File.open(input) do |file|
+    json = JSON.parse(file.read)
+    original.call(json, **options)
+  end
+end
+
+xml_matcher = ->(input, **) { File.extname(input) == '.xml' }
+xml_caller = lambda do |input, **options, &original|
+  File.open(input) do |file|
+    original.call(REXML::Document.new(file), **options)
+  end
+end
+
+animals_json_matcher = ->(input, **) { !input['animals'].nil? }
+animals_json_caller = ->(input, **) { input['animals'].to_h { |e| [e['name'], e['emoji']] } }
+
+fruits_json_matcher = ->(input, **) { !input['fruits'].nil? }
+fruits_json_caller = ->(input, **) { input['fruits'].to_h { |e| [e['name'], e['emoji']] } }
+
+animals_xml_matcher = ->(input, **) { !input.get_elements('//animals').empty? }
+animals_xml_caller = ->(input, **) { input.get_elements('//animals').first.to_h { |e| [e['name'], e['emoji']] } }
+
+fruits_xml_matcher = ->(input, **) { !input.get_elements('//fruits').empty? }
+fruits_xml_caller = ->(input, **) { input.get_elements('//fruits').first.to_h { |e| [e['name'], e['emoji']] } }
+
+terminator_true = ->(*) { true }
+
+# === Tree Structure (clearly visible!) ===
+
+tree = CallableTree::Node::Root.new.seekable.append(
+  CallableTree::Node::Internal.create(
+    matcher: json_matcher,
+    caller: json_caller,
+    terminator: terminator_true
+  ).seekable.append(
+    CallableTree::Node::External.create(matcher: animals_json_matcher, caller: animals_json_caller),
+    CallableTree::Node::External.create(matcher: fruits_json_matcher, caller: fruits_json_caller)
+  ),
+  CallableTree::Node::Internal.create(
+    matcher: xml_matcher,
+    caller: xml_caller,
+    terminator: terminator_true
+  ).seekable.append(
+    CallableTree::Node::External.create(matcher: animals_xml_matcher, caller: animals_xml_caller),
+    CallableTree::Node::External.create(matcher: fruits_xml_matcher, caller: fruits_xml_caller)
+  )
+)
+
+# === Execution ===
+
+Dir.glob("#{__dir__}/../docs/*") do |file|
+  options = { foo: :bar }
+  pp tree.call(file, **options)
+  puts '---'
+end

data/examples/factory/logging.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require_relative '../../lib/callable_tree'
+# require 'callable_tree'
+require 'json'
+require 'rexml/document'
+
+# Logging example using Factory style with pre-defined procs
+# Uses hooks to add logging to the tree - _node_: is used in hooks
+
+# === Behavior Definitions ===
+
+json_matcher = ->(input, **) { File.extname(input) == '.json' }
+json_caller = lambda do |input, **options, &original|
+  File.open(input) do |file|
+    json = JSON.parse(file.read)
+    original.call(json, **options)
+  end
+end
+
+xml_matcher = ->(input, **) { File.extname(input) == '.xml' }
+xml_caller = lambda do |input, **options, &original|
+  File.open(input) do |file|
+    original.call(REXML::Document.new(file), **options)
+  end
+end
+
+animals_json_matcher = ->(input, **) { !input['animals'].nil? }
+animals_json_caller = ->(input, **) { input['animals'].to_h { |e| [e['name'], e['emoji']] } }
+
+fruits_json_matcher = ->(input, **) { !input['fruits'].nil? }
+fruits_json_caller = ->(input, **) { input['fruits'].to_h { |e| [e['name'], e['emoji']] } }
+
+animals_xml_matcher = ->(input, **) { !input.get_elements('//animals').empty? }
+animals_xml_caller = ->(input, **) { input.get_elements('//animals').first.to_h { |e| [e['name'], e['emoji']] } }
+
+fruits_xml_matcher = ->(input, **) { !input.get_elements('//fruits').empty? }
+fruits_xml_caller = ->(input, **) { input.get_elements('//fruits').first.to_h { |e| [e['name'], e['emoji']] } }
+
+terminator_true = ->(*) { true }
+
+# === Logging Module (uses _node_:) ===
+
+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
+
+    return unless 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
+
+loggable = Logging.method(:loggable)
+
+# === Tree Structure ===
+
+tree = CallableTree::Node::Root.new.seekable.append(
+  CallableTree::Node::Internal.create(
+    matcher: json_matcher,
+    caller: json_caller,
+    terminator: terminator_true,
+    hookable: true
+  ).tap(&loggable).seekable.append(
+    CallableTree::Node::External.create(
+      matcher: animals_json_matcher,
+      caller: animals_json_caller,
+      hookable: true
+    ).tap(&loggable).verbosify,
+    CallableTree::Node::External.create(
+      matcher: fruits_json_matcher,
+      caller: fruits_json_caller,
+      hookable: true
+    ).tap(&loggable).verbosify
+  ),
+  CallableTree::Node::Internal.create(
+    matcher: xml_matcher,
+    caller: xml_caller,
+    terminator: terminator_true,
+    hookable: true
+  ).tap(&loggable).seekable.append(
+    CallableTree::Node::External.create(
+      matcher: animals_xml_matcher,
+      caller: animals_xml_caller,
+      hookable: true
+    ).tap(&loggable).verbosify,
+    CallableTree::Node::External.create(
+      matcher: fruits_xml_matcher,
+      caller: fruits_xml_caller,
+      hookable: true
+    ).tap(&loggable).verbosify
+  )
+)
+
+# === Execution ===
+
+Dir.glob("#{__dir__}/../docs/*") do |file|
+  options = { foo: :bar }
+  pp tree.call(file, **options)
+  puts '---'
+end

data/lib/callable_tree/node/builder.rb

@@ -50,6 +50,7 @@ module CallableTree
         ::Class
           .new do
             include node_type
+
             if hookable
               prepend Hooks::Matcher
               prepend Hooks::Caller

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

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module CallableTree
+  module Node
+    module External
+      # Pod: A node that can be instantiated directly with proc-based behavior.
+      # Provides an alternative to Builder style for inline node creation.
+      #
+      # Usage patterns:
+      #   Constructor style: Pod.new(caller: ->(input, **) { input * 2 })
+      #   Factory style: External.create(caller: ->(input, **) { input * 2 })
+      #   Block style: External.create { |node| node.caller { |input, **| input * 2 } }
+      class Pod
+        include External
+
+        def initialize(matcher: nil, caller: nil, terminator: nil, identifier: nil)
+          @_matcher = matcher
+          @_caller = caller
+          @_terminator = terminator
+          @_identifier = identifier
+
+          yield self if block_given?
+        end
+
+        # DSL setters for block syntax
+        def matcher(proc = nil, &block)
+          @_matcher = proc || block
+          self
+        end
+
+        def caller(proc = nil, &block)
+          @_caller = proc || block
+          self
+        end
+
+        def terminator(proc = nil, &block)
+          @_terminator = proc || block
+          self
+        end
+
+        def identifier(proc = nil, &block)
+          @_identifier = proc || block
+          self
+        end
+
+        def match?(*inputs, **options)
+          return super unless @_matcher
+
+          @_matcher.call(*inputs, **options, _node_: self) do |*a, **o|
+            super(*a, **o)
+          end
+        end
+
+        def call(*inputs, **options)
+          raise ::CallableTree::Error, 'caller is not set' unless @_caller
+
+          @_caller.call(*inputs, **options, _node_: self) do |*a, **o|
+            super(*a, **o)
+          end
+        end
+
+        def terminate?(output, *inputs, **options)
+          return super unless @_terminator
+
+          @_terminator.call(output, *inputs, **options, _node_: self) do |o, *a, **opts|
+            super(o, *a, **opts)
+          end
+        end
+
+        def identity
+          return super unless @_identifier
+
+          @_identifier.call(_node_: self) { super }
+        end
+      end
+
+      # HookablePod: Pod with Hooks support (before/around/after callbacks).
+      class HookablePod < Pod
+        prepend Hooks::Matcher
+        prepend Hooks::Caller
+        prepend Hooks::Terminator
+      end
+
+      # Factory method
+      def self.create(matcher: nil, caller: nil, terminator: nil, identifier: nil, hookable: false, &block)
+        klass = hookable ? HookablePod : Pod
+        klass.new(matcher: matcher, caller: caller, terminator: terminator, identifier: identifier, &block)
+      end
+    end
+  end
+end

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

@@ -11,7 +11,7 @@ module CallableTree
         end
 
         def call(*inputs, **options)
-          output = super(*inputs, **options)
+          output = super
           options.delete(:_node_)
           routes = self.routes
 

data/lib/callable_tree/node/external.rb

@@ -32,6 +32,7 @@ module CallableTree
 
       def verbosify!
         extend Verbose
+
         self
       end
 

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

@@ -42,7 +42,7 @@ module CallableTree
 
           terminated =
             if around_terminator_callbacks.empty?
-              super(output, *inputs, **options)
+              super
             else
               around_terminator_callbacks_head, *around_terminator_callbacks_tail = around_terminator_callbacks
               terminator = proc { super(output, *inputs, **options) }

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

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module CallableTree
+  module Node
+    module Internal
+      # Pod: A node that can be instantiated directly with proc-based behavior.
+      # Provides an alternative to Builder style for inline node creation.
+      #
+      # Usage patterns:
+      #   Constructor style: Pod.new(caller: ->(input, **) { input * 2 })
+      #   Factory style: Internal.create(caller: ->(input, **) { input * 2 })
+      #   Block style: Internal.create { |node| node.caller { |input, **| input * 2 } }
+      class Pod
+        include Internal
+
+        def initialize(matcher: nil, caller: nil, terminator: nil, identifier: nil)
+          @_matcher = matcher
+          @_caller = caller
+          @_terminator = terminator
+          @_identifier = identifier
+
+          yield self if block_given?
+        end
+
+        # DSL setters for block syntax
+        def matcher(proc = nil, &block)
+          @_matcher = proc || block
+          self
+        end
+
+        def caller(proc = nil, &block)
+          @_caller = proc || block
+          self
+        end
+
+        def terminator(proc = nil, &block)
+          @_terminator = proc || block
+          self
+        end
+
+        def identifier(proc = nil, &block)
+          @_identifier = proc || block
+          self
+        end
+
+        def match?(*inputs, **options)
+          return super unless @_matcher
+
+          @_matcher.call(*inputs, **options, _node_: self) do |*a, **o|
+            super(*a, **o)
+          end
+        end
+
+        def call(*inputs, **options)
+          return super unless @_caller
+
+          @_caller.call(*inputs, **options, _node_: self) do |*a, **o|
+            super(*a, **o)
+          end
+        end
+
+        def terminate?(output, *inputs, **options)
+          return super unless @_terminator
+
+          @_terminator.call(output, *inputs, **options, _node_: self) do |o, *a, **opts|
+            super(o, *a, **opts)
+          end
+        end
+
+        def identity
+          return super unless @_identifier
+
+          @_identifier.call(_node_: self) { super }
+        end
+      end
+
+      # HookablePod: Pod with Hooks support (before/around/after callbacks).
+      class HookablePod < Pod
+        prepend Hooks::Matcher
+        prepend Hooks::Caller
+        prepend Hooks::Terminator
+      end
+
+      # Factory method
+      def self.create(matcher: nil, caller: nil, terminator: nil, identifier: nil, hookable: false, &block)
+        klass = hookable ? HookablePod : Pod
+        klass.new(matcher: matcher, caller: caller, terminator: terminator, identifier: identifier, &block)
+      end
+    end
+  end
+end

data/lib/callable_tree/node/internal/{strategyable.rb → strategizable.rb}

@@ -3,7 +3,7 @@
 module CallableTree
   module Node
     module Internal
-      module Strategyable
+      module Strategizable
         def self.included(mod)
           mod.extend ClassMethods
         end
@@ -70,8 +70,8 @@ module CallableTree
             key = key.to_sym
             config[:alias] = key unless config[:alias]
             config[:factory] = DEFAUTL_FACTORY unless config[:factory]
-            Strategyable.__send__(:strategy_configs)[key] = config
-            Strategyable.__send__(:define_strategy_methods, key, config)
+            Strategizable.__send__(:strategy_configs)[key] = config
+            Strategizable.__send__(:define_strategy_methods, key, config)
           end
         end
 
@@ -95,7 +95,7 @@ module CallableTree
         private
 
         def strategize(name, *args, matchable:, terminable:, **kwargs)
-          clone.strategy!(name, *args, matchable: matchable, terminable: terminable, **kwargs)
+          clone.strategize!(name, *args, matchable: matchable, terminable: terminable, **kwargs)
         end
 
         def strategize!(name, *args, matchable:, terminable:, **kwargs)

data/lib/callable_tree/node/internal.rb

@@ -5,7 +5,7 @@ module CallableTree
     module Internal
       extend ::Forwardable
       include Node
-      include Strategyable
+      include Strategizable
 
       def self.included(mod)
         return unless mod.include?(External)
@@ -46,7 +46,7 @@ module CallableTree
           .lazy
           .select(&:internal?)
           .map { |node| node.find(recursive: true, &block) }
-          .reject(&:nil?)
+          .reject(&:nil?) # rubocop:disable Style/CollectionCompact
           .first
       end
 

data/lib/callable_tree/version.rb

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

data/lib/callable_tree.rb

@@ -14,10 +14,12 @@ require_relative 'callable_tree/node/internal/strategy'
 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/internal/strategyable'
+require_relative 'callable_tree/node/internal/strategizable'
 require_relative 'callable_tree/node/external/verbose'
 require_relative 'callable_tree/node/external'
 require_relative 'callable_tree/node/internal'
+require_relative 'callable_tree/node/external/pod'
+require_relative 'callable_tree/node/internal/pod'
 require_relative 'callable_tree/node/builder'
 require_relative 'callable_tree/node/internal/builder'
 require_relative 'callable_tree/node/external/builder'

data/mise.toml

@@ -0,0 +1,2 @@
+[tools]
+ruby = "4.0.0"