callable_tree 0.1.0

data/examples/example5.rb

@@ -0,0 +1,35 @@
+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(
+    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/lib/callable_tree.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module CallableTree
+  class Error < StandardError; end
+end
+
+require 'forwardable'
+require_relative 'callable_tree/version'
+require_relative 'callable_tree/node'
+require_relative 'callable_tree/node/external/verbose'
+require_relative 'callable_tree/node/external'
+require_relative 'callable_tree/node/hooks/call'
+require_relative 'callable_tree/node/internal'
+require_relative 'callable_tree/node/root'

data/lib/callable_tree/node.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module CallableTree
+  module Node
+    attr_reader :parent
+
+    def ancestors
+      ::Enumerator.new do |y|
+        node = self
+        loop do
+          y << node
+          break unless node = node&.parent
+        end
+      end
+    end
+
+    def routes
+      ancestors.map(&:identity)
+    end
+
+    def identity
+      self.class
+    end
+
+    def depth
+      parent.nil? ? 0 : parent.depth + 1
+    end
+
+    def match?(_input = nil, **_options)
+      true
+    end
+
+    def call(_input = nil, **_options)
+      raise ::CallableTree::Error, 'Not implemented'
+    end
+
+    def terminate?(output = nil, **_options)
+      !output.nil?
+    end
+
+    private
+
+    attr_writer :parent
+  end
+end

data/lib/callable_tree/node/branch.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module CallableTree
+  module Node
+    module Branch
+      attr_reader :parent
+
+      def ancestors
+        ::Enumerator.new do |y|
+          node = self
+          while node = node&.parent
+            y << node
+          end
+        end
+      end
+
+      def routes
+        ::Enumerator.new do |y|
+          y << self.class
+          ancestors.each { |node| y << node.class }
+        end
+      end
+
+      def depth
+        parent.nil? ? 0 : parent.depth + 1
+      end
+
+      private
+
+      attr_writer :parent
+    end
+
+    private_constant :Branch
+  end
+end

data/lib/callable_tree/node/external.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module CallableTree
+  module Node
+    module External
+      include Node
+
+      def self.proxify(callable)
+        Proxy.new(callable)
+      end
+
+      def self.proxified?(node)
+        node.is_a?(Proxy)
+      end
+
+      def self.unproxify(node)
+        node.callable
+      end
+
+      def verbosify
+        extend Verbose
+        self
+      end
+
+      def identity
+        if External.proxified?(self)
+          External.unproxify(self)
+        else
+          self
+        end
+          .class
+      end
+
+      class Proxy
+        extend ::Forwardable
+        include External
+
+        def_delegators :@callable, :call
+        attr_reader :callable
+
+        def initialize(callable)
+          @callable = callable
+        end
+      end
+
+      private_constant :Proxy
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module CallableTree
+  module Node
+    module External
+      Output = Struct.new(:value, :options, :routes)
+
+      module Verbose
+        def call(input = nil, **options)
+          output = super(input, **options)
+          routes = self.routes
+
+          Output.new(output, options, routes)
+        end
+      end
+
+      private_constant :Verbose
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# 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)
+          before_callbacks << block
+          self
+        end
+
+        def around_call(&block)
+          around_callbacks << block
+          self
+        end
+
+        def after_call(&block)
+          after_callbacks << block
+          self
+        end
+
+        def call(input = nil, **options)
+          input = before_callbacks.reduce(input) do |input, callable|
+            callable.call(input, self, **options)
+          end
+
+          output = super(input, **options)
+
+          output = around_callbacks.reduce(output) do |output, callable|
+            callable.call(input, 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

data/lib/callable_tree/node/internal.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module CallableTree
+  module Node
+    module Internal
+      include Node
+
+      def children
+        @children ||= []
+      end
+
+      def <<(callable)
+        children <<
+          if callable.is_a?(Node)
+            callable.clone
+          else
+            External.proxify(callable)
+          end
+          .tap { |node| node.send(:parent=, self) }
+
+        self
+      end
+
+      def append(*callables)
+        callables.each { |callable| self.<<(callable) }
+        self
+      end
+
+      def match?(_input = nil, **_options)
+        !children.empty?
+      end
+
+      def call(input = nil, **options)
+        children
+          .lazy
+          .map { |node| Input.new(input, options, node) }
+          .select { |input| input.valid? }
+          .map { |input| input.call }
+          .select { |output| output.valid? }
+          .map { |output| output.call }
+          .first
+      end
+
+      class Input < BasicObject
+        def initialize(value, options, node)
+          @value = value
+          @options = options
+          @node = node
+        end
+
+        def valid?
+          @node.match?(@value, **@options)
+        end
+
+        def call
+          value = @node.call(@value, **@options)
+          Output.new(value, @options, @node)
+        end
+      end
+
+      class Output < BasicObject
+        def initialize(value, options, node)
+          @value = value
+          @options = options
+          @node = node
+        end
+
+        def valid?
+          @node.terminate?(@value, **@options)
+        end
+
+        def call
+          @value
+        end
+      end
+
+      private_constant :Input, :Output
+
+      private
+
+      attr_writer :children
+
+      def initialize_copy(_node)
+        super
+        self.children = children.map do |node|
+          node.clone.tap { |new_node| new_node.send(:parent=, self) }
+        end
+      end
+    end
+  end
+end

data/lib/callable_tree/node/root.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module CallableTree
+  module Node
+    class Root
+      include Internal
+      prepend Hooks::Call
+
+      def self.inherited(subclass)
+        raise ::CallableTree::Error, "#{subclass} cannot inherit #{self}"
+      end
+    end
+  end
+end

data/lib/callable_tree/version.rb

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

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: callable_tree
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- jsmmr
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2021-05-19 00:00:00.000000000 Z
+dependencies: []
+description: Builds a tree by linking callable nodes. The nodes that match the calling
+  condition are called in a chain from the root node to the leaf node. This is like
+  nested case statements.
+email:
+- jsmmr@icloud.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/build.yml"
+- ".gitignore"
+- ".rspec"
+- ".ruby-version"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- callable_tree.gemspec
+- examples/docs/animals.json
+- examples/docs/animals.xml
+- examples/docs/fruits.json
+- examples/docs/fruits.xml
+- examples/example1.rb
+- examples/example2.rb
+- examples/example3.rb
+- examples/example4.rb
+- examples/example5.rb
+- lib/callable_tree.rb
+- lib/callable_tree/node.rb
+- lib/callable_tree/node/branch.rb
+- lib/callable_tree/node/external.rb
+- lib/callable_tree/node/external/verbose.rb
+- lib/callable_tree/node/hooks/call.rb
+- lib/callable_tree/node/internal.rb
+- lib/callable_tree/node/root.rb
+- lib/callable_tree/version.rb
+homepage: https://github.com/jsmmr/ruby_callable_tree
+licenses:
+- MIT
+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/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.16
+signing_key:
+specification_version: 4
+summary: Builds a tree by linking callable nodes. The nodes that match the calling
+  condition are called in a chain from the root node to the leaf node. This is like
+  nested case statements.
+test_files: []