sycamore 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 17dce2903bbad75bfd5c528662e0857d2505cf1f
-  data.tar.gz: b0314f85b8c211cc3fe324dfd304c14e07c96bcb
+  metadata.gz: a9ca22a9fa8a7caafbbce1f4a166ff6a43780493
+  data.tar.gz: ed6fa35d1e3bdef4d41d3642153437755dc0d708
 SHA512:
-  metadata.gz: 008f0f0f027983a40aed89c98af2726711ab7297af755f3894e7b82d8e7b5e84154dfa318add0d27aa51ca56f4d28e66767fca8e0acf6419064f861d20efa0fc
-  data.tar.gz: e4c7b8096a0aad94b6702747c1fd26e7efa09102ec10c3d14b63672f89bca237cb88d9119439a03c5d10eada7f42714d699bd00653fc62a637419edbd9cbb3fa
+  metadata.gz: 55180ebbfd457ba351a0ad933bcf5064e3de0efa9bb032bcc0c8bf4e9493abe108ad2a40d2de82a584beadc57973b92ffb9027aabbb84bd8a6a070de55cab77d
+  data.tar.gz: ac5e395633685242d42b6b3710441274425266ecaa2246298c6434146b65df1e2993bc5ad9de266f1d9e94dd9c193fa8be12dfe416b079192932cb4efe5f5ac4

data/.travis.yml

@@ -8,3 +8,5 @@ rvm:
 cache: bundler
 before_install:
   - gem update bundler
+before_script:
+  - support/travis.sh

data/.yardopts

@@ -8,4 +8,6 @@
 AUTHORS
 CREDITS
 LICENSE.txt
+CHANGELOG.md
+CONTRIBUTING.md
 VERSION

data/CHANGELOG.md

@@ -5,11 +5,38 @@ This project adheres to [Semantic Versioning](http://semver.org/) and
 [Keep a CHANGELOG](http://keepachangelog.com).
 
 
-## [Unreleased]
+## 0.3.0 - 2016-04-23
 
+### Added
+
+- support `Path` objects as input on the following `Tree` methods:
+  - the `Tree.[]` population constructor
+  - `fetch`
+  - `add` 
+  - `delete`
+  - `replace`
+  - `[]=`
+  - `include_node?`
+  - `leaf?`
+  - `strict_leaf?`
+  - `strict_leaves?`
+  - `internal?`
+  - `external?`
+- `Tree#fetch_path` for fetching a child by path 
+
+### Fixed
+
+- `Tree#add` or `Tree#delete` now fail without making any changes, when given 
+  invalid input. Previously these command methods performed their operations  
+  until the invalid input elements were encountered.
+- `Tree#delete` deleted paths, when they matched a given input path partially,
+  e.g. `Tree[a: 1] >> a: {1 => 2}` deleted successfully.
+
+[Compare v0.2.1...v0.3.0](https://github.com/marcelotto/sycamore/compare/v0.2.1...v0.3.0)
 
 
-## [0.2.1] - 2016-04-07
+
+## 0.2.1 - 2016-04-07
 
 ### Added
 
@@ -18,11 +45,13 @@ This project adheres to [Semantic Versioning](http://semver.org/) and
 
 ### Fixed
 
-- #2: Rubinius support
+- [#2](https://github.com/marcelotto/sycamore/issues/2): Rubinius support
+
+[Compare v0.2.0...v0.2.1](https://github.com/marcelotto/sycamore/compare/v0.2.0...v0.2.1)
 
 
 
-## [0.2.0] - 2016-04-05
+## 0.2.0 - 2016-04-05
 
 ### Added
 
@@ -31,13 +60,10 @@ This project adheres to [Semantic Versioning](http://semver.org/) and
 - `Tree#node!` as a more strict variant of `Tree#node`, which raises an error 
   when no node present
 
+[Compare v0.1.0...v0.2.0](https://github.com/marcelotto/sycamore/compare/v0.1.0...v0.2.0)
+
 
 
 ## 0.1.0 - 2016-03-28
 
 Initial release
-
-
-[Unreleased]: https://github.com/marcelotto/sycamore/compare/v0.2.1...HEAD
-[0.2.1]: https://github.com/marcelotto/sycamore/compare/v0.2.0...v0.2.1
-[0.2.0]: https://github.com/marcelotto/sycamore/compare/v0.1.0...v0.2.0

data/Gemfile

@@ -2,6 +2,12 @@ source 'https://rubygems.org'
 
 gemspec
 
+group :development do
+  gem 'guard-rspec'
+  gem 'listen', '< 3.1' # to circumvent the fail for Ruby 2.1 and Rubinius
+  gem 'pry'
+end
+
 group :test do
-  gem 'coveralls',  require: false, platform: :mri
+  gem 'coveralls', require: false, platform: :mri
 end

data/README.md

@@ -198,6 +198,15 @@ tree.fetch(:z) { :default }  # => :default
 
 Fetching the child of a leaf behaves almost the same as fetching the child of a non-existing node, i.e. the default value is returned or a `KeyError` gets raised. In order to differentiate these cases, a `Sycamore::ChildError` as a subclass of `KeyError` is raised when accessing the child of a leaf.
 
+`fetch_path` allows a `dig` similar access with `fetch` semantics, except it requires the path of nodes to be given as an Enumerable.
+
+```ruby
+tree.fetch_path([:y, 2]).node  # => "a"
+tree.fetch_path([:y, 3])               # => KeyError: key not found: 3
+tree.fetch_path([:y, 3], :default)     # => :default
+tree.fetch_path([:y, 3]) { :default }  # => :default
+```
+
 The number of nodes of a tree can be determined with `size`. This will only count direct nodes.
 
 ```ruby
@@ -543,6 +552,8 @@ If you search for multiple nodes, only the paths to child trees containing all o
 tree.search [:b, :c]  # => [#<Sycamore::Path[3]>]
 ```
 
+All `Tree` methods for which it makes sense accept path objects as input instead or in combination with nodes or tree structures. This allows it to apply the search results to any of these methods.
+
 
 ## Getting help
 

data/VERSION

@@ -1 +1 @@
-0.2.1
+0.3.0

data/bin/console

@@ -1,9 +1,7 @@
 #!/usr/bin/env ruby
 
 require 'bundler/setup'
-require 'sycamore'
+require 'sycamore/extension'
 
 require 'pry'
 Pry.start
-
-include Sycamore # TODO: require 'sycamore/extension'

data/lib/sycamore/tree.rb

@@ -46,7 +46,7 @@ module Sycamore
     # 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 search
+         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] << :[]
 
@@ -177,6 +177,10 @@ module Sycamore
     #   adds a tree structure of nodes
     #   @param tree_structure [Hash, Tree]
     #
+    # @overload add(path)
+    #   adds a {Path} of nodes
+    #   @param path [Path]
+    #
     # @return +self+ as a proper command method
     #
     # @raise [InvalidNode] when given a nested node set
@@ -186,21 +190,26 @@ module Sycamore
     #   tree.add :foo
     #   tree.add [:bar, :baz]
     #   tree.add [:node, [:nested, :values]]  # => raise Sycamore::InvalidNode, "[:nested, :values] is not a valid tree node"
-    #   tree.add foo: 1, bar: {baz: 2}
+    #   tree.add foo: 1, bar: {qux: 2}
     #   tree.add foo: [:node, [:nested, :values]]  # => raise Sycamore::InvalidNode, "[:nested, :values] is not a valid tree node"
+    #   tree.add Sycamore::Path[1,2,3]
+    #   tree.to_h  # => {:foo=>1, :bar=>{:qux=>2}, :baz=>nil, 1=>{2=>3}}
     #
     #   tree = Tree.new
     #   tree[:foo][:bar] << :baz
     #   tree[:foo] << { bar: 1, qux: 2 }
     #   tree.to_h  # => {:foo=>{:bar=>[:baz, 1], :qux=>2}}
     #
-    # @todo support Paths
-    #
     def add(nodes_or_tree)
       case
-        when Tree.like?(nodes_or_tree)       then add_tree(nodes_or_tree)
-        when nodes_or_tree.is_a?(Enumerable) then add_nodes(nodes_or_tree)
-                                             else add_node(nodes_or_tree)
+        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)
       end
 
       self
@@ -208,18 +217,17 @@ module Sycamore
 
     alias << add
 
-    private def add_node(node)
-      return self if node.equal? Nothing
-      return add_tree(node) if Tree.like? node
-      raise InvalidNode, "#{node} is not a valid tree node" if node.is_a? Enumerable
-
+    protected def add_node(node)
       @data[node] ||= Nothing
 
       self
     end
 
-    private def add_nodes(nodes)
-      nodes.each { |node| add_node(node) }
+    ##
+    # @api private
+    #
+    def clear_child_of_node(node)
+      @data[valid_node! node] = Nothing
 
       self
     end
@@ -228,7 +236,7 @@ module Sycamore
     # @api private
     #
     def add_node_with_empty_child(node)
-      raise InvalidNode, "#{node} is not a valid tree node" if node.is_a? Enumerable
+      valid_node! node
 
       if @data.fetch(node, Nothing).nothing?
         @data[node] = new_child(node)
@@ -237,17 +245,6 @@ module Sycamore
       self
     end
 
-    ##
-    # @api private
-    #
-    def clear_child_of_node(node)
-      raise InvalidNode, "#{node} is not a valid tree node" if node.is_a? Enumerable
-
-      @data[node] = Nothing
-
-      self
-    end
-
     private def add_child(node, children)
       return add_node(node) if Nothing.like?(children)
 
@@ -263,6 +260,17 @@ module Sycamore
       self
     end
 
+    private def add_path(path)
+      return self if path.root?
+
+      path.parent.inject(self) { |tree, node| # using a {} block to circumvent this Rubinius issue: https://github.com/rubinius/rubinius-code/issues/7
+        tree.add_node_with_empty_child(node)
+        tree[node]
+      }.add_node path.node
+
+      self
+    end
+
     ##
     # Remove nodes or a tree structure from this tree.
     #
@@ -281,6 +289,10 @@ module Sycamore
     #   deletes a tree structure of nodes
     #   @param tree_structure [Hash, Tree]
     #
+    # @overload delete(path)
+    #   deletes a {Path} of nodes
+    #   @param path [Path]
+    #
     # @return +self+ as a proper command method
     #
     # @raise [InvalidNode] when given a nested node set
@@ -295,14 +307,20 @@ module Sycamore
     #   tree.to_h  # => {"d" => {foo: :baz}}
     #   tree.delete "d" => {foo: :baz}
     #   tree.to_h  # => {}
-    #
-    # @todo support Paths
+    #   tree = Tree[foo: {bar: :baz, qux: nil}]
+    #   tree.delete Sycamore::Path[:foo, :bar, :baz]
+    #   tree.to_h  # => {foo: :qux}
     #
     def delete(nodes_or_tree)
       case
-        when Tree.like?(nodes_or_tree)       then delete_tree(nodes_or_tree)
-        when nodes_or_tree.is_a?(Enumerable) then delete_nodes(nodes_or_tree)
-                                             else delete_node(nodes_or_tree)
+        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)
       end
 
       self
@@ -310,31 +328,30 @@ module Sycamore
 
     alias >> delete
 
-    private def delete_node(node)
-      return delete_tree(node) if Tree.like? node
-      raise InvalidNode, "#{node} is not a valid tree node" if node.is_a? Enumerable
-
+    protected def delete_node(node)
       @data.delete(node)
 
       self
     end
 
-    private def delete_nodes(nodes)
-      nodes.each { |node| delete_node(node) }
-
-      self
-    end
-
-    private def delete_tree(tree)
-      tree.each { |node, child| # using a {} block to circumvent this Rubinius issue: https://github.com/rubinius/rubinius-code/issues/7
-        raise InvalidNode, "#{node} is not a valid tree node" if node.is_a? Enumerable
-        next unless include? node
-        if Nothing.like?(child) or (child.respond_to?(:empty?) and child.empty?)
-          delete_node node
+    protected def delete_tree(tree)
+      tree.each { |node_to_delete, child_to_delete| # using a {} block to circumvent this Rubinius issue: https://github.com/rubinius/rubinius-code/issues/7
+        next unless include? node_to_delete
+        if Nothing.like?(child_to_delete) or
+            (child_to_delete.respond_to?(:empty?) and child_to_delete.empty?)
+          delete_node node_to_delete
         else
-          child_of(node).tap do |this_child|
-            this_child.delete child
-            delete_node(node) if this_child.empty?
+          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
+            end
+            delete_node(node_to_delete) if child.empty?
           end
         end
       }
@@ -342,6 +359,19 @@ module Sycamore
       self
     end
 
+    protected def delete_path(path)
+      case path.length
+        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?
+
+      self
+    end
+
     ##
     # Replaces the contents of this tree.
     #
@@ -357,6 +387,10 @@ module Sycamore
     #   Replaces the contents of this tree with a tree structure of nodes.
     #   @param tree_structure [Hash, Tree]
     #
+    # @overload replace(path)
+    #   Replaces the contents of this tree with a path of nodes.
+    #   @param path [Path]
+    #
     # @return +self+ as a proper command method
     #
     # @raise [InvalidNode] when given a nested node set
@@ -402,6 +436,11 @@ module Sycamore
     #   @param path [Array<Object>, Sycamore::Path] a path as a sequence of nodes or a {Path} object
     #   @param tree_structure [Hash, Tree]
     #
+    # @overload []=(*path, another_object)
+    #   Replaces the contents of the child at the given path with another path of nodes.
+    #   @param path [Array<Object>, Sycamore::Path] a path as a sequence of nodes or a {Path} object
+    #   @param path_object [Path]
+    #
     # @return the rvalue as for any Ruby assignment
     #
     # @raise [InvalidNode] when given a nested node set
@@ -419,8 +458,10 @@ module Sycamore
     #   tree.to_h  # => {:foo => :baz, 1 => :baz}
     #   tree[:foo] << :bar
     #   tree.to_h  # => {:foo => [:baz, :bar], 1 => :baz}
+    #   tree[1] = Sycamore::Path[2,3]
+    #   tree.to_h  # => {:foo => [:baz, :bar], 1 => {2 => 3}}
     #   tree[:foo] = Sycamore::Nothing
-    #   tree.to_h  # => {:foo => nil, 1 => :baz}
+    #   tree.to_h  # => {:foo => nil, 1 => {2 => 3}}
     #
     def []=(*args)
       path, nodes_or_tree = args[0..-2], args[-1]
@@ -562,7 +603,7 @@ module Sycamore
     # @todo Should we differentiate the case of a leaf and a not present node? How?
     #
     def child_of(node)
-      raise InvalidNode, "#{node} is not a valid tree node" if node.is_a? Enumerable
+      valid_node! node
 
       Nothing.like?(child = @data[node]) ? Absence.at(self, node) : child
     end
@@ -618,7 +659,7 @@ module Sycamore
     # - if +default+ is given, then that will be returned;
     # - if the optional code block is specified, then that will be run and its result returned.
     #
-    # @param node [Object]
+    # @param node [Object, Path]
     # @param default [Object] optional
     # @return [Tree, default]
     #
@@ -627,31 +668,68 @@ module Sycamore
     # @raise [ChildError] when no child for the given +node+ present
     #
     # @example
-    #   tree = Tree[x: 1, y: nil]
+    #   tree = Tree[x: 1, y: nil, foo: {bar: :baz}]
     #   tree.fetch(:x)               # #<Sycamore::Tree:0x3fc798a63854(1)>
-    #   tree.fetch(:y)               # => raise Sycamore::ChildError, "node y has no child tree"
+    #   tree.fetch(:y)               # => raise Sycamore::ChildError, "node :y has no child tree"
     #   tree.fetch(:z)               # => raise KeyError, "key not found: :z"
     #   tree.fetch(:z, :default)     # => :default
     #   tree.fetch(:y, :default)     # => :default
     #   tree.fetch(:z) { :default }  # => :default
+    #   tree.fetch(Sycamore::Path[:foo, :bar]).nodes          # => [:baz]
+    #   tree.fetch(Sycamore::Path[:foo, :missing], :default)  # => :default
     #
     # @todo Should we differentiate the case of a leaf and a not present node? How?
     #
     def fetch(node, *default, &block)
-      raise InvalidNode, "#{node} is not a valid tree node" if node.is_a? Enumerable
+      return fetch_path(node, *default, &block) if node.is_a? Path
+      valid_node! node
 
       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} has no child tree"
+          else raise ChildError, "node #{node.inspect} has no child tree"
         end
       end
 
       child
     end
 
+    ##
+    # The child tree of a node at a path.
+    #
+    # If the node at the given path can’t be found or has no child tree, it
+    # behaves like {#fetch}.
+    #
+    # @param path [Array<Object>, Path]
+    # @param default [Object] optional
+    # @return [Tree, default]
+    #
+    # @raise [InvalidNode] when given an +Enumerable+ as node
+    # @raise [KeyError] when the given +node+ can't be found
+    # @raise [ChildError] when no child for the given +node+ present
+    #
+    # @example
+    #   tree = Tree[foo: {bar: :baz}]
+    #   tree.fetch_path([:foo, :bar]).nodes  # => [:baz]
+    #   tree.fetch_path [:foo, :bar, :baz]   # => raise Sycamore::ChildError, "node :baz has no child tree"
+    #   tree.fetch_path [:foo, :qux]         # => raise KeyError, "key not found: :qux"
+    #   tree.fetch_path([:a, :b], :default)            # => :default
+    #   tree.fetch_path([:a, :b]) { :default }         # => :default
+    #   tree.fetch_path([:foo, :bar, :baz], :default)  # => :default
+    #
+    def fetch_path(path, *default, &block)
+      default_case = block_given? || !default.empty?
+      path.inject(self) do |tree, node|
+        if default_case
+          tree.fetch(node) { return block_given? ? yield : default.first }
+        else
+          tree.fetch(node)
+        end
+      end
+    end
+
     ##
     # Iterates over all {#nodes nodes} of this tree.
     #
@@ -762,17 +840,17 @@ module Sycamore
     #   tree.include_path? Sycamore::Path["c", :foo, :bar]  # => true
     #
     def include_path?(*args)
-      raise ArgumentError, 'wrong number of arguments (given 0, expected 1+)' if args.count == 0
-      first = args.first
-      if first.is_a? Enumerable
-        return include_path?(*first) if args.count == 1
-        raise InvalidNode, "#{first} is not a valid tree node"
+      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)
       end
+      path = [path] unless path.is_a? Enumerable
 
-      if args.count == 1
-        include? first
+      if path.is_a? Path
+        fetch_path(path.parent) { return false }.include? path.node
       else
-        include?(first) and child_of(first).include_path?(args[1..-1])
+        fetch_path(path[0..-2]) { return false }.include? path.last
       end
     end
 
@@ -781,14 +859,17 @@ module Sycamore
     ##
     # Checks if a node exists in the {#nodes nodes} set of this tree.
     #
-    # @param node [Object]
+    # @param node [Object, Path]
     # @return [Boolean]
     #
     # @example
     #  Tree[1,2,3].include_node? 3   # => true
     #  Tree[1 => 2].include_node? 2  # => false
+    #  Tree[1 => 2].include_node? Sycamore::Path[1,2]  # => true
     #
     def include_node?(node)
+      return include_path?(node) if node.is_a? Path
+
       @data.include?(node)
     end
 
@@ -928,7 +1009,7 @@ module Sycamore
     ##
     # Checks if the given node has no children.
     #
-    # @param node [Object]
+    # @param node [Object, Path]
     # @return [Boolean]
     #
     # @example
@@ -936,9 +1017,10 @@ module Sycamore
     #   tree.leaf?(:x)  # => false
     #   tree.leaf?(:y)  # => true
     #   tree.leaf?(:z)  # => true
+    #   tree.leaf?(Sycamore::Path[:x, 1])  # => true
     #
     def leaf?(node)
-      include_node?(node) && child_of(node).empty?
+      include_node?(node) && child_at(node).empty?
     end
 
     ##
@@ -952,9 +1034,10 @@ module Sycamore
     #   tree.strict_leaf?(:x)  # => false
     #   tree.strict_leaf?(:y)  # => false
     #   tree.strict_leaf?(:z)  # => true
+    #   tree.strict_leaf?(Sycamore::Path[:x, 1])  # => true
     #
     def strict_leaf?(node)
-      include_node?(node) && child_of(node).absent?
+      include_node?(node) && child_at(node).absent?
     end
 
     alias sleaf? strict_leaf?
@@ -968,15 +1051,17 @@ module Sycamore
     #
     # @overload strict_leaves?(*nodes)
     #   Checks if all of the given nodes have no children, even not an empty child tree.
-    #   @param nodes [Array<Object>] splat of nodes
+    #   @param nodes [Array<Object, Path>] splat of nodes or Path objects
     #   @return [Boolean]
     #
     # @example
     #   Tree[1,2,3].strict_leaves?  # => true
-    #   tree = Tree[a: :foo, b: :bar, c: []]
+    #   tree = Tree[x: 1, y: [], z: nil]
     #   tree.strict_leaves?          # => false
     #   tree.strict_leaves?(:x, :y)  # => false
     #   tree.strict_leaves?(:y, :z)  # => false
+    #   tree.strict_leaves?(:y, :z)  # => false
+    #   tree.strict_leaves?(:z, Sycamore::Path[:x, 1])  # => true
     #
     def strict_leaves?(*nodes)
       nodes = self.nodes if nodes.empty?
@@ -995,15 +1080,17 @@ module Sycamore
     #
     # @overload external?(*nodes)
     #   Checks if all of the given nodes have no children.
-    #   @param nodes [Array<Object>] splat of nodes
+    #   @param nodes [Array<Object, Path>] splat of nodes or Path objects
     #   @return [Boolean]
     #
     # @example
     #   Tree[1,2,3].leaves?  # => true
     #   tree = Tree[x: 1, y: [], z: nil]
-    #   tree.leaves?          # => false
-    #   tree.leaves?(:x, :y)  # => false
-    #   tree.leaves?(:y, :z)  # => true
+    #   tree.external?          # => false
+    #   tree.external?(:x, :y)  # => false
+    #   tree.external?(:y, :z)  # => true
+    #   tree.external?(:y, :z)  # => true
+    #   tree.external?(Sycamore::Path[:x, 1], :y)  # => true
     #
     def external?(*nodes)
       nodes = self.nodes if nodes.empty?
@@ -1023,7 +1110,7 @@ module Sycamore
     #
     # @overload internal?(*nodes)
     #   Checks if all of the given nodes have children.
-    #   @param nodes [Array<Object>] splat of nodes
+    #   @param nodes [Array<Object, Path>] splat of nodes or Path objects
     #   @return [Boolean]
     #
     # @example
@@ -1033,6 +1120,8 @@ module Sycamore
     #   tree.internal?(:x, :y)  # => false
     #   tree.internal?(:y, :z)  # => false
     #   tree.internal?(:x)      # => true
+    #   tree.internal?(:x)      # => true
+    #   tree.internal?(Sycamore::Path[:x, 1])  # => false
     #
     # @todo Does it make sense to support the no arguments variant here and with this semantics?
     #   One would expect it to be the negation of #external? without arguments.
@@ -1280,6 +1369,36 @@ module Sycamore
             to_h(sleaf_child_as: Sycamore::NothingTree::NestedString).inspect}>"
     end
 
+    # @api private
+    #
+    private def valid_tree!(tree)
+      tree.each { |node, child| # using a {} block to circumvent this Rubinius issue: https://github.com/rubinius/rubinius-code/issues/7
+        next if child.nil?
+        valid_node!(node)
+        valid_tree!(child) if Tree.like?(child)
+      }
+
+      tree
+    end
+
+    # @api private
+    #
+    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
+    end
+
+
+    # @api private
+    #
+    private def valid_node!(node)
+      raise InvalidNode, "#{node} is not a valid tree node" if node.is_a? Enumerable
+
+      node
+    end
+
     ##
     # Checks if the given object can be converted into a Tree.
     #
@@ -1305,7 +1424,6 @@ module Sycamore
       alias like? tree_like?
     end
 
-
     ########################################################################
     # @group Other standard Ruby methods
     ########################################################################

data/support/travis.sh

@@ -0,0 +1,6 @@
+#/bin/sh
+set -e
+set -x
+
+mkdir ~/.yard
+bundle exec yard config -a autoload_plugins yard-doctest

data/sycamore.gemspec

@@ -14,18 +14,16 @@ Gem::Specification.new do |spec|
   spec.homepage      = 'https://github.com/marcelotto/sycamore'
   spec.license       = 'MIT'
 
-  spec.required_ruby_version = '>= 2.1'
-
   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.1'
+
   spec.add_development_dependency 'bundler', '~> 1.9'
   spec.add_development_dependency 'rake', '~> 10.0'
-  spec.add_development_dependency 'pry'
   spec.add_development_dependency 'rspec', '~> 3.4.0'
-  spec.add_development_dependency 'guard-rspec'
   spec.add_development_dependency 'yard', '~> 0.8'
   spec.add_development_dependency 'yard-doctest'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sycamore
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Marcel Otto
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-04-06 00:00:00.000000000 Z
+date: 2016-04-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -38,20 +38,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
-- !ruby/object:Gem::Dependency
-  name: pry
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -66,20 +52,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 3.4.0
-- !ruby/object:Gem::Dependency
-  name: guard-rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
@@ -146,9 +118,8 @@ files:
 - lib/sycamore/stree.rb
 - lib/sycamore/tree.rb
 - lib/sycamore/version.rb
-- script/console
-- script/console.cmd
 - support/doctest_helper.rb
+- support/travis.sh
 - sycamore.gemspec
 homepage: https://github.com/marcelotto/sycamore
 licenses:

data/script/console

@@ -1,14 +0,0 @@
-#!/usr/bin/env ruby
-# File: script/console
-pry = 'pry'
-repl = pry
-
-# libs = " -r #{File.expand_path(File.dirname(__FILE__)) + '/../lib/sycamore.rb'}"
-libs = " -r #{File.expand_path(File.dirname(__FILE__)) + '/../lib/sycamore/extension'}"
-
-puts "Loading Sycamore gem..."
-#exec "#{irb} #{libs} --simple-prompt"
-exec "bundle exec #{repl} #{libs}"
-
-#init_console = " -r #{File.expand_path(File.dirname(__FILE__)) + '/init_console.rb'}"
-#exec "pry #{libs} #{init_console}"

data/script/console.cmd

@@ -1 +0,0 @@
-@ruby script/console %*