key_tree 0.5.2 → 0.8.0

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
@@ -22,41 +30,59 @@ module KeyTree
     # key path matches in trees further away, returning nil. This preserves
     # the constraints that only leaves may contain a value.
     #
-    def [](key, &merger)
+    def [](key)
       return super(key) if key.is_a?(Numeric)
-      fetch(key, &merger)
-    rescue KeyError
+
+      trees.lazy.each do |tree|
+        result = tree[key]
+        return result unless result.nil?
+        break if tree.prefix?(key)
+      end
       nil
     end
 
-    def fetch(key)
-      return tree_with_key(key)[key] unless block_given?
+    # 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?
 
-      values = trees_with_key(key).map { |tree| tree[key] }
-      values.reverse.reduce { |left, right| yield(key, left, right) }
+      raise KeyError, %(key not found: "#{key}")
     end
 
-    def tree_with_key(key)
-      result = trees.detect do |tree|
-        tree.prefix?(key) || tree.default_key?(key)
-      end
-      result || raise(KeyError, "key not found: #{key}")
+    def key?(key)
+      trees.lazy.any? { |tree| tree.key?(key) }
     end
+    alias has_key? key?
 
-    def trees_with_key(key)
-      result = trees.select do |tree|
-        tree.prefix?(key) || tree.default_key?(key)
-      end
-      raise(KeyError, "key not found: #{key}") if result.empty?
-      result
+    def prefix?(key)
+      trees.lazy.any? { |tree| tree.prefix?(key) }
     end
+    alias has_prefix? prefix?
 
-    def key?(key)
-      trees.any? { |tree| tree.key?(key) }
+    def key_path?(key)
+      trees.lazy.any? { |tree| tree.key_path?(key) }
     end
+    alias has_key_path? key_path?
 
-    def prefix?(key)
-      trees.any? { |tree_or_forest| tree_or_forest.prefix?(key) }
+    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
@@ -74,9 +100,15 @@ module KeyTree
         remaining = [self]
         remaining.each do |woods|
           next yielder << woods if woods.is_a?(Tree)
+
           woods.each { |wood| remaining << wood }
         end
       end
     end
+
+    # Return all visible key paths in the forest
+    def key_paths
+      trees.reduce(Set.new) { |result, tree| result.merge(tree.key_paths) }
+    end
   end
 end

data/lib/key_tree/loader.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'key_tree/loader/nil'
 
 module KeyTree
@@ -8,26 +10,27 @@ module KeyTree
       yaml: 'YAML', yml: 'YAML'
     }.freeze
 
-    def self.[](type)
-      type = type.to_sym if type.respond_to?(:to_sym)
-      loaders[type] || @fallback
-    end
+    class << self
+      def [](type)
+        type = type.to_sym if type.respond_to?(:to_sym)
+        loaders[type] || @fallback
+      end
 
-    def self.[]=(type, loader_class)
-      type = type.to_sym if type.respond_to?(:to_sym)
-      loaders[type] = loader_class
-    end
+      def []=(type, loader_class)
+        type = type.to_sym if type.respond_to?(:to_sym)
+        loaders[type] = loader_class
+      end
 
-    def self.fallback(loader)
-      @fallback = loader
-    end
+      attr_writer :fallback, :loaders
+      alias fallback fallback=
 
-    private_class_method
+      private
 
-    def self.loaders
-      @loaders ||= BUILTIN_LOADERS.each_with_object({}) do |pair, result|
-        type, name = pair
-        result[type] = const_get(name) if const_defined?(name)
+      def loaders
+        @loaders ||= BUILTIN_LOADERS.each_with_object({}) do |pair, result|
+          type, name = pair
+          result[type] = const_get(name) if const_defined?(name)
+        end
       end
     end
   end

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/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 << Path.new(key_path)
       end
     end
 
@@ -22,21 +28,16 @@ module KeyTree
     #
     # Example:
     #   KeyTree::Path.new("a.b.c")
-    #   => ["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)
-      when Array
-        key_or_path.each { |key| append(key.to_sym) }
-      else
-        raise ArgumentError, 'key path must be String, Symbol or Array of those'
-      end
+    def initialize(key_path = [])
+      key_path = key_path.to_key_path unless key_path.is_a? Array
+
+      super(key_path.map(&:to_sym))
     end
 
+    alias to_key_path itself
+
     def to_s
       join('.')
     end
@@ -46,45 +47,36 @@ 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+
     #
-    #   Returns a key path without the leading prefix
-    #
-    # drop(+n+)
-    #
-    #   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:
+    #   drop(other) => Path
+    def drop(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,157 @@
+# frozen_string_literal: true
+
+module KeyTree
+  module Refine
+    # Refinements to Hash for deep_ methods, for traversing nested structures
+    module DeepHash
+      refine Hash do
+        # 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, *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 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
+        # 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_path, lhs, rhs| } => self
+        def deep_merge!(other, prefix = [], &block)
+          merge!(other) do |key, lhs, rhs|
+            key_path = prefix + [key]
+            both_are_hashes = lhs.is_a?(Hash) && rhs.is_a?(Hash)
+            next lhs.deep_merge!(rhs, key_path, &block) if both_are_hashes
+            next yield(key_path, lhs, rhs) unless block.nil?
+
+            rhs
+          end
+        end
+
+        # Deeply merge nested hash structures
+        #
+        # :call-seq:
+        #   deep_merge(other) => self
+        #   deep_merge(other) { |key_path, lhs, rhs| } => self
+        def deep_merge(other, prefix = [], &block)
+          merge(other) do |key, lhs, rhs|
+            key_path = prefix + [key]
+            both_are_hashes = lhs.is_a?(Hash) && rhs.is_a?(Hash)
+            next lhs.deep_merge(rhs, key_path, &block) if both_are_hashes
+            next yield(key_path, lhs, rhs) unless block.nil?
+
+            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
+
+        # 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]
+            yielder << [key_path, value]
+            value.deep_enumerator(yielder, key_path) if value.is_a?(Hash)
+          end
+        end
+      end
+    end
+  end
+end
+
+require_relative '../path'