key_tree 0.4.3 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0435887525ff8f573dcfb0bfe96a09b48768a5b2c9d33f10a9fb03cedae7440d'
-  data.tar.gz: 2c733e6d41c19a4fe8f4e9a167212a900acb779bf77c5150a4eab15126673197
+  metadata.gz: 47919143e113a4448b85cf800098227c6e47a5bcb92501e7d612722e7c06898f
+  data.tar.gz: 2b44f183949638a0a379297c0cb8ea6c50d0aa756c7e5a17e52324c9d3d96957
 SHA512:
-  metadata.gz: fba0374da8e56048ba4c98218e42c08673119163a8055ef8e8ae5129d59101e7971e65384f12cb3a0404fde5139732a3a89f605c2f46516dd24529b85367951f
-  data.tar.gz: d2c8161ae7689454c36103ce914ab5f40b12da89a17f9911e7f1c50a8c1076dd9076289c25fd8fde12ea1c2c73767b7fd8d8241c0bf486a6418ee7c0dd13da1d
+  metadata.gz: 2122707f4be42067a53db54c4fa98a13ecc55ff64fddc91c8ec3d40dbd5fddef9c1e3f01028ee3e662ce8e47d7f10bb4a3bc6d2ffbd156291e9223dedb4e283b
+  data.tar.gz: a1c2bc1e22162a646d2a88444e70017f093cde440fce3b9eeeefeba65d662c7e2d65ea3bad6f5c7d9f12cb3191a37e7fd4d4a380a1971e1aefa2ff4b2ed73c0b

data/.rubocop.yml

@@ -1,3 +1,7 @@
 Metrics/BlockLength:
   Exclude:
     - 'spec/*_spec.rb'
+
+Style/BlockDelimiters:
+  Exclude:
+    - 'spec/*_spec.rb'

data/RELEASE_NOTES.md

@@ -0,0 +1,51 @@
+# Release Notes
+
+## v0.5.0 – 2018-04-17
+
+### Changed methods
+
+  * `KeyTree.load(type, serialization, prefix: nil)`
+  * `KeyTree::Forest#[key] { |key, original, incoming| }`
+  * `KeyTree::Forest#fetch(key) { |key, original, incoming| }`
+  * `KeyTree::Forest#flatten { |key, original, incoming| }`
+  * `KeyTree::Tree#merge { |key, original, incoming| }`
+  * `KeyTree::Tree#merge! { |key, original, incoming| }`
+
+### New methods
+
+  * `KeyTree::Loader.fallback(loader)`
+
+### New features
+
+#### Merge value selection
+Improve merge related methods in `KeyTree::Tree`, and `KeyTree::Forest`
+to take a `Hash#merge` style block argument, to allow control of the result when a key i present on both sides of a merge operation.
+
+  * 083b25c Add merge value selector to Forest#[]
+  * e813e55 Add merge value selection to Forest#fetch
+  * 581bc82 Add method to get list of trees with key
+  * 0f66f03 Pass merge value selector via Forest#flatten
+  * df9b80e Pass any merge selection block to super
+
+#### Key prefix for file loading
+When a key file has a name like `prefix@name.ext`, the `prefix` part will be prepended to all keys loaded from the file.
+
+  * fbe333a Changed call syntax for KeyTree.load
+  * 595902c Load keytree with prefix from files with @ in name
+  * d23a7e1 Allow prepending a prefix when loading keys
+
+#### Fallback for KeyTree loaders
+Allow a fallback class for handling loading of file types where no loader is specified, e.g. to ignore all files with unrecognized extension for `KeyTree.load_all`.
+
+  * a9d096c Add tree loader fallback
+
+### Bug fixes
+
+#### Proper breadth first flattening
+
+  * ff327f2 Use tree enumarator for Forest#key? and #prefix?
+  * 74fa15d Rewrite Forest#[]
+  * 177de08 Use tree enumerator in Forest#[]
+  * d161fe1 Use tree enumerator in Forest#flatten
+  * b0c94df Add breadth-first enumerator for trees
+  * 3468f28 Remove forest vs tree sorting nonsense

data/lib/key_tree/forest.rb

@@ -11,7 +11,7 @@ module KeyTree
     def self.[](*contents)
       contents.reduce(Forest.new) do |result, content|
         result << KeyTree[content]
-      end.sort!
+      end
     end
 
     # For a numeric key, return the n:th tree in the forest
@@ -22,70 +22,56 @@ module KeyTree
     # key path matches in trees further away, returning nil. This preserves
     # the constraints that only leaves may contain a value.
     #
-    def [](key)
-      case key
-      when Numeric
-        super(key)
-      else
-        detect do |tree_or_forest|
-          return tree_or_forest[key] if tree_or_forest.key?(key)
-          return nil if tree_or_forest.prefix?(key)
-        end
-      end
+    def [](key, &merger)
+      return super(key) if key.is_a?(Numeric)
+      fetch(key, &merger)
+    rescue KeyError
+      nil
     end
 
-    # Trees are always smaller than forrests.
-    # Forests are compared by nesting depth, not number of trees.
-    #
-    def <=>(other)
-      return 0 if self == other
+    def fetch(key)
+      return tree_with_key(key).fetch(key) unless block_given?
 
-      case other
-      when Forest
-        depth <=> other.depth
-      when Tree
-        1
-      else
-        raise ArgumentError, 'only forests and trees are comparable'
-      end
+      values = trees_with_key(key).map { |tree| tree.fetch(key) }
+      values.reverse.reduce { |left, right| yield(key, left, right) }
     end
 
-    # The nesting depth of a forest
-    def depth
-      reduce(1) do |result, tree_or_forest|
-        [result, content_depth(tree_or_forest) + 1].max
-      end
+    def tree_with_key(key)
+      result = trees.detect { |tree| tree.prefix?(key) }
+      result || raise(KeyError, "key not found: #{key}")
+    end
+
+    def trees_with_key(key)
+      result = trees.select { |tree| tree.prefix?(key) }
+      raise(KeyError, "key not found: #{key}") if result.empty?
+      result
     end
 
     def key?(key)
-      any? { |tree_or_forest| tree_or_forest.key?(key) }
+      trees.any? { |tree| tree.key?(key) }
     end
 
     def prefix?(key)
-      any? { |tree_or_forest| tree_or_forest.prefix?(key) }
+      trees.any? { |tree_or_forest| tree_or_forest.prefix?(key) }
     end
 
     # Flattening a forest produces a tree with the equivalent view of key paths
     #
-    def flatten
-      reduce(Tree[]) do |result, tree_or_forest|
-        case tree_or_forest
-        when Forest
-          tree_or_forest.flatten.merge(result)
-        else
-          tree_or_forest.merge(result)
-        end
+    def flatten(&merger)
+      trees.reverse_each.reduce(Tree[]) do |result, tree|
+        result.merge!(tree, &merger)
       end
     end
 
-    private
-
-    def content_depth(content)
-      case content
-      when Forest
-        content.depth
-      else
-        0
+    # Return a breadth-first Enumerator for all the trees in the forest,
+    # and any nested forests
+    def trees
+      Enumerator.new do |yielder|
+        remaining = [self]
+        remaining.each do |woods|
+          next yielder << woods if woods.is_a?(Tree)
+          woods.each { |wood| remaining << wood }
+        end
       end
     end
   end

data/lib/key_tree/loader/nil.rb

@@ -0,0 +1,10 @@
+module KeyTree
+  module Loader
+    # KeyTree loader that ignores payload and produces an empty tree
+    module Nil
+      def self.load(*_drop)
+        {}
+      end
+    end
+  end
+end

data/lib/key_tree/loader.rb

@@ -1,3 +1,5 @@
+require 'key_tree/loader/nil'
+
 module KeyTree
   # Module to manage key tree loaders
   module Loader
@@ -8,7 +10,7 @@ module KeyTree
 
     def self.[](type)
       type = type.to_sym if type.respond_to?(:to_sym)
-      loaders[type]
+      loaders[type] || @fallback
     end
 
     def self.[]=(type, loader_class)
@@ -16,6 +18,10 @@ module KeyTree
       loaders[type] = loader_class
     end
 
+    def self.fallback(loader)
+      @fallback = loader
+    end
+
     private_class_method
 
     def self.loaders

data/lib/key_tree/tree.rb

@@ -54,31 +54,18 @@ module KeyTree
       keys.any? { |key| key.conflict?(Path[key_or_path]) }
     end
 
-    # All trees are created equal. Forests are always larger than trees.
-    #
-    def <=>(other)
-      case other
-      when Forest
-        -1
-      when Tree
-        0
-      else
-        raise ArgumentError, 'only trees and forests are comparable'
-      end
-    end
-
     # The merging of trees needs some extra consideration; due to the
     # nature of key paths, prefix conflicts must be deleted
     #
-    def merge!(other)
+    def merge!(other, &merger)
       other = Tree[other] unless other.is_a?(Tree)
       delete_if { |key, _| other.conflict?(key) }
       super
     end
     alias << merge!
 
-    def merge(other)
-      dup.merge!(other)
+    def merge(other, &merger)
+      dup.merge!(other, &merger)
     end
     alias + merge
   end

data/lib/key_tree.rb

@@ -27,35 +27,41 @@ module KeyTree
   # Load a KeyTree from some external serialization
   #
   # load +type+: +serialization+
+  # load +key_prefix+, +type+: +serialization+
   #
   # +type+ is upcased to form a class name that should provide a
   # +.load+ class method (like YAML or JSON does).
   #
-  # Example:
-  #   load(yaml: "---\na: 1\n")
+  # If a +key_prefix+ is given, it will be prepended to the loaded data.
+  #
+  # Examples:
+  #   load(:yaml, "---\na: 1\n")
   # => {"a" => 1}
   #
-  def self.load(typed_serialization = {})
-    unless typed_serialization.size == 1
-      raise ArgumentError, "pick one: #{typed_serialization.keys}"
-    end
-
-    type, serialization = typed_serialization.flatten
+  #   load(:yaml, "---\nb: 2\n", prefix: 'a')
+  # => {"a.b" => 2}
+  #
+  def self.load(type, serialization, prefix: nil)
+    type = type.to_sym unless type.nil?
     loader = Loader[type]
-    self[loader.load(serialization)].with_meta_data do |meta_data|
-      meta_data << { load: { type: type,
-                             loader: loader } }
+    contents = loader.load(serialization)
+    contents = { prefix => contents } unless prefix.nil?
+
+    self[contents].with_meta_data do |meta_data|
+      meta_data << { load: { type: type, loader: loader } }
+      meta_data << { load: { prefix: prefix } } unless prefix.nil?
     end
   end
 
   # Open an external file and load contents into a KeyTree
-  #
+  # When the file basename begins with 'prefix@', the prefix
+  # is prepended to all keys in the filee.
   def self.open(file_name)
     type = File.extname(file_name)[/[^.]+/]
-    type = type.to_sym unless type.nil?
+    prefix = File.basename(file_name)[/(.+)@/, 1]
 
     keytree = File.open(file_name, mode: 'rb:utf-8') do |file|
-      load_from_file(file, type)
+      load_from_file(file, type, prefix)
     end
 
     return keytree unless block_given?
@@ -79,8 +85,8 @@ module KeyTree
 
   private_class_method
 
-  def self.load_from_file(file, type)
-    load(type => file.read).with_meta_data do |meta_data|
+  def self.load_from_file(file, type, prefix)
+    load(type, file.read, prefix: prefix).with_meta_data do |meta_data|
       file_path = file.path
       meta_data << { file: { path: file_path,
                              name: File.basename(file_path),

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: key_tree
 version: !ruby/object:Gem::Version
-  version: 0.4.3
+  version: 0.5.0
 platform: ruby
 authors:
 - Calle Englund
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-04-07 00:00:00.000000000 Z
+date: 2018-04-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: git-version-bump
@@ -95,6 +95,7 @@ files:
 - Gemfile
 - LICENSE.txt
 - README.md
+- RELEASE_NOTES.md
 - Rakefile
 - bin/console
 - bin/setup
@@ -102,6 +103,7 @@ files:
 - lib/key_tree.rb
 - lib/key_tree/forest.rb
 - lib/key_tree/loader.rb
+- lib/key_tree/loader/nil.rb
 - lib/key_tree/meta_data.rb
 - lib/key_tree/path.rb
 - lib/key_tree/tree.rb