key_tree 0.6.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 535d58bfc5880880fe498d115be5d62a7cb4670661c17d46f4a44087f02c36a2
-  data.tar.gz: 42896ddb6f71accd5a23504ae63e38abf242bf6f839df4b599d7e567c48fcb4f
+  metadata.gz: 69bc0aa979e024edf0ce7e8bf7fd091aa6976a99b436031be3d4d1e7eae94108
+  data.tar.gz: 14da39af72e5680703b911ddf7fa9b27bc8a614bbb95847ed79d01771d827307
 SHA512:
-  metadata.gz: a0e0c52ca0cc4766b226d8f31efcf1e97aa154a8a67f132d5f4f2c0764bd2c45ff05e8a9686f25ed3bfcc87caa144960ffd9dfdcf083084e71d490d9418d2444
-  data.tar.gz: 8cff399bdf835fb25fb45d0c50cf562e7f080ef9d5a88b7fd53c2a9c029b747fa1065bbf83455ffe1ef7a91eba5a91ef28b0ee2688eb06c942a7a4110a0c6eb7
+  metadata.gz: 606f5b5907e53c97570439a2eaa2d5b1c4085300bb1b4855a31ee72fe3ffdc39a69d88f74a439dcd285e51e101bd159f1baacd641536b3c1ceed3ed3f0557232
+  data.tar.gz: 9e9a5f2b2ce987786be86670e003f0cc9d7fa44d33e90acf6db8d835d38aa2bf635027f909245bae092d22502ce67e150d03907c5ad9281689532dcfdf5fcaca

data/RELEASE_NOTES.md

@@ -1,5 +1,30 @@
 # Release Notes
 
+## v0.6.1 – 2018-05-31
+
+### New methods
+
+  * `KeyTree::Tree#fetch_default(key, default) { block }`
+
+  * Using `KeyTree::Refine::DeepHash`
+    * `Hash#deep_key_pathify`
+
+### Bug fixes
+
+Default processing for forests was broken.
+
+  * 7ff646ff Fix Forest#fetch default vs KeyError processing
+  * 62f6fd73 Add default aware fetch method
+  * 00f0b163 Manage deep_fetch KeyError generation on our own
+
+#### Handle incoming key pathish keys
+
+When a `Hash` had keys that looked like key paths, they were not correctly
+converted to nested hashes with symbol keys.
+
+  * c23df1dd Change key transform for incoming hashes
+  * 09b526c8 Add new hash refinement for key_path-ification
+
 ## v0.6.0 – 2018-05-30
 
 ### Major changes

data/key_tree.gemspec

@@ -3,16 +3,11 @@
 lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
-begin
-  require 'git-version-bump'
-  GIT_VERSION = GVB.version.freeze
-rescue LoadError
-  GIT_VERSION = '0.0.0.UNDEF'
-end
+require 'key_tree/version'
 
 Gem::Specification.new do |spec|
   spec.name          = 'key_tree'
-  spec.version       = GIT_VERSION
+  spec.version       = KeyTree::VERSION
   spec.authors       = ['Calle Englund']
   spec.email         = ['calle@discord.bofh.se']
 

data/lib/key_tree/forest.rb

@@ -41,11 +41,23 @@ module KeyTree # rubocop:disable Style/Documentation
       nil
     end
 
-    def fetch(key)
-      return tree_with_key(key).fetch(key) unless block_given?
-
-      values = trees_with_key(key).map { |tree| tree.fetch(key) }
-      values.reverse.reduce { |left, right| yield(key, left, right) }
+    # Fetch a value from a forest
+    #
+    # :call-seq:
+    #   fetch(key) => value
+    #   fetch(key, default) => value
+    #   fetch(key) { |key| } => value
+    #
+    # The first form raises a +KeyError+ unless +key+ has a value.
+    def fetch(key, *default)
+      trees.lazy.each do |tree|
+        catch do |ball|
+          return tree.fetch(key) { throw ball }
+        end
+      end
+      return yield(key) if block_given?
+      return default.first unless default.empty?
+      raise KeyError, %(key not found: "#{key}")
     end
 
     def key?(key)

data/lib/key_tree/refine/deep_hash.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative '../path'
+
 module KeyTree
   module Refine
     # Refinements to Hash for deep_ methods, for traversing nested structures
@@ -22,14 +24,17 @@ module KeyTree
         #   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)
+        def deep_fetch(key_path, *default)
+          catch do |ball|
+            result = key_path.reduce(self) do |hash, key|
+              throw ball unless hash.is_a?(Hash)
+              hash.fetch(key) { throw ball }
+            end
+            return result unless result.is_a?(Hash)
           end
-          return result unless result.is_a?(Hash)
-          raise(*key_error)
+          return yield(key_path) if block_given?
+          return default.first unless default.empty?
+          raise KeyError, %(key path invalid: "#{key_path}")
         end
 
         # Store a new value in a nested hash structure, expanding it
@@ -115,6 +120,19 @@ module KeyTree
           end
         end
 
+        # Comvert any keys containing a +.+ in a hash structure
+        # to nested hashes.
+        #
+        # :call-seq:
+        #   deep_key_pathify => Hash
+        def deep_key_pathify
+          each_with_object({}) do |(key, value), result|
+            key_path = Path[key]
+            value = value.deep_key_pathify if value.is_a?(Hash)
+            result.deep_store(key_path, value)
+          end
+        end
+
         def deep_enumerator(yielder, prefix = [])
           each do |key, value|
             key_path = prefix + [key]

data/lib/key_tree/tree.rb

@@ -24,7 +24,7 @@ module KeyTree # rubocop:disable Style/Documentation
     end
 
     def initialize(hash = {}, default = nil, &default_proc)
-      @hash = hash.to_h.deep_transform_keys(&:to_sym)
+      @hash = hash.to_h.deep_key_pathify
       @default = default
       @default_proc = default_proc
     end
@@ -45,12 +45,17 @@ module KeyTree # rubocop:disable Style/Documentation
     end
 
     def [](key_path)
-      fetch(key_path) do
-        next default_proc.call(self, key_path) unless default_proc.nil?
-        default
+      fetch_default(key_path, default)
+    end
+
+    def fetch_default(key_path, *default)
+      catch do |ball|
+        return fetch(key_path) { throw ball }
       end
-    rescue KeyError
-      default
+      return default_proc.call(self, key_path) unless default_proc.nil?
+      return yield(key_path) if block_given?
+      return default.first unless default.empty?
+      raise KeyError, %(key not found: "#{key_path}")
     end
 
     def fetch(key_path, *args, &key_missing)

data/lib/key_tree/version.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module KeyTree # rubocop:disable Style/Documentation
+  begin
+    require 'git-version-bump'
+    VERSION = GVB.version.freeze
+  rescue LoadError
+    VERSION = '0.0.0.UNDEF'
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: key_tree
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.6.1
 platform: ruby
 authors:
 - Calle Englund
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-05-30 00:00:00.000000000 Z
+date: 2018-05-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -123,6 +123,7 @@ files:
 - 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