callable_tree 0.3.3 → 0.3.6

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/examples/{internal-broadcast.rb → internal-broadcastable.rb}

@@ -16,16 +16,16 @@ module Node
   end
 end
 
-tree = CallableTree::Node::Root.new.append(
-  Node::LessThan.new(5).append(
+tree = CallableTree::Node::Root.new.broadcastable.append(
+  Node::LessThan.new(5).broadcastable.append(
     ->(input) { input * 2 }, # anonymous external node
     ->(input) { input + 1 }  # anonymous external node
-  ).broadcast,
-  Node::LessThan.new(10).append(
+  ),
+  Node::LessThan.new(10).broadcastable.append(
     ->(input) { input * 3 }, # anonymous external node
     ->(input) { input - 1 }  # anonymous external node
-  ).broadcast
-).broadcast
+  )
+)
 
 (0..10).each do |input|
   output = tree.call(input)

data/examples/{internal-compose.rb → internal-composable.rb}

@@ -16,16 +16,16 @@ module Node
   end
 end
 
-tree = CallableTree::Node::Root.new.append(
-  Node::LessThan.new(5).append(
+tree = CallableTree::Node::Root.new.composable.append(
+  Node::LessThan.new(5).composable.append(
     proc { |input| input * 2 }, # anonymous external node
     proc { |input| input + 1 }  # anonymous external node
-  ).compose,
-  Node::LessThan.new(10).append(
+  ),
+  Node::LessThan.new(10).composable.append(
     proc { |input| input * 3 }, # anonymous external node
     proc { |input| input - 1 }  # anonymous external node
-  ).compose
-).compose
+  )
+)
 
 (0..10).each do |input|
   output = tree.call(input)

data/examples/{internal-seek.rb → internal-seekable.rb}

@@ -85,12 +85,12 @@ module Node
   end
 end
 
-tree = CallableTree::Node::Root.new.append(
-  Node::JSON::Parser.new.append(
+tree = CallableTree::Node::Root.new.seekable.append(
+  Node::JSON::Parser.new.seekable.append(
     Node::JSON::Scraper.new(type: :animals),
     Node::JSON::Scraper.new(type: :fruits)
   ),
-  Node::XML::Parser.new.append(
+  Node::XML::Parser.new.seekable.append(
     Node::XML::Scraper.new(type: :animals),
     Node::XML::Scraper.new(type: :fruits)
   )

data/lib/callable_tree/node/builder.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module CallableTree
+  module Node
+    module Builder
+      def matcher(&block)
+        @matcher = block
+        self
+      end
+
+      def caller(&block)
+        @caller = block
+        self
+      end
+
+      def terminater(&block)
+        warn 'Use CallableTree::Node::Internal::Builder#terminator instead.'
+        @terminator = block
+        self
+      end
+
+      def terminator(&block)
+        @terminator = block
+        self
+      end
+
+      def hookable(hookable = true)
+        @hookable = hookable
+        self
+      end
+
+      def build(node_type:)
+        matcher = @matcher
+        caller = @caller
+        terminator = @terminator
+        hookable = @hookable
+
+        validate(
+          matcher: matcher,
+          caller: caller,
+          terminator: terminator
+        )
+
+        ::Class
+          .new do
+            include node_type
+            if hookable
+              prepend Hooks::Matcher
+              prepend Hooks::Caller
+            end
+
+            if matcher
+              define_method(:match?) do |*inputs, **options|
+                matcher.call(*inputs, **options) do |*inputs, **options|
+                  super(*inputs, **options)
+                end
+              end
+            end
+
+            if caller
+              define_method(:call) do |*inputs, **options|
+                caller.call(*inputs, **options) do |*inputs, **options|
+                  super(*inputs, **options)
+                end
+              end
+            end
+
+            if terminator
+              define_method(:terminate?) do |output, *inputs, **options|
+                terminator.call(output, *inputs, **options) do |output, *inputs, **options|
+                  super(output, *inputs, **options)
+                end
+              end
+            end
+          end
+      end
+
+      private
+
+      def validate(matcher:, caller:, terminator:)
+        raise ::CallableTree::Error, 'Not implemented'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module CallableTree
+  module Node
+    module External
+      class Builder
+        include Node::Builder
+
+        class Error < StandardError; end
+
+        def build
+          super(node_type: External)
+        end
+
+        private
+
+        def validate(matcher:, caller:, terminator:)
+          raise Error, 'caller is required' unless caller
+        end
+      end
+    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/builder.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module CallableTree
+  module Node
+    module Internal
+      class Builder
+        include Node::Builder
+
+        def build
+          super(node_type: Internal)
+        end
+
+        private
+
+        def validate(matcher:, caller:, terminator:)
+          # noop
+        end
+      end
+    end
+  end
+end

data/lib/callable_tree/node/internal.rb

@@ -98,6 +98,10 @@ module CallableTree
         end
       end
 
+      alias seekable? seek?
+      alias seekable seek
+      alias seekable! seek!
+
       def broadcast?
         strategy.is_a?(Strategy::Broadcast)
       end
@@ -118,6 +122,10 @@ module CallableTree
         end
       end
 
+      alias broadcastable? broadcast?
+      alias broadcastable broadcast
+      alias broadcastable! broadcast!
+
       def compose?
         strategy.is_a?(Strategy::Compose)
       end
@@ -138,6 +146,10 @@ 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)) }

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.3'
+  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'
@@ -15,4 +16,7 @@ require_relative 'callable_tree/node/internal/strategy/compose'
 require_relative 'callable_tree/node/external/verbose'
 require_relative 'callable_tree/node/external'
 require_relative 'callable_tree/node/internal'
+require_relative 'callable_tree/node/builder'
+require_relative 'callable_tree/node/internal/builder'
+require_relative 'callable_tree/node/external/builder'
 require_relative 'callable_tree/node/root'