unobtainium 0.5.1 → 0.6.0

data/lib/unobtainium/pathed_hash.rb

@@ -1,199 +0,0 @@
-# coding: utf-8
-#
-# unobtainium
-# https://github.com/jfinkhaeuser/unobtainium
-#
-# Copyright (c) 2016 Jens Finkhaeuser and other unobtainium contributors.
-# All rights reserved.
-#
-
-require 'unobtainium/recursive_merge'
-
-module Unobtainium
-
-  ##
-  # The PathedHash class wraps Hash by offering pathed access on top of
-  # regular access, i.e. instead of `h["first"]["second"]` you can write
-  # `h["first.second"]`.
-  #
-  # The main benefit is much simpler code for accessing nested structured.
-  # For any given path, PathedHash will return nil from `[]` if *any* of
-  # the path components do not exist.
-  #
-  # Similarly, intermediate nodes will be created when you write a value
-  # for a path.
-  #
-  # PathedHash also includes RecursiveMerge.
-  class PathedHash
-    include RecursiveMerge
-
-    DEFAULT_PROC = proc do |hash, key|
-      case key
-      when String
-        sym = key.to_sym
-        hash[sym] if hash.key?(sym)
-      when Symbol
-        str = key.to_s
-        hash[str] if hash.key?(str)
-      end
-    end.freeze
-
-    ##
-    # Initializer. Accepts `nil`, hashes or pathed hashes.
-    #
-    # @param init [NilClass, Hash] initial values.
-    def initialize(init = nil)
-      if init.nil?
-        @data = {}
-      else
-        @data = init.dup
-      end
-      @separator = '.'
-
-      @data.default_proc = DEFAULT_PROC
-    end
-
-    # @return [String] the separator is the character or pattern splitting paths.
-    attr_accessor :separator
-
-    # @api private
-    # Methods redefined to support pathed read access.
-    READ_METHODS = [
-      :[], :default, :delete, :fetch, :has_key?, :include?, :key?, :member?,
-    ].freeze
-
-    # @api private
-    # Methods redefined to support pathed write access.
-    WRITE_METHODS = [
-      :[]=, :store,
-    ].freeze
-
-    ##
-    # @return [RegExp] the pattern to split paths at; based on `separator`
-    def split_pattern
-      /(?<!\\)#{Regexp.escape(@separator)}/
-    end
-
-    (READ_METHODS + WRITE_METHODS).each do |method|
-      # Wrap all accessor functions to deal with paths
-      define_method(method) do |*args, &block|
-        # If there are no arguments, there's nothing to do with paths. Just
-        # delegate to the hash.
-        if args.empty?
-          return @data.send(method, *args, &block)
-        end
-
-        # With any of the dispatch methods, we know that the first argument has
-        # to be a key. We'll try to split it by the path separator.
-        components = args[0].to_s.split(split_pattern)
-        loop do
-          if components.empty? or not components[0].empty?
-            break
-          end
-          components.shift
-        end
-
-        # If there are no components, return self/the root
-        if components.empty?
-          return self
-        end
-
-        # This PathedHash is already the leaf-most Hash
-        if components.length == 1
-          # Weird edge case: if we didn't have to shift anything, then it's
-          # possible we inadvertently changed a symbol key into a string key,
-          # which could mean looking fails.
-          # We can detect that by comparing copy[0] to a symbolized version of
-          # components[0].
-          copy = args.dup
-          if copy[0] != components[0].to_sym
-            copy[0] = components[0]
-          end
-          return @data.send(method, *copy, &block)
-        end
-
-        # Deal with other paths. The frustrating part here is that for nested
-        # hashes, only this outermost one is guaranteed to know anything about
-        # path splitting, so we'll have to recurse down to the leaf here.
-        #
-        # For write methods, we need to create intermediary hashes.
-        leaf = recursive_fetch(components, @data,
-                               create: WRITE_METHODS.include?(method))
-        if leaf.is_a? Hash
-          leaf.default_proc = DEFAULT_PROC
-        end
-        if leaf.nil?
-          leaf = @data
-        end
-
-        # If we have a leaf, we want to send the requested method to that
-        # leaf.
-        copy = args.dup
-        copy[0] = components.last
-        return leaf.send(method, *copy, &block)
-      end
-    end
-
-    # @return [String] string representation
-    def to_s
-      @data.to_s
-    end
-
-    # @return [PathedHash] duplicate, as `.dup` usually works
-    def dup
-      PathedHash.new(@data.dup)
-    end
-
-    # In place merge, as it usually works for hashes.
-    # @return [PathedHash] self
-    def merge!(*args, &block)
-      # FIXME: we may need other methods like this. This is used by
-      #        RecursiveMerge, so we know it's required.
-      PathedHash.new(super)
-    end
-
-    ##
-    # Map any missing method to the Hash implementation
-    def respond_to_missing?(meth, include_private = false)
-      if not @data.nil? and @data.respond_to?(meth, include_private)
-        return true
-      end
-      return super
-    end
-
-    ##
-    # Map any missing method to the Hash implementation
-    def method_missing(meth, *args, &block)
-      if not @data.nil? and @data.respond_to?(meth)
-        return @data.send(meth.to_s, *args, &block)
-      end
-      return super
-    end
-
-    private
-
-    ##
-    # Given the path components, recursively fetch any but the last key.
-    def recursive_fetch(path, data, options = {})
-      # For the leaf element, we do nothing because that's where we want to
-      # dispatch to.
-      if path.length == 1
-        return data
-      end
-
-      # Split path into head and tail; for the next iteration, we'll look use only
-      # head, and pass tail on recursively.
-      head = path[0]
-      tail = path.slice(1, path.length)
-
-      # If we're a write function, then we need to create intermediary objects,
-      # i.e. what's at head if nothing is there.
-      if options[:create] and data[head].nil?
-        data[head] = {}
-      end
-
-      # Ok, recurse.
-      return recursive_fetch(tail, data[head], options)
-    end
-  end # class PathedHash
-end # module Unobtainium

data/lib/unobtainium/recursive_merge.rb

@@ -1,55 +0,0 @@
-# coding: utf-8
-#
-# unobtainium
-# https://github.com/jfinkhaeuser/unobtainium
-#
-# Copyright (c) 2016 Jens Finkhaeuser and other unobtainium contributors.
-# All rights reserved.
-#
-
-module Unobtainium
-  ##
-  # Provides recursive merge functions for hashes. Used in PathedHash.
-  module RecursiveMerge
-    ##
-    # Recursively merge `:other` into this Hash.
-    #
-    # This starts by merging the leaf-most Hash entries. Arrays are merged
-    # by addition.
-    #
-    # For everything that's neither Hash or Array, if the `:overwrite`
-    # parameter is true, the entry from `:other` is used. Otherwise the entry
-    # from `:self` is used.
-    #
-    # @param other [Hash] the hash to merge into `:self`
-    # @param overwrite [Boolean] see method description.
-    def recursive_merge!(other, overwrite = true)
-      if other.nil?
-        return self
-      end
-
-      merger = proc do |_, v1, v2|
-        # rubocop:disable Style/GuardClause
-        if v1.is_a? Hash and v2.is_a? Hash
-          next v1.merge(v2, &merger)
-        elsif v1.is_a? Array and v2.is_a? Array
-          next v1 + v2
-        end
-        if overwrite
-          next v2
-        else
-          next v1
-        end
-        # rubocop:enable Style/GuardClause
-      end
-      merge!(other, &merger)
-    end
-
-    ##
-    # Same as `dup.recursive_merge!`
-    # @param (see #recursive_merge!)
-    def recursive_merge(other, overwrite = true)
-      dup.recursive_merge!(other, overwrite)
-    end
-  end # module RecursiveMerge
-end # module Unobtainium

data/spec/config_spec.rb

@@ -1,119 +0,0 @@
-require 'spec_helper'
-require_relative '../lib/unobtainium/config'
-
-describe ::Unobtainium::Config do
-  before :each do
-    @data_path = File.join(File.dirname(__FILE__), 'data')
-  end
-
-  it "fails to load a nonexistent file" do
-    expect { ::Unobtainium::Config.load_config("_nope_.yaml") }.to \
-      raise_error Errno::ENOENT
-  end
-
-  it "is asked to load an unrecognized extension" do
-    expect { ::Unobtainium::Config.load_config("_nope_.cfg") }.to \
-      raise_error ArgumentError
-  end
-
-  it "loads a yaml config with a top-level hash correctly" do
-    config = File.join(@data_path, 'hash.yml')
-    cfg = ::Unobtainium::Config.load_config(config)
-
-    expect(cfg["foo"]).to eql "bar"
-    expect(cfg["baz"]).to eql "quux"
-  end
-
-  it "loads a yaml config with a top-level array correctly" do
-    config = File.join(@data_path, 'array.yaml')
-    cfg = ::Unobtainium::Config.load_config(config)
-
-    expect(cfg["config"]).to eql %w(foo bar)
-  end
-
-  it "loads a JSON config correctly" do
-    config = File.join(@data_path, 'test.json')
-    cfg = ::Unobtainium::Config.load_config(config)
-
-    expect(cfg["foo"]).to eql "bar"
-    expect(cfg["baz"]).to eql 42
-  end
-
-  it "merges a hashed config correctly" do
-    config = File.join(@data_path, 'hashmerge.yml')
-    cfg = ::Unobtainium::Config.load_config(config)
-
-    expect(cfg["asdf"]).to eql 1
-    expect(cfg["foo.bar"]).to eql "baz"
-    expect(cfg["foo.quux"]).to eql [1, 42]
-    expect(cfg["foo.baz"]).to eql 3.14
-    expect(cfg["blargh"]).to eql false
-  end
-
-  it "merges an array config correctly" do
-    config = File.join(@data_path, 'arraymerge.yaml')
-    cfg = ::Unobtainium::Config.load_config(config)
-
-    expect(cfg["config"]).to eql %w(foo bar baz)
-  end
-
-  it "merges an array and hash config" do
-    config = File.join(@data_path, 'mergefail.yaml')
-    cfg = ::Unobtainium::Config.load_config(config)
-
-    expect(cfg["config"]).to eql %w(array in main config)
-    expect(cfg["local"]).to eql "override is a hash"
-  end
-
-  it "overrides configuration variables from the environment" do
-    config = File.join(@data_path, 'hash.yml')
-    cfg = ::Unobtainium::Config.load_config(config)
-
-    ENV["BAZ"] = "override"
-    expect(cfg["foo"]).to eql "bar"
-    expect(cfg["baz"]).to eql "override"
-  end
-
-  it "treats an empty YAML file as an empty hash" do
-    config = File.join(@data_path, 'empty.yml')
-    cfg = ::Unobtainium::Config.load_config(config)
-    expect(cfg).to be_empty
-  end
-
-  it "extends configuration hashes" do
-    config = File.join(@data_path, 'driverconfig.yml')
-    cfg = ::Unobtainium::Config.load_config(config)
-
-    # First, test for non-extended values
-    expect(cfg["drivers.mock.mockoption"]).to eql 42
-    expect(cfg["drivers.branch1.branch1option"]).to eql "foo"
-    expect(cfg["drivers.branch2.branch2option"]).to eql "bar"
-    expect(cfg["drivers.leaf.leafoption"]).to eql "baz"
-
-    # Now test extended values
-    expect(cfg["drivers.branch1.mockoption"]).to eql 42
-    expect(cfg["drivers.branch2.mockoption"]).to eql 42
-    expect(cfg["drivers.leaf.mockoption"]).to eql 42
-
-    expect(cfg["drivers.branch2.branch1option"]).to eql "foo"
-    expect(cfg["drivers.leaf.branch1option"]).to eql "override" # not "foo" !
-
-    expect(cfg["drivers.leaf.branch2option"]).to eql "bar"
-
-    # Also test that all levels go back to base == mock
-    expect(cfg["drivers.branch1.base"]).to eql 'mock'
-    expect(cfg["drivers.branch2.base"]).to eql 'mock'
-    expect(cfg["drivers.leaf.base"]).to eql 'mock'
-  end
-
-  it "extends configuration hashes when the base does not exist" do
-    config = File.join(@data_path, 'driverconfig.yml')
-    cfg = ::Unobtainium::Config.load_config(config)
-
-    # Ensure the hash contains its own value
-    expect(cfg["drivers.base_does_not_exist.some"]).to eql "value"
-
-    # Also ensure the "base" is set properly
-    expect(cfg["drivers.base_does_not_exist.base"]).to eql "nonexistent_base"
-  end
-end

data/spec/data/array.yaml

@@ -1,3 +0,0 @@
----
-- foo
-- bar

data/spec/data/arraymerge-local.yaml

@@ -1,2 +0,0 @@
----
-- baz

data/spec/data/arraymerge.yaml

@@ -1,3 +0,0 @@
----
-- foo
-- bar

data/spec/data/empty.yml

@@ -1 +0,0 @@
----

data/spec/data/hash.yml

@@ -1,3 +0,0 @@
----
-foo: bar
-baz: quux

data/spec/data/hashmerge-local.yml

@@ -1,4 +0,0 @@
----
-blargh: false
-foo:
-  baz: 3.14

data/spec/data/hashmerge.yml

@@ -1,7 +0,0 @@
----
-asdf: 1
-foo:
-  bar: baz
-  quux:
-    - 1
-    - 42

data/spec/data/mergefail-local.yaml

@@ -1,2 +0,0 @@
----
-local: override is a hash

data/spec/data/mergefail.yaml

@@ -1,5 +0,0 @@
----
-- array
-- in
-- main
-- config

data/spec/data/test.json

@@ -1,4 +0,0 @@
-{
-  "foo": "bar",
-  "baz": 42
-}

data/spec/data/world.yml

@@ -1,5 +0,0 @@
----
-drivers:
-  mock:
-    option: value
-driver: mock

data/spec/pathed_hash_spec.rb

@@ -1,192 +0,0 @@
-require 'spec_helper'
-require_relative '../lib/unobtainium/pathed_hash'
-
-describe ::Unobtainium::PathedHash do
-  describe "#initialize" do
-    it "can be constructed without values" do
-      ph = ::Unobtainium::PathedHash.new
-      expect(ph.empty?).to eql true
-    end
-
-    it "can be constructed with values" do
-      ph = ::Unobtainium::PathedHash.new(foo: 42)
-      expect(ph.empty?).to eql false
-      expect(ph[:foo]).to eql 42
-    end
-
-    it "can be constructed with a nil value" do
-      ph = ::Unobtainium::PathedHash.new(nil)
-      expect(ph.empty?).to eql true
-    end
-  end
-
-  describe "Hash-like" do
-    it "responds to Hash functions" do
-      ph = ::Unobtainium::PathedHash.new
-      [:invert, :delete, :fetch].each do |meth|
-        expect(ph.respond_to?(meth)).to eql true
-      end
-    end
-
-    it "can be used like a hash" do
-      ph = ::Unobtainium::PathedHash.new(foo: 42)
-      inverted = ph.invert
-      expect(inverted.empty?).to eql false
-      expect(inverted[42]).to eql :foo
-    end
-
-    it "delegates to Hash if it's nothing to do with paths" do
-      ph = ::Unobtainium::PathedHash.new(foo: 42)
-      expect(ph.default).to be_nil
-    end
-  end
-
-  it "can recursively read entries via a path" do
-    sample = {
-      "foo" => 42,
-      "bar" => {
-        "baz" => "quux",
-        "blah" => [1, 2],
-      }
-    }
-    ph = ::Unobtainium::PathedHash.new(sample)
-
-    expect(ph["foo"]).to eql 42
-    expect(ph["bar.baz"]).to eql "quux"
-    expect(ph["bar.blah"]).to eql [1, 2]
-
-    expect(ph["nope"]).to eql nil
-    expect(ph["bar.nope"]).to eql nil
-  end
-
-  it "behaves consistently if in a path the first node cannot be found" do
-    sample = {
-      "foo" => 42,
-    }
-    ph = ::Unobtainium::PathedHash.new(sample)
-
-    expect(ph["nope.bar"]).to eql nil
-  end
-
-  it "can be used with indifferent access from string key" do
-    sample = {
-      "foo" => 42,
-    }
-    ph = ::Unobtainium::PathedHash.new(sample)
-
-    expect(ph["foo"]).to eql 42
-    expect(ph[:foo]).to eql 42
-  end
-
-  it "can be used with indifferent access from symbol key" do
-    sample = {
-      foo: 42,
-      bar: {
-        baz: 'quux',
-      }
-    }
-    ph = ::Unobtainium::PathedHash.new(sample)
-
-    expect(ph["foo"]).to eql 42
-    expect(ph[:foo]).to eql 42
-
-    expect(ph['bar.baz']).to eql 'quux'
-  end
-
-  it "treats a single separator as the root" do
-    sample = { "foo" => 42 }
-    ph = ::Unobtainium::PathedHash.new(sample)
-
-    expect(ph[ph.separator]["foo"]).to eql 42
-  end
-
-  it "treats an empty path as the root" do
-    sample = { "foo" => 42 }
-    ph = ::Unobtainium::PathedHash.new(sample)
-
-    expect(ph[""]["foo"]).to eql 42
-  end
-
-  it "can recursively write entries via a path" do
-    ph = ::Unobtainium::PathedHash.new
-    ph["foo.bar"] = 42
-    expect(ph["foo.bar"]).to eql 42
-  end
-
-  it "has the same string representation as the hash it's initialized from" do
-    h = { foo: 42 }
-    ph = ::Unobtainium::PathedHash.new(h)
-    expect(ph.to_s).to eql h.to_s
-  end
-
-  it "understands absolute paths (starting with separator)" do
-    sample = {
-      "foo" => 42,
-      "bar" => {
-        "baz" => "quux",
-        "blah" => [1, 2],
-      }
-    }
-    ph = ::Unobtainium::PathedHash.new(sample)
-
-    expect(ph["bar.baz"]).to eql "quux"
-    expect(ph[".bar.baz"]).to eql "quux"
-  end
-
-  it "recursively merges with overwriting" do
-    sample1 = {
-      "foo" => {
-        "bar" => 42,
-        "baz" => "quux",
-      }
-    }
-    sample2 = {
-      "foo" => {
-        "baz" => "override"
-      }
-    }
-
-    ph1 = ::Unobtainium::PathedHash.new(sample1)
-    ph2 = ph1.recursive_merge(sample2)
-
-    expect(ph2["foo.bar"]).to eql 42
-    expect(ph2["foo.baz"]).to eql "override"
-  end
-
-  it "recursively merges without overwriting" do
-    sample1 = {
-      "foo" => {
-        "bar" => 42,
-        "baz" => "quux",
-      }
-    }
-    sample2 = {
-      "foo" => {
-        "baz" => "override"
-      }
-    }
-
-    ph1 = ::Unobtainium::PathedHash.new(sample1)
-    ph2 = ph1.recursive_merge(sample2, false)
-
-    expect(ph2["foo.bar"]).to eql 42
-    expect(ph2["foo.baz"]).to eql "quux"
-  end
-
-  it "can write with indifferent access without overwriting" do
-    sample = {
-      foo: {
-        bar: 42,
-        baz: 'quux',
-      }
-    }
-    ph = ::Unobtainium::PathedHash.new(sample)
-
-    expect(ph['foo.bar']).to eql 42
-    expect(ph['foo.baz']).to eql 'quux'
-
-    ph['foo.bar'] = 123
-    expect(ph['foo.bar']).to eql 123
-    expect(ph['foo.baz']).to eql 'quux'
-  end
-end