metaractor-sycamore 0.4.2 → 0.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '09edde479077bf32f656d467d8ff8a570d74bd6175bab55aa15946e366938efc'
-  data.tar.gz: 85aca0da2093c00c5eefc2c76341d5442356e6625113543d2374b97de07fcadd
+  metadata.gz: ae5565f1e3e26149ac616264c7f80814ec43d0402af467d3bd39a0a95a242007
+  data.tar.gz: 6ac8b42b9cbfd6b1c2bbb32bb5415ca0f099d40c3cced190e264297f215414ea
 SHA512:
-  metadata.gz: b118f12ebd537dd56965309b610e9588b9b39eb7dd228e9b909fb7a67812e6335e163d1a4b679fad0a9e093f86a8919e20548c3edafce3a0179b42a4b0eef60b
-  data.tar.gz: ad88b3e9d45fa3429de8d27a091412e099d38e6606118a40cff6d2ffde9b963f9076f770395855459b2ec1974c3ad982a42fae94facfaa7fef8bc39218f3e9a4
+  metadata.gz: 31278db416f78913b21d63f384b5a02e195d3d47ceb6a91a847fd0489b99c7164bfc7c0629e046eabe8ee629a3de7006c684da9fd8f7e32e3cdfd86b3bb4169a
+  data.tar.gz: 1e2e022767207c83f0fd3da132a11e67f9dcc866140ac3751e1624b737a994a0c2e87856363b95ae0d84033b531f35a6d86533537f86df58822abf89714ce223

data/Gemfile

@@ -1,12 +1,12 @@
-source 'https://rubygems.org'
+source "https://rubygems.org"
 
 gemspec
 
 group :debug do
-  gem 'guard-rspec'
-  gem 'pry'
+  gem "guard-rspec"
+  gem "pry"
 end
 
 group :test do
-  gem 'coveralls', require: false, platform: :mri
+  gem "coveralls", require: false, platform: :mri
 end

data/Rakefile

@@ -1,36 +1,35 @@
-require 'bundler/gem_tasks'
+require "bundler/gem_tasks"
 
 begin
-  require 'rspec/core/rake_task'
+  require "rspec/core/rake_task"
   RSpec::Core::RakeTask.new(:spec)
 rescue LoadError
   puts "Couldn't find RSpec core Rake task"
 end
 
 begin
-  require 'yard'
+  require "yard"
   YARD::Rake::YardocTask.new do |t|
-    t.options = ['--verbose']
-    t.files   = ['lib/**/*.rb', 'doc/**/*.md']
-    t.stats_options = ['--list-undoc']
+    t.options = ["--verbose"]
+    t.files = ["lib/**/*.rb", "doc/**/*.md"]
+    t.stats_options = ["--list-undoc"]
   end
 rescue LoadError
   puts "Couldn't find YARD"
 end
 
 begin
-  require 'yard-doctest'
+  require "yard-doctest"
   YARD::Doctest::RakeTask.new do |task|
     task.doctest_opts = %w[]
-    task.pattern = 'lib/**/*.rb'
+    task.pattern = "lib/**/*.rb"
   end
 rescue LoadError
   puts "Couldn't find yard-doctest"
 end
 
-task :default =>
-  if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
-    [:spec]
-  else
-    [:spec, 'yard:doctest']
-  end
+task default:   if defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby"
+                  [:spec]
+                else
+                  [:spec, "yard:doctest"]
+                end

data/VERSION

@@ -1 +1 @@
-0.4.2
+0.4.3

data/lib/sycamore/absence.rb

@@ -1,7 +1,6 @@
-require 'delegate'
+require "delegate"
 
 module Sycamore
-
   ##
   # An Absence object represents the absence of a specific child {Sycamore::Tree}.
   #
@@ -21,7 +20,6 @@ module Sycamore
   # implementation of the parent tree and the parent node.
   #
   class Absence < Delegator
-
     ##
     # @api private
     #
@@ -30,7 +28,7 @@ module Sycamore
     end
 
     class << self
-      alias at new
+      alias_method :at, :new
     end
 
     ########################################################################
@@ -46,7 +44,7 @@ module Sycamore
       @tree or Nothing
     end
 
-    alias __getobj__ presence
+    alias_method :__getobj__, :presence
 
     ##
     # @api private
@@ -96,17 +94,17 @@ module Sycamore
       if absent?
         # TODO: This is duplication of Tree#child_at! How can we remove it, without introducing a module for this single method or inherit from Tree?
         case path.length
-          when 0 then raise ArgumentError, 'wrong number of arguments (given 0, expected 1+)'
-          when 1 then child_of(*path)
-          else child_of(path[0]).child_at(*path[1..-1])
+        when 0 then raise ArgumentError, "wrong number of arguments (given 0, expected 1+)"
+        when 1 then child_of(*path)
+        else child_of(path[0]).child_at(*path[1..])
         end
       else
         presence.child_at(*path)
       end
     end
 
-    alias [] child_at
-    alias dig child_at
+    alias_method :[], :child_at
+    alias_method :dig, :child_at
 
     ##
     # A developer-friendly string representation of the absent tree.
@@ -114,7 +112,7 @@ module Sycamore
     # @return [String]
     #
     def inspect
-      "#{absent? ? 'absent' : 'present'} child of node #{@parent_node.inspect} in #{@parent_tree.inspect}"
+      "#{absent? ? "absent" : "present"} child of node #{@parent_node.inspect} in #{@parent_tree.inspect}"
     end
 
     ##
@@ -174,6 +172,5 @@ module Sycamore
         end
       end
     end
-
   end
 end

data/lib/sycamore/exceptions.rb

@@ -1,16 +1,16 @@
 module Sycamore
   # raised when a value is not a valid node
-  class InvalidNode < ArgumentError ; end
+  class InvalidNode < ArgumentError; end
 
   # raised when trying to call a additive command method of the {Nothing} tree
-  class NothingMutation < StandardError ; end
+  class NothingMutation < StandardError; end
 
   # raised when calling {Tree#node} or {Tree#node!} on a Tree with multiple nodes
-  class NonUniqueNodeSet < StandardError ; end
+  class NonUniqueNodeSet < StandardError; end
 
   # raised when calling {Tree#node!} on a Tree without nodes
-  class EmptyNodeSet < StandardError ; end
+  class EmptyNodeSet < StandardError; end
 
   # raised when trying to fetch the child of a leaf
-  class ChildError < KeyError ; end
+  class ChildError < KeyError; end
 end

data/lib/sycamore/extension/nothing.rb

@@ -1,4 +1,4 @@
-require 'sycamore/nothing'
+require "sycamore/nothing"
 
 # optional global shortcut constant for {Sycamore::Nothing}
 Nothing = Sycamore::Nothing unless defined? Nothing

data/lib/sycamore/extension/path.rb

@@ -1,4 +1,4 @@
-require 'sycamore'
+require "sycamore"
 
 # optional global shortcut constant for Sycamore::Path
 Path = Sycamore::Path

data/lib/sycamore/extension/tree.rb

@@ -1,4 +1,4 @@
-require 'sycamore'
+require "sycamore"
 
 # optional global shortcut constant for Sycamore::Tree
 Tree = Sycamore::Tree

data/lib/sycamore/extension.rb

@@ -1,2 +1,2 @@
-require 'sycamore/extension/tree'
-require 'sycamore/extension/nothing'
+require "sycamore/extension/tree"
+require "sycamore/extension/nothing"

data/lib/sycamore/nothing.rb

@@ -1,7 +1,6 @@
-require 'singleton'
+require "singleton"
 
 module Sycamore
-
   ##
   # The Nothing Tree singleton class.
   #
@@ -43,7 +42,7 @@ module Sycamore
     # TODO: YARD should be informed about this method definitions.
     command_methods.each do |command_method|
       define_method command_method do |*args|
-        raise NothingMutation, 'attempt to change the Nothing tree'
+        raise NothingMutation, "attempt to change the Nothing tree"
       end
     end
 
@@ -66,7 +65,7 @@ module Sycamore
     # @return [String]
     #
     def to_s
-      'Tree[Nothing]'
+      "Tree[Nothing]"
     end
 
     ##
@@ -75,7 +74,7 @@ module Sycamore
     # @return [String]
     #
     def inspect
-      '#<Sycamore::Nothing>'
+      "#<Sycamore::Nothing>"
     end
 
     def freeze
@@ -95,7 +94,6 @@ module Sycamore
       (other.is_a?(Tree) or other.is_a?(Absence)) and other.empty?
     end
 
-
     ########################################################################
     # Falsiness
     #
@@ -119,7 +117,6 @@ module Sycamore
     #   true
     # end
 
-
     ########################################################################
     # Some helpers
     #
@@ -139,19 +136,17 @@ module Sycamore
       include Singleton
 
       def inspect
-        'n/a'
+        "n/a"
       end
     end
 
     ##
     # @api private
     NestedString = NestedStringPresentation.instance.freeze
-
   end
 
   ############################################################################
   # The Nothing Tree Singleton object
   #
   Nothing = NothingTree.instance.freeze
-
 end

data/lib/sycamore/path.rb

@@ -1,7 +1,6 @@
-require 'forwardable'
+require "forwardable"
 
 module Sycamore
-
   ##
   # A compact, immutable representation of Tree paths, i.e. node sequences.
   #
@@ -62,7 +61,7 @@ module Sycamore
     #
     def self.of(*args)
       if (parent = args.first).is_a? Path
-        parent.branch(*args[1..-1])
+        parent.branch(*args[1..])
       else
         root.branch(*args)
       end
@@ -71,7 +70,7 @@ module Sycamore
     class << self
       private :new  # disable Path.new
 
-      alias [] of
+      alias_method :[], :of
     end
 
     ########################################################################
@@ -96,7 +95,7 @@ module Sycamore
     #     Sycamore::Path[:foo, :bar, :baz, :qux]  # => true
     #
     def branch(*nodes)
-      return branch(*nodes.first) if nodes.size == 1 and nodes.first.is_a? Enumerable
+      return branch(*nodes.first) if nodes.size == 1 && nodes.first.is_a?(Enumerable)
 
       parent = self
       nodes.each do |node|
@@ -108,8 +107,8 @@ module Sycamore
       parent
     end
 
-    alias + branch
-    alias / branch
+    alias_method :+, :branch
+    alias_method :/, :branch
 
     ##
     # @return [Path] the n-th last parent path
@@ -126,9 +125,9 @@ module Sycamore
         distance.is_a? Integer
 
       case distance
-        when 1 then @parent
-        when 0 then self
-        else parent.up(distance - 1)
+      when 1 then @parent
+      when 0 then self
+      else parent.up(distance - 1)
       end
     end
 
@@ -148,7 +147,7 @@ module Sycamore
       i
     end
 
-    alias size length
+    alias_method :size, :length
 
     ##
     # Iterates over all nodes on this path.
@@ -160,7 +159,7 @@ module Sycamore
     #   @return [Enumerator<node>]
     #
     def each_node(&block)
-      return enum_for(__callee__) unless block_given?
+      return enum_for(__callee__) unless block
 
       if @parent
         @parent.each_node(&block)
@@ -168,7 +167,7 @@ module Sycamore
       end
     end
 
-    alias each each_node
+    alias_method :each, :each_node
 
     ##
     # If a given structure contains this path.
@@ -184,18 +183,18 @@ module Sycamore
     def present_in?(struct)
       each do |node|
         case
-          when struct.is_a?(Enumerable)
-            return false unless struct.include? node
-            struct = (Tree.like?(struct) ? struct[node] : Nothing )
-          else
-            return false unless struct.eql? node
-            struct = Nothing
+        when struct.is_a?(Enumerable)
+          return false unless struct.include? node
+          struct = (Tree.like?(struct) ? struct[node] : Nothing)
+        else
+          return false unless struct.eql? node
+          struct = Nothing
         end
       end
       true
     end
 
-    alias in? present_in?
+    alias_method :in?, :present_in?
 
     ########################################################################
     # @group Equality
@@ -214,8 +213,8 @@ module Sycamore
     #
     def eql?(other)
       other.is_a?(self.class) and
-        self.length == other.length and begin
-          i = other.each ; all? { |node| node.eql? i.next }
+        length == other.length and begin
+          i = other.each; all? { |node| node.eql? i.next }
         end
     end
 
@@ -224,8 +223,8 @@ module Sycamore
     # @param other [Object]
     #
     def ==(other)
-      other.is_a?(Enumerable) and self.length == other.length and begin
-        i = other.each ; all? { |node| node == i.next }
+      other.is_a?(Enumerable) and length == other.length and begin
+        i = other.each; all? { |node| node == i.next }
       end
     end
 
@@ -244,7 +243,7 @@ module Sycamore
     #   Sycamore::Path[1,2,3].join       # => '/1/2/3'
     #   Sycamore::Path[1,2,3].join('|')  # => '|1|2|3'
     #
-    def join(separator = '/')
+    def join(separator = "/")
       @parent.join(separator) + separator + node.to_s
     end
 
@@ -259,8 +258,7 @@ module Sycamore
     # @return [String] a more verbose string representation of this path
     #
     def inspect
-      "#<Sycamore::Path[#{each_node.map(&:inspect).join(',')}]>"
+      "#<Sycamore::Path[#{each_node.map(&:inspect).join(",")}]>"
     end
   end
-
 end

data/lib/sycamore/path_root.rb

@@ -1,4 +1,4 @@
-require 'singleton'
+require "singleton"
 
 module Sycamore
   class Path
@@ -25,16 +25,16 @@ module Sycamore
         0
       end
 
-      def join(delimiter = '/')
-        ''
+      def join(delimiter = "/")
+        ""
       end
 
       def to_s
-        '#<Path:Root>'
+        "#<Path:Root>"
       end
 
       def inspect
-        '#<Sycamore::Path::Root>'
+        "#<Sycamore::Path::Root>"
       end
     end
 

data/lib/sycamore/stree.rb

@@ -1,4 +1,4 @@
-require 'sycamore'
+require "sycamore"
 
 # optional global shortcut constant for Sycamore::Tree
 STree = Sycamore::Tree

data/lib/sycamore/tree.rb

@@ -1,12 +1,10 @@
 module Sycamore
-
   ##
   # A tree data structure as a recursively nested set of {#nodes nodes} of immutable values.
   #
   # See {file:README.md} for a general introduction.
   #
   class Tree
-
     include Enumerable
 
     # the internal hash representation of this tree
@@ -19,11 +17,11 @@ module Sycamore
 
     # the names of all command methods, which add elements to a Tree
     ADDITIVE_COMMAND_METHODS = %i[add << replace add_node_with_empty_child
-       clear_child_of_node] << :[]=
+      clear_child_of_node] << :[]=
 
     # the names of all command methods, which delete elements from a Tree
     DESTRUCTIVE_COMMAND_METHODS = %i[delete >> clear compact replace
-        clear_child_of_node] << :[]=
+      clear_child_of_node] << :[]=
 
     # the names of all additive command methods, which only add elements from a Tree
     PURE_ADDITIVE_COMMAND_METHODS = ADDITIVE_COMMAND_METHODS - DESTRUCTIVE_COMMAND_METHODS
@@ -38,21 +36,21 @@ module Sycamore
     # the names of all query methods, which return a boolean
     PREDICATE_METHODS =
       %i[nothing? absent? existent? present? blank? empty?
-         include? include_node? member? key? has_key? include_path? path? >= > < <=
-         leaf? leaves? internal? external? flat? nested?
-         sleaf? sleaves? strict_leaf? strict_leaves?
-         eql? matches? === ==]
+        include? include_node? member? key? has_key? include_path? path? >= > < <=
+        leaf? leaves? internal? external? flat? nested?
+        sleaf? sleaves? strict_leaf? strict_leaves?
+        eql? matches? === ==]
 
     # the names of all methods, which side-effect-freeze return only a value
     QUERY_METHODS = PREDICATE_METHODS +
       %i[new_child dup hash to_native_object to_h to_s inspect
-         node node! nodes keys child_of child_at dig fetch fetch_path search
-         size total_size tsize height
-         each each_path paths each_node each_key each_pair] << :[]
+        node node! nodes keys child_of child_at dig fetch fetch_path search
+        size total_size tsize height
+        each each_path paths each_node each_key each_pair] << :[]
 
     %i[COMMAND_METHODS QUERY_METHODS PREDICATE_METHODS
-       ADDITIVE_COMMAND_METHODS DESTRUCTIVE_COMMAND_METHODS
-       PURE_ADDITIVE_COMMAND_METHODS PURE_DESTRUCTIVE_COMMAND_METHODS]
+      ADDITIVE_COMMAND_METHODS DESTRUCTIVE_COMMAND_METHODS
+      PURE_ADDITIVE_COMMAND_METHODS PURE_DESTRUCTIVE_COMMAND_METHODS]
       .each do |method_set|
         define_singleton_method(method_set.downcase) { const_get method_set }
       end
@@ -68,7 +66,7 @@ module Sycamore
     end
 
     protected def data
-      @data ||= Hash.new
+      @data ||= {}
     end
 
     protected def clear_data
@@ -89,13 +87,13 @@ module Sycamore
     #
     def self.with(*args)
       tree = new
-      tree.add( args.size == 1 ? args.first : args ) unless args.empty?
+      tree.add((args.size == 1) ? args.first : args) unless args.empty?
       tree
     end
 
     class << self
-      alias from with
-      alias [] with
+      alias_method :from, :with
+      alias_method :[], :with
     end
 
     ##
@@ -115,7 +113,6 @@ module Sycamore
       self.class.new(*args)
     end
 
-
     ########################################################################
     # @group Absence and Nothing predicates
     ########################################################################
@@ -144,7 +141,7 @@ module Sycamore
     # @return [Boolean]
     #
     def existent?
-      not absent?
+      !absent?
     end
 
     ##
@@ -157,10 +154,9 @@ module Sycamore
     # @return [Boolean]
     #
     def present?
-      not blank?
+      !blank?
     end
 
-
     ########################################################################
     # @group Element access
     ########################################################################
@@ -208,21 +204,24 @@ module Sycamore
     #   tree.to_h  # => {:foo=>{:bar=>[:baz, 1], :qux=>2}}
     #
     def add(nodes_or_tree)
-      case
-        when nodes_or_tree.equal?(Nothing) then # do nothing
-        when nodes_or_tree.is_a?(Tree)     then add_tree(nodes_or_tree)
-        when Tree.like?(nodes_or_tree)     then add_tree(valid_tree! nodes_or_tree)
-        when nodes_or_tree.is_a?(Path)     then add_path(nodes_or_tree)
-        when nodes_or_tree.is_a?(Enumerable)
-          nodes_or_tree.all? { |node| valid_node_element! node }
-          nodes_or_tree.each { |node| add(node) }
-        else add_node(nodes_or_tree)
+      if nodes_or_tree.equal?(Nothing) # do nothing
+      elsif nodes_or_tree.is_a?(Tree)
+        add_tree(nodes_or_tree)
+      elsif Tree.like?(nodes_or_tree)
+        add_tree(valid_tree!(nodes_or_tree))
+      elsif nodes_or_tree.is_a?(Path)
+        add_path(nodes_or_tree)
+      elsif nodes_or_tree.is_a?(Enumerable)
+        nodes_or_tree.all? { |node| valid_node_element! node }
+        nodes_or_tree.each { |node| add(node) }
+      else
+        add_node(nodes_or_tree)
       end
 
       self
     end
 
-    alias << add
+    alias_method :<<, :add
 
     protected def add_node(node)
       data[node] ||= Nothing
@@ -319,21 +318,23 @@ module Sycamore
     #   tree.to_h  # => {foo: :qux}
     #
     def delete(nodes_or_tree)
-      case
-        when nodes_or_tree.is_a?(Tree) then delete_tree(nodes_or_tree)
-        when Tree.like?(nodes_or_tree) then delete_tree(valid_tree! nodes_or_tree)
-        when nodes_or_tree.is_a?(Path) then delete_path(nodes_or_tree)
-        when nodes_or_tree.is_a?(Enumerable)
-          nodes_or_tree.all? { |node| valid_node_element! node }
-          nodes_or_tree.each { |node| delete node }
-        else
-          delete_node valid_node!(nodes_or_tree)
+      if nodes_or_tree.is_a?(Tree)
+        delete_tree(nodes_or_tree)
+      elsif Tree.like?(nodes_or_tree)
+        delete_tree(valid_tree!(nodes_or_tree))
+      elsif nodes_or_tree.is_a?(Path)
+        delete_path(nodes_or_tree)
+      elsif nodes_or_tree.is_a?(Enumerable)
+        nodes_or_tree.all? { |node| valid_node_element! node }
+        nodes_or_tree.each { |node| delete node }
+      else
+        delete_node valid_node!(nodes_or_tree)
       end
 
       self
     end
 
-    alias >> delete
+    alias_method :>>, :delete
 
     protected def delete_node(node)
       data.delete(node)
@@ -344,19 +345,19 @@ module Sycamore
     protected def delete_tree(tree)
       tree.each do |node_to_delete, child_to_delete|
         next unless include? node_to_delete
-        if Nothing.like?(child_to_delete) or
-            (child_to_delete.respond_to?(:empty?) and child_to_delete.empty?)
+        if Nothing.like?(child_to_delete) ||
+            (child_to_delete.respond_to?(:empty?) && child_to_delete.empty?)
           delete_node node_to_delete
         else
           fetch(node_to_delete, Nothing).tap do |child|
-            case
-              when child.empty? then next
-              when Tree.like?(child_to_delete)
-                child.delete_tree(child_to_delete)
-              when child_to_delete.is_a?(Enumerable)
-                child_to_delete.each { |node| child.delete_node node }
-              else
-                child.delete_node child_to_delete
+            if child.empty?
+              next
+            elsif Tree.like?(child_to_delete)
+              child.delete_tree(child_to_delete)
+            elsif child_to_delete.is_a?(Enumerable)
+              child_to_delete.each { |node| child.delete_node node }
+            else
+              child.delete_node child_to_delete
             end
             delete_node(node_to_delete) if child.empty?
           end
@@ -368,13 +369,13 @@ module Sycamore
 
     protected def delete_path(path)
       case path.length
-        when 0 then return self
-        when 1 then return delete_node(path.node)
+      when 0 then return self
+      when 1 then return delete_node(path.node)
       end
 
       parent = fetch_path(path.parent) { return self }
       parent.delete_node(path.node)
-      delete_path(path.parent) if parent.empty? and not path.parent.root?
+      delete_path(path.parent) if parent.empty? && !path.parent.root?
 
       self
     end
@@ -472,7 +473,7 @@ module Sycamore
     #
     def []=(*args)
       path, nodes_or_tree = args[0..-2], args[-1]
-      raise ArgumentError, 'wrong number of arguments (given 1, expected 2)' if path.empty?
+      raise ArgumentError, "wrong number of arguments (given 1, expected 2)" if path.empty?
 
       if Nothing.like? nodes_or_tree
         if path.size == 1
@@ -516,17 +517,19 @@ module Sycamore
     #   tree.to_h  # => {foo: :bar}
     #
     def compact
-      data.each do |node, child| case
-          when child.nothing? then next
-          when child.empty?   then clear_child_of_node(node)
-          else child.compact
+      data.each do |node, child|
+        if child.nothing?
+          next
+        elsif child.empty?
+          clear_child_of_node(node)
+        else
+          child.compact
         end
       end
 
       self
     end
 
-
     #####################
     #   query methods   #
     #####################
@@ -545,8 +548,7 @@ module Sycamore
       data.keys
     end
 
-    alias keys nodes  # Hash compatibility
-
+    alias_method :keys, :nodes  # Hash compatibility
 
     ##
     # The only node of this tree or an exception, if more {#nodes nodes} present.
@@ -587,7 +589,7 @@ module Sycamore
     # @see Tree#node
     #
     def node!
-      raise EmptyNodeSet, 'no node present' if empty?
+      raise EmptyNodeSet, "no node present" if empty?
       node
     end
 
@@ -640,21 +642,21 @@ module Sycamore
     def child_at(*path)
       first = path.first
       case path.length
-        when 0
-          raise ArgumentError, 'wrong number of arguments (given 0, expected 1+)'
-        when 1
-          if first.is_a? Enumerable
-            child_at(*first)
-          else
-            child_of(*path)
-          end
+      when 0
+        raise ArgumentError, "wrong number of arguments (given 0, expected 1+)"
+      when 1
+        if first.is_a? Enumerable
+          child_at(*first)
         else
-          child_of(first).child_at(*path[1..-1])
+          child_of(*path)
+        end
+      else
+        child_of(first).child_at(*path[1..])
       end
     end
 
-    alias [] child_at
-    alias dig child_at  # Hash compatibility
+    alias_method :[], :child_at
+    alias_method :dig, :child_at  # Hash compatibility
 
     ##
     # The child tree of a node.
@@ -693,10 +695,12 @@ module Sycamore
 
       child = data.fetch(node, *default, &block)
       if child.equal? Nothing
-        child = case
-          when block_given?    then yield
-          when !default.empty? then default.first
-          else raise ChildError, "node #{node.inspect} has no child tree"
+        child = if block
+          yield
+        elsif !default.empty?
+          default.first
+        else
+          raise ChildError, "node #{node.inspect} has no child tree"
         end
       end
 
@@ -727,10 +731,10 @@ module Sycamore
     #   tree.fetch_path([:foo, :bar, :baz], :default)  # => :default
     #
     def fetch_path(path, *default, &block)
-      default_case = block_given? || !default.empty?
+      default_case = block || !default.empty?
       path.inject(self) do |tree, node|
         if default_case
-          tree.fetch(node) { return block_given? ? yield : default.first }
+          tree.fetch(node) { return block ? yield : default.first }
         else
           tree.fetch(node)
         end
@@ -759,14 +763,14 @@ module Sycamore
     #   > b
     #
     def each_node(&block)
-      return enum_for(__callee__) unless block_given?
+      return enum_for(__callee__) unless block
 
       data.each_key(&block)
 
       self
     end
 
-    alias each_key each_node  # Hash compatibility
+    alias_method :each_key, :each_node  # Hash compatibility
 
     ##
     # Iterates over all {#nodes nodes} and their child trees.
@@ -788,14 +792,14 @@ module Sycamore
     #   > b => #<Tree: Nothing>
     #
     def each_pair(&block)
-      return enum_for(__callee__) unless block_given?
+      return enum_for(__callee__) unless block
 
       data.each_pair(&block)
 
       self
     end
 
-    alias each each_pair
+    alias_method :each, :each_pair
 
     ##
     # Iterates over the {Path paths} to all leaves of this tree.
@@ -818,7 +822,7 @@ module Sycamore
     #   > #<Path: /b/foo/baz>
     #
     def each_path(with_ancestor: Path::ROOT, &block)
-      return enum_for(__callee__) unless block_given?
+      return enum_for(__callee__) unless block
 
       each do |node, child|
         if child.empty?
@@ -831,7 +835,7 @@ module Sycamore
       self
     end
 
-    alias paths each_path
+    alias_method :paths, :each_path
 
     ##
     # Checks if a path of nodes exists in this tree.
@@ -848,9 +852,9 @@ module Sycamore
     #
     def include_path?(*args)
       case args.count
-        when 0 then raise ArgumentError, 'wrong number of arguments (given 0, expected 1+)'
-        when 1 then path = args.first
-               else return include_path?(args)
+      when 0 then raise ArgumentError, "wrong number of arguments (given 0, expected 1+)"
+      when 1 then path = args.first
+      else return include_path?(args)
       end
       path = [path] unless path.is_a? Enumerable
 
@@ -861,7 +865,7 @@ module Sycamore
       end
     end
 
-    alias path? include_path?
+    alias_method :path?, :include_path?
 
     ##
     # Checks if a node exists in the {#nodes nodes} set of this tree.
@@ -880,9 +884,9 @@ module Sycamore
       data.include?(node)
     end
 
-    alias member?  include_node?  # Hash compatibility
-    alias has_key? include_node?  # Hash compatibility
-    alias key?     include_node?  # Hash compatibility
+    alias_method :member?, :include_node?  # Hash compatibility
+    alias_method :has_key?, :include_node?  # Hash compatibility
+    alias_method :key?, :include_node?  # Hash compatibility
 
     ##
     # Checks if some nodes or a full tree-like structure is included in this tree.
@@ -899,24 +903,23 @@ module Sycamore
     #   tree.include?("a", "b" => 200)     # => true
     #
     def include?(*elements)
-      raise ArgumentError, 'wrong number of arguments (given 0, expected 1+)' if
+      raise ArgumentError, "wrong number of arguments (given 0, expected 1+)" if
         elements.size == 0
       return elements.all? { |element| include? element } if
         elements.size > 1
 
       elements = elements.first
-      case
-        when Tree.like?(elements)
-          elements.all? do |node, child|
-            include_node?(node) and ( child.nil? or child.equal?(Nothing) or
-                                        self.child_of(node).include?(child) )
-          end
-        when elements.is_a?(Path)
-          include_path? elements
-        when elements.is_a?(Enumerable)
-          elements.all? { |element| include_node? element }
-        else
-          include_node? elements
+      if Tree.like?(elements)
+        elements.all? do |node, child|
+          include_node?(node) and (child.nil? or child.equal?(Nothing) or
+                                      child_of(node).include?(child))
+        end
+      elsif elements.is_a?(Path)
+        include_path? elements
+      elsif elements.is_a?(Enumerable)
+        elements.all? { |element| include_node? element }
+      else
+        include_node? elements
       end
     end
 
@@ -941,7 +944,7 @@ module Sycamore
     protected def _search(query, current_path: Path::ROOT, results: [])
       results << current_path if include?(query)
       each do |node, child|
-        child._search(query, current_path: current_path/node, results: results)
+        child._search(query, current_path: current_path / node, results: results)
       end
       results
     end
@@ -982,7 +985,7 @@ module Sycamore
       total
     end
 
-    alias tsize total_size
+    alias_method :tsize, :total_size
 
     ##
     # The length of the longest path of this tree.
@@ -1011,7 +1014,7 @@ module Sycamore
       data.empty?
     end
 
-    alias blank? empty?
+    alias_method :blank?, :empty?
 
     ##
     # Checks if the given node has no children.
@@ -1047,7 +1050,7 @@ module Sycamore
       include_node?(node) && child_at(node).absent?
     end
 
-    alias sleaf? strict_leaf?
+    alias_method :sleaf?, :strict_leaf?
 
     ##
     # Checks if all given nodes or that of the tree have no children, even not an empty child tree.
@@ -1076,7 +1079,7 @@ module Sycamore
       nodes.all? { |node| strict_leaf?(node) }
     end
 
-    alias sleaves? strict_leaves?
+    alias_method :sleaves?, :strict_leaves?
 
     ##
     # Checks if all given nodes or that of the tree have no children.
@@ -1105,8 +1108,8 @@ module Sycamore
       nodes.all? { |node| leaf?(node) }
     end
 
-    alias leaves? external?
-    alias flat? external?
+    alias_method :leaves?, :external?
+    alias_method :flat?, :external?
 
     ##
     # Checks if all given nodes or that of the tree have children.
@@ -1134,14 +1137,13 @@ module Sycamore
     #   One would expect it to be the negation of #external? without arguments.
     #
     def internal?(*nodes)
-      return false if self.empty?
+      return false if empty?
       nodes = self.nodes if nodes.empty?
 
-      nodes.all? { |node| not leaf?(node) and include_node?(node) }
+      nodes.all? { |node| !leaf?(node) and include_node?(node) }
     end
 
-    alias nested? internal?
-
+    alias_method :nested?, :internal?
 
     ########################################################################
     # @group Comparison
@@ -1246,7 +1248,7 @@ module Sycamore
     #   tree1 >= tree1  # => true
     #
     def >=(other)
-      (other.is_a?(Tree) or other.is_a?(Absence)) and self.include?(other)
+      (other.is_a?(Tree) or other.is_a?(Absence)) and include?(other)
     end
 
     ##
@@ -1263,7 +1265,7 @@ module Sycamore
     #   tree1 > tree1  # => false
     #
     def >(other)
-      (other.is_a?(Tree) or other.is_a?(Absence)) and self.include?(other) and self != other
+      (other.is_a?(Tree) or other.is_a?(Absence)) and include?(other) and self != other
     end
 
     ##
@@ -1281,17 +1283,19 @@ module Sycamore
     #   Problem: Requires a solution which doesn't use +Hash#include?+.
     #
     def matches?(other)
-      case
-        when Tree.like?(other)       then matches_tree?(other)
-        when other.is_a?(Enumerable) then matches_enumerable?(other)
-                                     else matches_atom?(other)
+      if Tree.like?(other)
+        matches_tree?(other)
+      elsif other.is_a?(Enumerable)
+        matches_enumerable?(other)
+      else
+        matches_atom?(other)
       end
     end
 
-    alias === matches?
+    alias_method :===, :matches?
 
     private def matches_atom?(other)
-      not other.nil? and (size == 1 and nodes.first == other and leaf? other)
+      !other.nil? and (size == 1 and nodes.first == other and leaf? other)
     end
 
     private def matches_enumerable?(other)
@@ -1304,15 +1308,15 @@ module Sycamore
         all? { |node, child|
           if child.nothing?
             other.include?(node) and begin other_child = other.fetch(node, nil)
-              not other_child or
-                (other_child.respond_to?(:empty?) and other_child.empty?)
+                                           !other_child or
+                                             (other_child.respond_to?(:empty?) and other_child.empty?)
             end
           else
             child.matches? other[node]
-          end }
+          end
+        }
     end
 
-
     ########################################################################
     # @group Conversion
     ########################################################################
@@ -1325,13 +1329,12 @@ module Sycamore
     # @api private
     #
     def to_native_object(sleaf_child_as: nil, special_nil: false)
-      case
-        when empty?
-          []
-        when strict_leaves?
-          size == 1 && (!special_nil || !nodes.first.nil?) ? nodes.first : nodes
-        else
-          to_h(sleaf_child_as: sleaf_child_as, special_nil: special_nil)
+      if empty?
+        []
+      elsif strict_leaves?
+        (size == 1 && (!special_nil || !nodes.first.nil?)) ? nodes.first : nodes
+      else
+        to_h(sleaf_child_as: sleaf_child_as, special_nil: special_nil)
       end
     end
 
@@ -1392,12 +1395,11 @@ module Sycamore
     #
     private def valid_node_element!(node)
       raise InvalidNode, "#{node} is not a valid tree node" if
-        node.is_a?(Enumerable) and not node.is_a?(Path) and not Tree.like?(node)
+        node.is_a?(Enumerable) && !node.is_a?(Path) && !Tree.like?(node)
 
       node
     end
 
-
     # @api private
     #
     private def valid_node!(node)
@@ -1420,15 +1422,15 @@ module Sycamore
     #
     def self.tree_like?(object)
       case object
-        when Hash, Tree, Absence # ... ?!
-          true
-        else
-          (object.respond_to? :tree_like? and object.tree_like?) # or ...
+      when Hash, Tree, Absence # ... ?!
+        true
+      else
+        (object.respond_to? :tree_like? and object.tree_like?) # or ...
       end
     end
 
     class << self
-      alias like? tree_like?
+      alias_method :like?, :tree_like?
     end
 
     ########################################################################
@@ -1441,8 +1443,7 @@ module Sycamore
     # @return [Tree]
     #
     def dup
-      duplicate = self.class.new.add(self)
-      duplicate
+      self.class.new.add(self)
     end
 
     ##
@@ -1464,6 +1465,5 @@ module Sycamore
       each { |_, child| child.freeze }
       super
     end
-
   end  # Tree
 end  # Sycamore

data/lib/sycamore/version.rb

@@ -2,27 +2,33 @@ module Sycamore
   # version representation
   module VERSION
     # the file containing the project version number
-    FILE = File.expand_path('../../../VERSION', __FILE__)
-    MAJOR, MINOR, TINY, EXTRA = File.read(FILE).chomp.split('.')
+    FILE = File.expand_path("../../../VERSION", __FILE__)
+    MAJOR, MINOR, TINY, EXTRA = File.read(FILE).chomp.split(".")
     # the normalized version string
-    STRING = [MAJOR, MINOR, TINY, EXTRA].compact.join('.').freeze
+    STRING = [MAJOR, MINOR, TINY, EXTRA].compact.join(".").freeze
 
     ##
     # @return [String]
-    def self.to_s() STRING end
+    def self.to_s
+      STRING
+    end
 
     ##
     # @return [String]
-    def self.to_str() STRING end
+    def self.to_str
+      STRING
+    end
 
     ##
     # @return [Array(Integer, Integer, Integer)]
-    def self.to_a() [MAJOR, MINOR, TINY] end
+    def self.to_a
+      [MAJOR, MINOR, TINY]
+    end
 
     ##
     # @return [Boolean]
     def self.==(other)
-      other == self.to_s
+      other == to_s
     end
   end
 end

data/lib/sycamore.rb

@@ -1,10 +1,10 @@
-require 'sycamore/version'
-require 'sycamore/exceptions'
-require 'sycamore/path'
-require 'sycamore/path_root'
-require 'sycamore/tree'
-require 'sycamore/nothing'
-require 'sycamore/absence'
+require "sycamore/version"
+require "sycamore/exceptions"
+require "sycamore/path"
+require "sycamore/path_root"
+require "sycamore/tree"
+require "sycamore/nothing"
+require "sycamore/absence"
 
 ##
 # see README.md

data/support/doctest_helper.rb

@@ -1,2 +1,2 @@
-$LOAD_PATH << 'lib'
-require 'sycamore/extension'
+$LOAD_PATH << "lib"
+require "sycamore/extension"

data/sycamore.gemspec

@@ -1,29 +1,28 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'sycamore/version'
+require "sycamore/version"
 
 Gem::Specification.new do |spec|
-  spec.name          = 'metaractor-sycamore'
-  spec.version       = Sycamore::VERSION
-  spec.authors       = ['Marcel Otto', 'Ryan Schlesinger']
-  spec.email         = ['ryan@ryanschlesinger.com']
+  spec.name = "metaractor-sycamore"
+  spec.version = Sycamore::VERSION
+  spec.authors = ["Marcel Otto", "Ryan Schlesinger"]
+  spec.email = ["ryan@ryanschlesinger.com"]
 
-  spec.summary       = %q{An unordered tree data structure for Ruby.}
-  spec.description   = %q{Sycamore is an unordered tree data structure.}
-  spec.homepage      = 'https://github.com/metaractor/sycamore'
-  spec.license       = 'MIT'
+  spec.summary = "An unordered tree data structure for Ruby."
+  spec.description = "Sycamore is an unordered tree data structure."
+  spec.homepage = "https://github.com/metaractor/sycamore"
+  spec.license = "MIT"
 
-  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  spec.bindir        = 'exe'
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ['lib']
+  spec.files = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
 
-  spec.required_ruby_version = '>= 2.7'
+  spec.required_ruby_version = ">= 2.7"
 
-  spec.add_development_dependency 'bundler', '~> 2'
-  spec.add_development_dependency 'rake', '~> 13.0'
-  spec.add_development_dependency 'rspec', '~> 3.11'
-  spec.add_development_dependency 'yard', '~> 0.9'
-  spec.add_development_dependency 'yard-doctest', '0.1.7'
+  spec.add_development_dependency "bundler", "~> 2"
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "rspec", "~> 3.11"
+  spec.add_development_dependency "yard", "~> 0.9"
+  spec.add_development_dependency "yard-doctest", "0.1.7"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: metaractor-sycamore
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.4.3
 platform: ruby
 authors:
 - Marcel Otto