key_tree 0.5.3 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9cfde9ce8a431f8ce658b0d092958dcb97cf237fd1132b459a80191b72ef002b
-  data.tar.gz: f51c7e7ce679a1830d929e24114089820f8c1a79082c3e487ef5ac4fa23fa81f
+  metadata.gz: 535d58bfc5880880fe498d115be5d62a7cb4670661c17d46f4a44087f02c36a2
+  data.tar.gz: 42896ddb6f71accd5a23504ae63e38abf242bf6f839df4b599d7e567c48fcb4f
 SHA512:
-  metadata.gz: a904cca7e3be01bfb902b5c144685fc8c6dd3b52227f22fbd048e8d9e98e1675473bf766cc159ed422b6ac1c35a3b94969beea50dd29bdb528e4242a149a0c77
-  data.tar.gz: c9f17cdd2fff51099699d625a72a57bec483859369518c1b273db0478099320426aa24292a71eb07234d8f92ccabcda06875319356c9dae209b267be2657e75e
+  metadata.gz: a0e0c52ca0cc4766b226d8f31efcf1e97aa154a8a67f132d5f4f2c0764bd2c45ff05e8a9686f25ed3bfcc87caa144960ffd9dfdcf083084e71d490d9418d2444
+  data.tar.gz: 8cff399bdf835fb25fb45d0c50cf562e7f080ef9d5a88b7fd53c2a9c029b747fa1065bbf83455ffe1ef7a91eba5a91ef28b0ee2688eb06c942a7a4110a0c6eb7

data/.rubocop.yml

@@ -1,3 +1,6 @@
+AllCops:
+  TargetRubyVersion: 2.3
+
 Metrics/BlockLength:
   Exclude:
     - 'spec/*_spec.rb'

data/Gemfile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 source 'https://rubygems.org'
 
 git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }

data/RELEASE_NOTES.md

@@ -1,5 +1,52 @@
 # Release Notes
 
+## v0.6.0 – 2018-05-30
+
+### Major changes
+
+  * Updated to Ruby ~> 2.3
+  * Added refinements module for `to_key_*` conversions in core classes
+  * `KeyTree::Tree` rewritten from scratch, to use a refinements
+    to an internal `Hash` structure instead of subclassing `Hash`
+
+### New methods
+
+  * `KeyTree::Forest#key_paths`
+  * `KeyTree::Forest#to_key_forest`
+  * `KeyTree::Forest#to_key_wood`
+  * `KeyTree::Path#===`
+  * `KeyTree::Path#to_key_path`
+  * `KeyTree::Tree#delete(key_path)`
+  * `KeyTree::Tree#delete!(key_path)`
+  * `KeyTree::Tree#store(key_path, new_value)`
+  * `KeyTree::Tree#store!(key_path, new_value)`
+  * `KeyTree::Tree#to_key_tree`
+  * `KeyTree::Tree#to_key_wood`
+
+  * Using `KeyTree::Refinements`
+    * `Array#to_key_forest`
+    * `Array#to_key_path`
+    * `Array#to_key_wood`
+    * `Hash#to_key_tree`
+    * `Hash#to_key_wood`
+    * `String#to_key_path`
+    * `Symbol#to_key_path`
+
+  * Using `KeyTree::Refine::DeepHash`
+    * `Hash#deep`
+    * `Hash#deep_delete(key_path)`
+    * `Hash#deep_fetch(key_path, default, &default_proc)`
+    * `Hash#deep_merge(other)`
+    * `Hash#deep_merge!(other)`
+    * `Hash#deep_store(key_path, new_value)`
+    * `Hash#deep_transform_keys(&block)`
+    * `Hash#deep_transform_keys!(&block)`
+
+### Removed methods
+
+  * `KeyTree::Tree` no longer inherits `Hash`, but most of the
+    inherited methods didn't work properly anyway
+
 ## v0.5.3 – 2018-05-25
 
 ### Bug fixes

data/Rakefile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'bundler/setup'
 require 'bundler/gem_tasks'
 
@@ -11,4 +13,4 @@ desc 'Run RSpec'
 require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new(:spec)
 
-task default: %i[rubocop spec]
+task default: %i[spec rubocop]

data/bin/console

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 require 'bundler/setup'
 require 'key_tree'

data/key_tree.gemspec

@@ -1,17 +1,22 @@
+# frozen_string_literal: true
 
 lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'key_tree/version'
+
+begin
+  require 'git-version-bump'
+  GIT_VERSION = GVB.version.freeze
+rescue LoadError
+  GIT_VERSION = '0.0.0.UNDEF'
+end
 
 Gem::Specification.new do |spec|
   spec.name          = 'key_tree'
-  spec.version       = KeyTree::VERSION
-  spec.date          = KeyTree::DATE
+  spec.version       = GIT_VERSION
   spec.authors       = ['Calle Englund']
   spec.email         = ['calle@discord.bofh.se']
 
   spec.summary       = 'Manage trees of keys'
-  spec.description   = spec.summary
   spec.homepage      = 'https://github.com/notcalle/ruby-keytree'
   spec.license       = 'MIT'
 
@@ -22,10 +27,13 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'git-version-bump', '~> 0.15'
+  spec.platform = Gem::Platform::RUBY
+  spec.required_ruby_version = '~> 2.3'
 
   spec.add_development_dependency 'bundler', '~> 1.16'
+  spec.add_development_dependency 'git-version-bump', '~> 0.15'
   spec.add_development_dependency 'rake', '~> 10.0'
   spec.add_development_dependency 'rspec', '~> 3.0'
   spec.add_development_dependency 'rubocop', '~> 0.52'
+  spec.add_development_dependency 'ruby-prof', '~> 0.17'
 end

data/lib/key_tree/forest.rb

@@ -1,7 +1,12 @@
-require 'key_tree/tree'
-require 'key_tree/meta_data'
+# frozen_string_literal: true
+
+require_relative 'meta_data'
+require_relative 'refinements'
+require_relative 'tree'
+
+module KeyTree # rubocop:disable Style/Documentation
+  using Refinements
 
-module KeyTree
   #
   # A forest is a (possibly nested) collection of trees
   #
@@ -10,10 +15,13 @@ module KeyTree
 
     def self.[](*contents)
       contents.reduce(Forest.new) do |result, content|
-        result << KeyTree[content]
+        result << content.to_key_wood
       end
     end
 
+    alias to_key_forest itself
+    alias to_key_wood itself
+
     # For a numeric key, return the n:th tree in the forest
     #
     # For a key path convertable key, return the closest match in the forest
@@ -24,8 +32,12 @@ module KeyTree
     #
     def [](key)
       return super(key) if key.is_a?(Numeric)
-      tree_with_default_key(key)[key]
-    rescue KeyError
+
+      trees.lazy.each do |tree|
+        result = tree[key]
+        return result unless result.nil?
+        break if tree.prefix?(key)
+      end
       nil
     end
 
@@ -37,11 +49,27 @@ module KeyTree
     end
 
     def key?(key)
-      trees.any? { |tree| tree.key?(key) }
+      trees.lazy.any? { |tree| tree.key?(key) }
     end
+    alias has_key? key?
 
     def prefix?(key)
-      trees.any? { |tree_or_forest| tree_or_forest.prefix?(key) }
+      trees.lazy.any? { |tree| tree.prefix?(key) }
+    end
+    alias has_prefix? prefix?
+
+    def key_path?(key)
+      trees.lazy.any? { |tree| tree.key_path?(key) }
+    end
+    alias has_key_path? key_path?
+
+    def include?(needle)
+      case needle
+      when Tree, Forest
+        super(needle)
+      else
+        key_path?(needle)
+      end
     end
 
     # Flattening a forest produces a tree with the equivalent view of key paths
@@ -64,17 +92,15 @@ module KeyTree
       end
     end
 
-    private
-
-    def tree_with_default_key(key)
-      result = trees.detect do |tree|
-        tree.prefix?(key) || tree.default_key?(key)
-      end
-      result || raise(KeyError, %(key not found: "#{key}"))
+    # Return all visible key paths in the forest
+    def key_paths
+      trees.reduce(Set.new) { |result, tree| result.merge(tree.key_paths) }
     end
 
+    private
+
     def tree_with_key(key)
-      result = trees.detect do |tree|
+      result = trees.lazy.detect do |tree|
         tree.prefix?(key)
       end
       result || raise(KeyError, %(key not found: "#{key}"))

data/lib/key_tree/loader/nil.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module KeyTree
   module Loader
     # KeyTree loader that ignores payload and produces an empty tree

data/lib/key_tree/loader.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'key_tree/loader/nil'
 
 module KeyTree

data/lib/key_tree/meta_data.rb

@@ -1,4 +1,4 @@
-require 'key_tree/tree'
+# frozen_string_literal: true
 
 module KeyTree
   #
@@ -20,3 +20,5 @@ module KeyTree
     end
   end
 end
+
+require_relative 'tree'

data/lib/key_tree/path.rb

@@ -1,4 +1,10 @@
-module KeyTree
+# frozen_string_literal: true
+
+require_relative 'refinements'
+
+module KeyTree # rubocop:disable Style/Documentation
+  using Refinements
+
   #
   # Representation of the key path to a value in a key tree
   #
@@ -8,9 +14,9 @@ module KeyTree
     #
     # Make a new key path from one or more keys or paths
     #
-    def self.[](*keys_or_paths)
-      keys_or_paths.reduce(Path.new) do |result, key_or_path|
-        result << Path.new(key_or_path)
+    def self.[](*key_paths)
+      key_paths.reduce(Path.new) do |result, key_path|
+        result << key_path.to_key_path
       end
     end
 
@@ -24,19 +30,21 @@ module KeyTree
     #   KeyTree::Path.new("a.b.c")
     #   => ["a", "b", "c"]
     #
-    def initialize(key_or_path = [])
-      case key_or_path
-      when String
-        initialize(key_or_path.split('.'))
-      when Symbol
-        initialize(key_or_path.to_s)
+    def initialize(key_path = nil)
+      case key_path
+      when NilClass
+        nil
       when Array
-        key_or_path.each { |key| append(key.to_sym) }
+        concat(key_path.map(&:to_sym))
       else
-        raise ArgumentError, 'key path must be String, Symbol or Array of those'
+        initialize(key_path.to_key_path)
       end
     end
 
+    def to_key_path
+      self
+    end
+
     def to_s
       join('.')
     end
@@ -46,45 +54,34 @@ module KeyTree
     end
 
     def <<(other)
-      case other
-      when Path
-        other.reduce(self) do |result, key|
-          result.append(key)
-        end
-      else
-        self << Path[other]
-      end
+      concat(other.to_key_path)
     end
 
     def +(other)
-      dup << other
+      dup.concat(other.to_key_path)
     end
 
-    # drop(+prefix+)
-    #
-    #   Returns a key path without the leading prefix
-    #
-    # drop(+n+)
+    # Returns a key path without the leading +prefix+
     #
-    #   Returns a key path without the first n elements
-    #
-    def drop(prefix)
-      case prefix
-      when Path
-        return self unless prefix?(other)
-        drop(other.length)
-      else
-        super(prefix)
-      end
+    # :call-seq:
+    #   Path - other => Path
+    def -(other)
+      other = other.to_key_path
+      raise KeyError unless prefix?(other)
+      super(other.length)
     end
 
     # Is +other+ a prefix?
     #
+    # :call-seq:
+    #   prefix?(other) => boolean
     def prefix?(other)
+      other = other.to_key_path
       return false if other.length > length
       key_enum = each
       other.all? { |other_key| key_enum.next == other_key }
     end
+    alias === prefix?
 
     # Would +other+ conflict?
     #

data/lib/key_tree/refine/deep_hash.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module KeyTree
+  module Refine
+    # Refinements to Hash for deep_ methods, for traversing nested structures
+    module DeepHash
+      refine Hash do # rubocop:disable Metrics/BlockLength
+        # Return a deep enumerator for all (+key_path+, +value+) pairs in a
+        # nested hash structure.
+        #
+        # :call-seq:
+        #   deep => Enumerator
+        def deep
+          Enumerator.new do |yielder|
+            deep_enumerator(yielder)
+          end
+        end
+
+        # Fetch a leaf value from a nested hash structure
+        #
+        # :call-seq:
+        #   deep_fetch(key_path) => value
+        #   deep_fetch(key_path, default) => value || default
+        #   deep_fetch(key_path) { |key_path| block } => value || block
+        def deep_fetch(key_path, *args, &key_missing)
+          key_error = [KeyError, %(key path invalid: "#{key_path}")]
+          result = key_path.reduce(self) do |hash, key|
+            raise(*key_error) unless hash.is_a?(Hash)
+            hash.fetch(key, *args, &key_missing)
+          end
+          return result unless result.is_a?(Hash)
+          raise(*key_error)
+        end
+
+        # Store a new value in a nested hash structure, expanding it
+        # if necessary.
+        #
+        # :call-seq:
+        #   deep_store(key_path, new_value) => new_value
+        #
+        # Raises KeyError if a prefix of the +key_path+ has a value.
+        def deep_store(key_path, new_value)
+          *prefix_path, last_key = key_path
+          result = prefix_path.reduce(self) do |hash, key|
+            result = hash.fetch(key) { hash[key] = {} }
+            next result if result.is_a?(Hash)
+            raise KeyError, %(prefix has value: "#{key_path}")
+          end
+          result[last_key] = new_value
+        end
+
+        # Delete a leaf value in a nested hash structure
+        #
+        # :call-seq:
+        #   deep_delete(key_path)
+        #
+        # Raises KeyError if a prefix of the +key_path+ has a value.
+        def deep_delete(key_path)
+          *prefix_path, last_key = key_path
+          result = prefix_path.reduce(self) do |hash, key|
+            result = hash.fetch(key, nil)
+            next result if result.is_a?(Hash)
+            raise KeyError, %(prefix has value: "#{key_path}")
+          end
+          result.delete(last_key)
+        end
+
+        # Deeply merge nested hash structures
+        #
+        # :call-seq:
+        #   deep_merge!(other) => self
+        #   deep_merge!(other) { |key, lhs, rhs| } => self
+        def deep_merge!(other)
+          merge!(other) do |key, lhs, rhs|
+            next lhs.merge!(rhs) if lhs.is_a?(Hash) && rhs.is_a?(Hash)
+            next yield(key, lhs, rhs) if block_given?
+            rhs
+          end
+        end
+
+        # Deeply merge nested hash structures
+        #
+        # :call-seq:
+        #   deep_merge(other) => self
+        #   deep_merge(other) { |key, lhs, rhs| } => self
+        def deep_merge(other)
+          merge(other) do |key, lhs, rhs|
+            next lhs.merge(rhs) if lhs.is_a?(Hash) && rhs.is_a?(Hash)
+            next yield(key, lhs, rhs) if block_given?
+            rhs
+          end
+        end
+
+        # Transform keys in a nested hash structure
+        #
+        # :call-seq:
+        #   deep_transform_keys { |key| block }
+        def deep_transform_keys(&block)
+          result = transform_keys(&block)
+          result.transform_values! do |value|
+            next value unless value.is_a?(Hash)
+            value.deep_transform_keys(&block)
+          end
+        end
+
+        # Transform keys in a nested hash structure
+        #
+        # :call-seq:
+        #   deep_transform_keys! { |key| block }
+        def deep_transform_keys!(&block)
+          result = transform_keys!(&block)
+          result.transform_values! do |value|
+            next value unless value.is_a?(Hash)
+            value.deep_transform_keys!(&block)
+          end
+        end
+
+        def deep_enumerator(yielder, prefix = [])
+          each do |key, value|
+            key_path = prefix + [key]
+            yielder << [key_path, value]
+            value.deep_enumerator(yielder, key_path) if value.is_a?(Hash)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/key_tree/refinements.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative 'forest'
+require_relative 'path'
+require_relative 'tree'
+
+module KeyTree
+  # KeyTree refinements to core classes
+  module Refinements
+    refine Array do
+      def to_key_forest
+        Forest[*map(&:to_key_wood)]
+      end
+      alias_method :to_key_wood, :to_key_forest
+
+      def to_key_path
+        Path.new(self)
+      end
+    end
+
+    refine Hash do
+      def to_key_tree
+        Tree[self]
+      end
+      alias_method :to_key_wood, :to_key_tree
+    end
+
+    refine String do
+      def to_key_path
+        split('.').to_key_path
+      end
+    end
+
+    refine Symbol do
+      def to_key_path
+        to_s.to_key_path
+      end
+    end
+  end
+end

data/lib/key_tree/tree.rb

@@ -1,118 +1,145 @@
-require 'key_tree/path'
-require 'key_tree/meta_data'
+# frozen_string_literal: true
+
+require 'forwardable'
+require_relative 'meta_data'
+require_relative 'path'
+require_relative 'refinements'
+require_relative 'refine/deep_hash'
+
+module KeyTree # rubocop:disable Style/Documentation
+  using Refinements
+  using Refine::DeepHash
 
-module KeyTree
   # A tree of key-value lookup tables (hashes)
-  class Tree < Hash
+  class Tree
     include MetaData
+    extend Forwardable
     #
     # KeyTree::Tree.new(+hash+)
     #
     # Initialize a new KeyTree from nested Hash:es
     #
     def self.[](hash = {})
-      keytree = Tree.new
-      hash.each do |key, value|
-        keytree[key] = value
-      end
-      keytree
+      new(hash)
     end
 
-    def [](key_or_path)
-      super(Path[key_or_path])
+    def initialize(hash = {}, default = nil, &default_proc)
+      @hash = hash.to_h.deep_transform_keys(&:to_sym)
+      @default = default
+      @default_proc = default_proc
     end
 
-    def fetch(key_or_path, *args, &missing_key)
-      super(Path[key_or_path], *args, &missing_key)
-    end
+    attr_reader :default, :default_proc
 
-    def values_at(*keys)
-      super(keys.map { |key_or_path| Path[key_or_path] })
-    end
+    alias to_key_tree itself
+    alias to_key_wood itself
 
-    def []=(key_or_path, new_value)
-      path = Path[key_or_path]
+    delegate %i[empty? to_h to_json] => :@hash
 
-      delete_if { |key, _| path.conflict?(key) }
+    # Convert a Tree to YAML, with string keys
+    #
+    # :call-seq:
+    #   to_yaml => String
+    def to_yaml
+      to_h.deep_transform_keys(&:to_s).to_yaml
+    end
 
-      case new_value
-      when Hash
-        new_value.each { |suffix, value| self[path + suffix] = value }
-      else
-        super(path, new_value)
+    def [](key_path)
+      fetch(key_path) do
+        next default_proc.call(self, key_path) unless default_proc.nil?
+        default
       end
+    rescue KeyError
+      default
     end
 
-    def key?(key_or_path)
-      super(Path[key_or_path])
+    def fetch(key_path, *args, &key_missing)
+      @hash.deep_fetch(key_path.to_key_path, *args, &key_missing)
     end
 
-    def default_key?(key_or_path)
-      return unless default_proc
-      default_proc.yield(self, Path[key_or_path])
-      true
-    rescue KeyError
-      false
+    def store(key_path, new_value)
+      @hash.deep_store(key_path.to_key_path, new_value)
     end
 
-    def prefix?(key_or_path)
-      keys.any? { |key| key.prefix?(Path[key_or_path]) }
+    def store!(key_path, new_value)
+      store(key_path, new_value)
+    rescue KeyError
+      delete!(key_path)
+      retry
     end
+    alias []= store!
 
-    def conflict?(key_or_path)
-      keys.any? { |key| key.conflict?(Path[key_or_path]) }
+    def delete(key_path)
+      @hash.deep_delete(key_path.to_key_path)
     end
 
-    # The merging of trees needs some extra consideration; due to the
-    # nature of key paths, prefix conflicts must be deleted
-    #
-    def merge!(other, &merger)
-      other = Tree[other] unless other.is_a?(Tree)
-      delete_if { |key, _| other.conflict?(key) }
-      super
+    def delete!(key_path)
+      delete(key_path)
+    rescue KeyError
+      key_path = key_path[0..-2]
+      retry
     end
-    alias << merge!
 
-    def merge(other, &merger)
-      dup.merge!(other, &merger)
+    def values_at(*key_paths)
+      key_paths.map { |key_path| self[key_path] }
     end
-    alias + merge
 
-    # Format +fmtstr+ with values from the Tree
-    def format(fmtstr)
-      Kernel.format(fmtstr, Hash.new { |_, key| fetch(key) })
+    # Return all maximal key paths in a tree
+    #
+    # :call-seq:
+    #   keys => Array of KeyTree::Path
+    def keys
+      @hash.deep.each_with_object([]) do |(key_path, value), result|
+        result << key_path.to_key_path unless value.is_a?(Hash)
+      end
     end
+    alias key_paths keys
 
-    # Convert a Tree back to nested hashes.
-    #
-    # to_h => Hash, with symbol keys
-    # to_h(string_keys: true) => Hash, with string keys
-    def to_h(**kwargs)
-      to_hash_tree(**kwargs)
+    def include?(key_path)
+      fetch(key_path)
+      true
+    rescue KeyError
+      false
     end
+    alias key? include?
+    alias has_key? include?
+    alias key_path? include?
+    alias has_key_path? include?
 
-    # Convert a Tree to JSON, with string keys
-    def to_json
-      to_hash_tree(string_keys: true).to_json
+    def prefix?(key_path)
+      key_path.to_key_path.reduce(@hash) do |subtree, key|
+        return false unless subtree.is_a?(Hash)
+        return false unless subtree.key?(key)
+        subtree[key]
+      end
+      true
     end
+    alias has_prefix? prefix?
 
-    # Convert a Tree to YAML, with string keys
-    def to_yaml
-      to_hash_tree(string_keys: true).to_yaml
+    def value?(needle)
+      @hash.deep.lazy.any? { |(_, straw)| straw == needle }
     end
+    alias has_value? value?
 
-    private
+    # Merge values from +other+ tree into self
+    #
+    # :call-seq:
+    #   merge!(other) => self
+    #   merge!(other) { |key, lhs, rhs| } => self
+    def merge!(other, &block)
+      @hash.deep_merge!(other.to_h, &block)
+      self
+    end
+    alias << merge!
 
-    def to_hash_tree(key_pairs = self, string_keys: false)
-      hash = key_pairs.group_by do |path, _|
-        string_keys ? path.first.to_s : path.first
-      end
-      hash.transform_values do |next_level|
-        next_level.map! { |path, value| [path[1..-1], value] }
-        first_key, first_value = next_level.first
-        next first_value if first_key.nil? || first_key.empty?
-        to_hash_tree(next_level)
-      end
+    # Return a new tree by merging values from +other+ tree
+    #
+    # :call-seq:
+    #   merge(other) => Tree
+    #   merge(other) { |key, lhs, rhs| } => Tree
+    def merge(other, &block)
+      @hash.deep_merge(other.to_h, &block).to_key_tree
     end
+    alias + merge
   end
 end

data/lib/key_tree.rb

@@ -1,7 +1,9 @@
-require 'key_tree/version'
-require 'key_tree/tree'
+# frozen_string_literal: true
+
 require 'key_tree/forest'
 require 'key_tree/loader'
+require 'key_tree/refinements'
+require 'key_tree/tree'
 
 # Manage a tree of keys
 #
@@ -13,17 +15,10 @@ require 'key_tree/loader'
 #   -> 2
 #
 module KeyTree
+  using Refinements
+
   def self.[](contents = {})
-    case contents
-    when Tree, Forest
-      contents
-    when Hash
-      Tree[contents]
-    when Array
-      Forest[*contents]
-    else
-      raise ArgumentError, "can't load #{contents.class} into a KeyTree"
-    end
+    contents.to_key_wood
   end
 
   # Load a KeyTree from some external serialization
@@ -49,7 +44,7 @@ module KeyTree
     contents = loader.load(serialization)
     contents = { prefix => contents } unless prefix.nil?
 
-    self[contents].with_meta_data do |meta_data|
+    contents.to_key_wood.with_meta_data do |meta_data|
       meta_data << { load: { type: type, loader: loader } }
       meta_data << { load: { prefix: prefix } } unless prefix.nil?
     end

metadata

@@ -1,43 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: key_tree
 version: !ruby/object:Gem::Version
-  version: 0.5.3
+  version: 0.6.0
 platform: ruby
 authors:
 - Calle Englund
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-05-25 00:00:00.000000000 Z
+date: 2018-05-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: git-version-bump
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.15'
-  type: :runtime
+        version: '1.16'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.15'
+        version: '1.16'
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: git-version-bump
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.16'
+        version: '0.15'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.16'
+        version: '0.15'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -80,7 +80,21 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.52'
-description: Manage trees of keys
+- !ruby/object:Gem::Dependency
+  name: ruby-prof
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.17'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.17'
+description: 
 email:
 - calle@discord.bofh.se
 executables: []
@@ -106,8 +120,9 @@ files:
 - lib/key_tree/loader/nil.rb
 - lib/key_tree/meta_data.rb
 - lib/key_tree/path.rb
+- lib/key_tree/refine/deep_hash.rb
+- lib/key_tree/refinements.rb
 - lib/key_tree/tree.rb
-- lib/key_tree/version.rb
 homepage: https://github.com/notcalle/ruby-keytree
 licenses:
 - MIT
@@ -118,9 +133,9 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - "~>"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/lib/key_tree/version.rb

@@ -1,6 +0,0 @@
-require 'git-version-bump'
-
-module KeyTree
-  VERSION = GVB.version.freeze
-  DATE = GVB.date.freeze
-end