callable_tree 0.1.3 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8fa06f3d5119313cc62468deec9349bb902f92ff6267f9b0051d5625eea8a866
-  data.tar.gz: 8679ef5bd22e419d6379b18fdc0a509074938073c9edaff37b4a7bee6029cda8
+  metadata.gz: df7b380d00c1a56530ddd6fc4ee7159ca4f1fc14d3418c2f567f43ff6d176553
+  data.tar.gz: 9e2d706c5d50ae1350dfdcf92951678e7284a83fba5a71e9f8f13ffcb58c4db7
 SHA512:
-  metadata.gz: 6ccdf3baffda301532c51510b84d066cec428961f773618ddc8d344917c9af26ca3da3d6186d6748585a8eceb0eabac0d7e652bcbcafb28b3a4a9e74622eb98f
-  data.tar.gz: e1aa253c87040bebc9f03080ad25f704c1cbde0410355b4ffb70bbe969338d3ec7a88804abe856d582b9e351a182db43a7abe4b2f0b89c3f7d97fc6bb64bf1eb
+  metadata.gz: 9cd503091f5ba29c416120bdf5eca39535048c920721d0e4180cbfa95b3eb4d40ea77e2f28a9a8f4cb271adbd11050ad6a4a33313a80baf5cfa587a4e81365a1
+  data.tar.gz: 1948d9a3f5ec7a8ed17030436e513f253c2f1d1e24719f8813128bdb7e3db68f6a6d573cf2dc5e155177c4c1558b0aaf4cf9befbaf0d2a7c71b3ce6b92d3b668

data/.ruby-version

@@ -1 +1 @@
-3.0.0
+3.0.2

data/CHANGELOG.md

@@ -1,5 +1,27 @@
 ## [Unreleased]
 
+## [0.2.3] - 2021-11-07
+- Add `CallableTree::Node::Internal#shake` to recursively execute `CallableTree::Node::Internal#reject`, including child nodes. The child nodes that are empty because their children have been rejected will also be rejected.
+- Add `CallableTree::Node::Internal#shake!` that make destructive change.
+- Add `CallableTree::Node#outline` that may be useful for writing the specs.
+
+## [0.2.2] - 2021-10-24
+- Add `CallableTree::Node::Internal#reject` to return a new node instance without rejected child nodes.
+- Add `CallableTree::Node::Internal#reject!` to destructively reject child nodes.
+
+## [0.2.1] - 2021-07-24
+- Add `CallableTree::Node#root?`.
+- Add `CallableTree::Node::Internal#seek!` that make destructive change.
+- Add `CallableTree::Node::Internal#broadcast!` that make destructive change.
+- Add `CallableTree::Node::Internal#compose!` that make destructive change.
+
+## [0.2.0] - 2021-06-15
+- Change `CallableTree::Node::Internal#append` to return a new instance.
+  To keep the same behavior as the older version, use `CallableTree::Node::External#append!` that make destructive change.
+- Remove `CallableTree::Node::Internal#<<`. Use `CallableTree::Node::External#append!` instead.
+- Change `CallableTree::Node::External#verbosify` to return a new instance.
+  To keep the same behavior as the older version, use `CallableTree::Node::External#verbosify!` that make destructive change.
+
 ## [0.1.3] - 2021-06-12
 - Minor improvements
 

data/Gemfile.lock

@@ -1,13 +1,13 @@
 PATH
   remote: .
   specs:
-    callable_tree (0.1.3)
+    callable_tree (0.2.3)
 
 GEM
   remote: https://rubygems.org/
   specs:
     diff-lcs (1.4.4)
-    rake (13.0.3)
+    rake (13.0.6)
     rspec (3.10.0)
       rspec-core (~> 3.10.0)
       rspec-expectations (~> 3.10.0)
@@ -20,7 +20,7 @@ GEM
     rspec-mocks (3.10.2)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.10.0)
-    rspec-support (3.10.2)
+    rspec-support (3.10.3)
 
 PLATFORMS
   x86_64-darwin-19
@@ -32,4 +32,4 @@ DEPENDENCIES
   rspec (~> 3.0)
 
 BUNDLED WITH
-   2.2.17
+   2.2.22

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2021 　
+Copyright (c) 2021 jsmmr
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -1,5 +1,7 @@
 # CallableTree
 
+[![build](https://github.com/jsmmr/ruby_callable_tree/actions/workflows/build.yml/badge.svg)](https://github.com/jsmmr/ruby_callable_tree/actions/workflows/build.yml)
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -158,7 +160,7 @@ Run `examples/internal-seek.rb`:
 ---
 ```
 
-#### `CallableTree::Node::Internal#broadcast` (experimental)
+#### `CallableTree::Node::Internal#broadcast`
 
 This strategy calls all child nodes of the internal node and ignores their `terminate?` methods, and then outputs their results as array.
 
@@ -212,7 +214,7 @@ Run `examples/internal-broadcast.rb`:
 10 -> [nil, nil]
 ```
 
-#### `CallableTree::Node::Internal#compose` (experimental)
+#### `CallableTree::Node::Internal#compose`
 
 This strategy calls all child nodes of the internal node in order to input the output of the previous node to the next node and ignores their `terminate?` methods, and then outputs a single result.
 

data/callable_tree.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |spec|
   spec.email         = ['jsmmr@icloud.com']
 
   spec.summary       = '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 `if` or `case` expressions.'
-  spec.description   = 'Builds a tree by linking callable nodes. The nodes that match the conditiosn are called in a chain from the root node to the leaf node. These are like nested `if` or `case` expressions.'
+  spec.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 `if` or `case` expressions.'
   spec.homepage      = 'https://github.com/jsmmr/ruby_callable_tree'
   spec.license       = 'MIT'
   spec.required_ruby_version = Gem::Requirement.new('>= 2.4.0')

data/lib/callable_tree/node/external.rb

@@ -18,6 +18,12 @@ module CallableTree
       end
 
       def verbosify
+        clone.tap do |node|
+          node.extend Verbose
+        end
+      end
+
+      def verbosify!
         extend Verbose
         self
       end
@@ -31,6 +37,17 @@ module CallableTree
           .class
       end
 
+      def outline
+        { identity => nil }
+      end
+
+      private
+
+      def initialize_copy(_node)
+        super
+        self.parent = nil
+      end
+
       class Proxy
         extend ::Forwardable
         include External

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module CallableTree
+  module Node
+    module Internal
+      module Strategy
+        class Broadcast
+          def call(nodes, input:, options:)
+            nodes.map do |node|
+              node.call(input, **options) if node.match?(input, **options)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module CallableTree
+  module Node
+    module Internal
+      module Strategy
+        class Compose
+          def call(nodes, input:, options:)
+            nodes.reduce(input) do |input, node|
+              if node.match?(input, **options)
+                node.call(input, **options)
+              else
+                input
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module CallableTree
+  module Node
+    module Internal
+      module Strategy
+        class Seek
+          def call(nodes, input:, options:)
+            nodes
+              .lazy
+              .select { |node| node.match?(input, **options) }
+              .map do |node|
+                output = node.call(input, **options)
+                terminated = node.terminate?(output, **options)
+                [output, terminated]
+              end
+              .select { |_output, terminated| terminated }
+              .map { |output, _terminated| output }
+              .first
+          end
+        end
+      end
+    end
+  end
+end

data/lib/callable_tree/node/internal.rb

@@ -6,75 +6,135 @@ module CallableTree
       include Node
 
       def children
-        @children ||= []
+        # TODO: Change to return a new array instance.
+        child_nodes
       end
 
-      def <<(callable)
-        children <<
-          if callable.is_a?(Node)
-            callable.clone
-          else
-            External.proxify(callable)
-          end
-          .tap { |node| node.send(:parent=, self) }
+      def append(*callables)
+        clone.tap do |node|
+          node.append!(*callables)
+        end
+      end
+
+      def append!(*callables)
+        callables
+          .map { |callable| nodeify(callable) }
+          .tap { |nodes| child_nodes.push(*nodes) } # Use Array#push for Ruby 2.4
 
         self
       end
 
-      def append(*callables)
-        callables.each { |callable| self.<<(callable) }
+      def reject(&block)
+        clone.tap do |node|
+          node.reject!(&block)
+        end
+      end
+
+      def reject!(&block)
+        child_nodes.reject!(&block)
         self
       end
 
+      def shake(&block)
+        clone.tap do |node|
+          node.shake!(&block)
+        end
+      end
+
+      def shake!(&block)
+        reject!(&block) if block_given?
+
+        reject! do |node|
+          node.is_a?(Internal) && node.shake!(&block).child_nodes.empty?
+        end
+      end
+
       def match?(_input = nil, **_options)
-        !children.empty?
+        !child_nodes.empty?
       end
 
       def call(input = nil, **options)
-        strategy.call(children, input: input, options: options)
+        strategy.call(child_nodes, input: input, options: options)
       end
 
       def seek
-        if strategy.is_a?(Seek)
+        if strategy.is_a?(Strategy::Seek)
           self
         else
           clone.tap do |node|
-            node.send(:strategy=, Seek.new)
+            node.send(:strategy=, Strategy::Seek.new)
           end
         end
       end
 
+      def seek!
+        self.strategy = Strategy::Seek.new unless strategy.is_a?(Strategy::Seek)
+        self
+      end
+
       def broadcast
-        if strategy.is_a?(Broadcast)
+        if strategy.is_a?(Strategy::Broadcast)
           self
         else
           clone.tap do |node|
-            node.send(:strategy=, Broadcast.new)
+            node.send(:strategy=, Strategy::Broadcast.new)
           end
         end
       end
 
+      def broadcast!
+        self.strategy = Strategy::Broadcast.new unless strategy.is_a?(Strategy::Broadcast)
+        self
+      end
+
       def compose
-        if strategy.is_a?(Compose)
+        if strategy.is_a?(Strategy::Compose)
           self
         else
           clone.tap do |node|
-            node.send(:strategy=, Compose.new)
+            node.send(:strategy=, Strategy::Compose.new)
           end
         end
       end
 
+      def compose!
+        self.strategy = Strategy::Compose.new unless strategy.is_a?(Strategy::Compose)
+        self
+      end
+
+      def outline(&block)
+        key = block ? block.call(self) : identity
+        value = child_nodes.reduce({}) { |memo, node| memo.merge!(node.outline(&block)) }
+        { key => value }
+      end
+
+      protected
+
+      def child_nodes
+        @child_nodes ||= []
+      end
+
       private
 
-      attr_writer :children, :strategy
+      attr_writer :child_nodes, :strategy
+
+      def nodeify(callable)
+        if callable.is_a?(Node)
+          callable.clone
+        else
+          External.proxify(callable)
+        end
+          .tap { |node| node.send(:parent=, self) }
+      end
 
       def strategy
-        @strategy ||= Seek.new
+        @strategy ||= Strategy::Seek.new
       end
 
       def initialize_copy(_node)
         super
-        self.children = children.map do |node|
+        self.parent = nil
+        self.child_nodes = child_nodes.map do |node|
           node.clone.tap { |new_node| new_node.send(:parent=, self) }
         end
       end

data/lib/callable_tree/node.rb

@@ -4,12 +4,16 @@ module CallableTree
   module Node
     attr_reader :parent
 
+    def root?
+      parent.nil?
+    end
+
     def ancestors
       ::Enumerator.new do |y|
         node = self
         loop do
           y << node
-          break unless node = node&.parent
+          break unless node = node.parent
         end
       end
     end
@@ -23,7 +27,11 @@ module CallableTree
     end
 
     def depth
-      parent.nil? ? 0 : parent.depth + 1
+      root? ? 0 : parent.depth + 1
+    end
+
+    def outline
+      raise ::CallableTree::Error, 'Not implemented'
     end
 
     def match?(_input = nil, **_options)

data/lib/callable_tree/version.rb

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

data/lib/callable_tree.rb

@@ -8,9 +8,9 @@ require 'forwardable'
 require_relative 'callable_tree/version'
 require_relative 'callable_tree/node'
 require_relative 'callable_tree/node/hooks/call'
-require_relative 'callable_tree/node/internal/broadcast'
-require_relative 'callable_tree/node/internal/seek'
-require_relative 'callable_tree/node/internal/compose'
+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/external/verbose'
 require_relative 'callable_tree/node/external'
 require_relative 'callable_tree/node/internal'

metadata

@@ -1,16 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: callable_tree
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.3
 platform: ruby
 authors:
 - jsmmr
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-06-12 00:00:00.000000000 Z
+date: 2021-11-07 00:00:00.000000000 Z
 dependencies: []
-description: Builds a tree by linking callable nodes. The nodes that match the conditiosn
+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
   `if` or `case` expressions.
 email:
@@ -49,9 +49,9 @@ files:
 - lib/callable_tree/node/external/verbose.rb
 - lib/callable_tree/node/hooks/call.rb
 - lib/callable_tree/node/internal.rb
-- lib/callable_tree/node/internal/broadcast.rb
-- lib/callable_tree/node/internal/compose.rb
-- lib/callable_tree/node/internal/seek.rb
+- 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/root.rb
 - lib/callable_tree/version.rb
 homepage: https://github.com/jsmmr/ruby_callable_tree
@@ -60,7 +60,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.1.3/CHANGELOG.md
+  changelog_uri: https://github.com/jsmmr/ruby_callable_tree/blob/v0.2.3/CHANGELOG.md
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -76,7 +76,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.16
+rubygems_version: 3.2.22
 signing_key:
 specification_version: 4
 summary: Builds a tree by linking callable nodes. The nodes that match the conditions

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

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module CallableTree
-  module Node
-    module Internal
-      class Broadcast
-        def call(nodes, input:, options:)
-          nodes.map do |node|
-            node.call(input, **options) if node.match?(input, **options)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module CallableTree
-  module Node
-    module Internal
-      class Compose
-        def call(nodes, input:, options:)
-          nodes.reduce(input) do |input, node|
-            if node.match?(input, **options)
-              node.call(input, **options)
-            else
-              input
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module CallableTree
-  module Node
-    module Internal
-      class Seek
-        def call(nodes, input:, options:)
-          nodes
-            .lazy
-            .select { |node| node.match?(input, **options) }
-            .map do |node|
-              output = node.call(input, **options)
-              terminated = node.terminate?(output, **options)
-              [output, terminated]
-            end
-            .select { |_output, terminated| terminated }
-            .map { |output, _terminated| output }
-            .first
-        end
-      end
-    end
-  end
-end