callable_tree 0.3.8 → 0.3.10

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

@@ -13,7 +13,7 @@ module CallableTree
         end
 
         def ==(other)
-          name == other.name
+          name == other.name && matchable? == other.matchable? && terminable? == other.terminable?
         end
 
         def eql?(other)
@@ -21,7 +21,37 @@ module CallableTree
         end
 
         def hash
-          self.class.name.hash
+          [self.class.name, matchable, terminable].join('-').hash
+        end
+
+        def matchable?
+          matchable
+        end
+
+        def terminable?
+          terminable
+        end
+
+        private
+
+        attr_accessor :matchable, :terminable
+
+        def matcher
+          @matcher ||=
+            if matchable
+              proc { |node, *inputs, **options| node.match?(*inputs, **options) }
+            else
+              proc { false }
+            end
+        end
+
+        def terminator
+          @terminator ||=
+            if terminable
+              proc { |node, output, *inputs, **options| node.terminate?(output, *inputs, **options) }
+            else
+              proc { false }
+            end
         end
       end
     end

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

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module CallableTree
+  module Node
+    module Internal
+      module Strategyable
+        def self.included(mod)
+          mod.extend ClassMethods
+        end
+
+        DEFAUTL_FACTORY = proc do |klass, *_args, matchable:, terminable:, **_kwargs|
+          klass.new(matchable: matchable, terminable: terminable)
+        end
+
+        @@strategy_configs = {
+          seek: {
+            klass: Strategy::Seek,
+            alias: :seekable,
+            matchable: true,
+            terminable: true,
+            factory: DEFAUTL_FACTORY
+          },
+          broadcast: {
+            klass: Strategy::Broadcast,
+            alias: :broadcastable,
+            matchable: true,
+            terminable: false,
+            factory: DEFAUTL_FACTORY
+          },
+          compose: {
+            klass: Strategy::Compose,
+            alias: :composable,
+            matchable: true,
+            terminable: false,
+            factory: DEFAUTL_FACTORY
+          }
+        }
+
+        class << self
+          private
+
+          def strategy_configs
+            @@strategy_configs
+          end
+
+          def define_strategy_methods(key, config)
+            define_method(:"#{config[:alias]}?") { strategy.is_a?(config[:klass]) }
+
+            define_method(config[:alias]) do |*args, matchable: config[:matchable], terminable: config[:terminable], **kwargs|
+              # TODO: Modify to use strategize method
+              if strategy == config[:factory].call(
+                config[:klass], *args, matchable: matchable, terminable: terminable, **kwargs
+              )
+                self
+              else
+                clone.__send__(:"#{config[:alias]}!", *args, matchable: matchable, terminable: terminable, **kwargs)
+              end
+            end
+
+            define_method(:"#{config[:alias]}!") do |*args, matchable: config[:matchable], terminable: config[:terminable], **kwargs|
+              strategize!(key, *args, matchable: matchable, terminable: terminable, **kwargs)
+            end
+          end
+        end
+
+        module ClassMethods
+          def store_strategy(key, config)
+            raise ::CallableTree::Error, 'Strategy class is required. [:klass]' unless config[:klass]
+
+            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)
+          end
+        end
+
+        @@strategy_configs.each { |key, config| define_strategy_methods(key, config) }
+
+        # Backward compatibility
+        alias seek? seekable?
+        alias seek seekable
+        alias seek! seekable!
+        alias broadcast? broadcastable?
+        alias broadcast broadcastable
+        alias broadcast! broadcastable!
+        alias compose? composable?
+        alias compose composable
+        alias compose! composable!
+
+        protected
+
+        attr_writer :strategy
+
+        private
+
+        def strategize(name, *args, matchable:, terminable:, **kwargs)
+          clone.strategy!(name, *args, matchable: matchable, terminable: terminable, **kwargs)
+        end
+
+        def strategize!(name, *args, matchable:, terminable:, **kwargs)
+          config = @@strategy_configs[name.to_sym]
+          raise ::CallableTree::Error, "Strategy is not found. [#{name}]" unless config
+
+          self.strategy = config[:factory].call(
+            config[:klass], *args, matchable: matchable, terminable: terminable, **kwargs
+          )
+          self
+        end
+
+        def strategy
+          @strategy ||= @@strategy_configs[:seek][:klass].new
+        end
+      end
+    end
+  end
+end

data/lib/callable_tree/node/internal.rb

@@ -5,12 +5,13 @@ module CallableTree
     module Internal
       extend ::Forwardable
       include Node
+      include Strategyable
 
       def self.included(mod)
-        if mod.include?(External)
-          raise ::CallableTree::Error,
-                "#{mod} cannot include #{self} together with #{External}"
-        end
+        return unless mod.include?(External)
+
+        raise ::CallableTree::Error,
+              "#{mod} cannot include #{self} together with #{External}"
       end
 
       def_delegators :child_nodes, :[], :at
@@ -39,14 +40,14 @@ module CallableTree
         node = child_nodes.find(&block)
         return node if node
 
-        if recursive
-          child_nodes
-            .lazy
-            .select { |node| node.internal? }
-            .map { |node| node.find(recursive: true, &block) }
-            .reject(&:nil?)
-            .first
-        end
+        return unless recursive
+
+        child_nodes
+          .lazy
+          .select(&:internal?)
+          .map { |node| node.find(recursive: true, &block) }
+          .reject(&:nil?)
+          .first
       end
 
       def reject(recursive: false, &block)
@@ -85,78 +86,6 @@ module CallableTree
         strategy.call(child_nodes, *inputs, **options)
       end
 
-      def seek?
-        strategy.is_a?(Strategy::Seek)
-      end
-
-      def seek
-        if seek?
-          self
-        else
-          clone.tap do |node|
-            node.strategy = Strategy::Seek.new
-          end
-        end
-      end
-
-      def seek!
-        tap do |node|
-          node.strategy = Strategy::Seek.new unless seek?
-        end
-      end
-
-      alias seekable? seek?
-      alias seekable seek
-      alias seekable! seek!
-
-      def broadcast?
-        strategy.is_a?(Strategy::Broadcast)
-      end
-
-      def broadcast
-        if broadcast?
-          self
-        else
-          clone.tap do |node|
-            node.strategy = Strategy::Broadcast.new
-          end
-        end
-      end
-
-      def broadcast!
-        tap do |node|
-          node.strategy = Strategy::Broadcast.new unless broadcast?
-        end
-      end
-
-      alias broadcastable? broadcast?
-      alias broadcastable broadcast
-      alias broadcastable! broadcast!
-
-      def compose?
-        strategy.is_a?(Strategy::Compose)
-      end
-
-      def compose
-        if compose?
-          self
-        else
-          clone.tap do |node|
-            node.strategy = Strategy::Compose.new
-          end
-        end
-      end
-
-      def compose!
-        tap do |node|
-          node.strategy = Strategy::Compose.new unless compose?
-        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)) }
@@ -171,10 +100,6 @@ module CallableTree
         false
       end
 
-      protected
-
-      attr_writer :strategy
-
       def child_nodes
         @child_nodes ||= []
       end
@@ -192,10 +117,6 @@ module CallableTree
           .tap { |node| node.parent = self }
       end
 
-      def strategy
-        @strategy ||= Strategy::Seek.new
-      end
-
       def initialize_copy(_node)
         super
         self.parent = nil

data/lib/callable_tree/node.rb

@@ -13,7 +13,7 @@ module CallableTree
         node = self
         loop do
           y << node
-          break unless node = node.parent
+          break unless (node = node.parent)
         end
       end
     end

data/lib/callable_tree/version.rb

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

data/lib/callable_tree.rb

@@ -14,6 +14,7 @@ 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/external/verbose'
 require_relative 'callable_tree/node/external'
 require_relative 'callable_tree/node/internal'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: callable_tree
 version: !ruby/object:Gem::Version
-  version: 0.3.8
+  version: 0.3.10
 platform: ruby
 authors:
 - jsmmr
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-05-05 00:00:00.000000000 Z
+date: 2022-12-30 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
@@ -19,6 +19,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/dependabot.yml"
 - ".github/workflows/build.yml"
 - ".github/workflows/codeql-analysis.yml"
 - ".gitignore"
@@ -34,7 +35,9 @@ files:
 - bin/console
 - bin/setup
 - callable_tree.gemspec
+- examples/builder/external-verbosify.rb
 - examples/builder/hooks.rb
+- examples/builder/identity.rb
 - examples/builder/internal-broadcastable.rb
 - examples/builder/internal-composable.rb
 - examples/builder/internal-seekable.rb
@@ -65,6 +68,7 @@ files:
 - lib/callable_tree/node/internal/strategy/broadcast.rb
 - lib/callable_tree/node/internal/strategy/compose.rb
 - lib/callable_tree/node/internal/strategy/seek.rb
+- lib/callable_tree/node/internal/strategyable.rb
 - lib/callable_tree/node/root.rb
 - lib/callable_tree/version.rb
 homepage: https://github.com/jsmmr/ruby_callable_tree
@@ -73,7 +77,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.8/CHANGELOG.md
+  changelog_uri: https://github.com/jsmmr/ruby_callable_tree/blob/v0.3.10/CHANGELOG.md
   rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
@@ -90,7 +94,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.4.1
 signing_key:
 specification_version: 4
 summary: Builds a tree by linking callable nodes. The nodes that match the conditions