hiera 3.1.0 → 3.1.1

data/README.md

@@ -101,6 +101,48 @@ $ hiera ssh_users.0
 root
 </pre>
 
+### Use quotes to disable qualified key behavior
+In case you have dotted keys and thus want to avoid using the qualified key semantics, you
+can put segments of a dotted key, or the whole key, within quotes.
+
+Given the following data:
+
+<pre>
+# yaml
+a:
+  b.c:
+    d: 'Data for a => b.c => d'
+</pre>
+
+it is possible to do a lookup of the data like this:
+
+<pre>
+$ hiera 'a."b.c".d'
+Data for a => b.c => d
+</pre>
+
+Quoting works in interpolation expressions as well.
+
+Interpolating from global scope:
+
+<pre>
+# yaml
+other.key: 'scope data: %{a."b.c".d}'
+</pre>
+
+or using an interpolation method:
+
+<pre>
+# yaml
+a:
+  b.c:
+    d: 'Data for a => b.c => d'
+other.key: 'hiera data %{hiera("a.''b.c''.d")}'
+</pre>
+
+Note that two single quotes are used to escape a single quote inside a single quoted string
+(that's YAML syntax, not Hiera) and that the quoted key must be quoted in turn.
+
 ## Future Enhancements
 
  * More backends should be created

data/lib/hiera/backend.rb

@@ -231,7 +231,7 @@ class Hiera
       # databases then do so in your constructor, future calls to your
       # backend will not create new instances
 
-      # @param key [String] The key to lookup
+      # @param key [String] The key to lookup. May be quoted with single or double quotes to avoid subkey traversal on dot characters
       # @param scope [#[]] The primary source of data for substitutions.
       # @param order_override [#[],nil] An override that will be pre-pended to the hierarchy definition.
       # @param resolution_type [Symbol,Hash,nil] One of :hash, :array,:priority or a Hash with deep merge behavior and options
@@ -250,7 +250,7 @@ class Hiera
 
         strategy = resolution_type.is_a?(Hash) ? :hash : resolution_type
 
-        segments = key.split('.')
+        segments = Util.split_key(key) { |problem| ArgumentError.new("#{problem} in key: #{key}") }
         subsegments = nil
         if segments.size > 1
           raise ArgumentError, "Resolution type :#{strategy} is illegal when doing segmented key lookups" unless strategy.nil? || strategy == :priority
@@ -265,7 +265,7 @@ class Hiera
             found_in_backend = false
             new_answer = catch(:no_such_key) do
               if subsegments.nil? 
-                value = backend.lookup(key, scope, order_override, resolution_type, context)
+                value = backend.lookup(segments[0], scope, order_override, resolution_type, context)
               elsif backend.respond_to?(:lookup_with_segments)
                 value = backend.lookup_with_segments(segments, scope, order_override, resolution_type, context)
               else

data/lib/hiera/interpolate.rb

@@ -4,34 +4,51 @@ require 'hiera/recursive_guard'
 
 class Hiera::InterpolationInvalidValue < StandardError; end
 
+# @api private
 class Hiera::Interpolate
+  RX_INTERPOLATION = /%\{([^\}]*)\}/
+  RX_ONLY_INTERPOLATION = /^%\{([^\}]*)\}$/
+  RX_METHOD_AND_ARG = /^(\w+)\(([^)]*)\)$/
+
+  EMPTY_INTERPOLATIONS = {
+    '' => true,
+    '::' => true,
+    '""' => true,
+    "''" => true,
+    '"::"' => true,
+    "'::'" => true
+  }.freeze
+
+  INTERPOLATION_METHODS = {
+    'hiera' => :hiera_interpolate,
+    'scope' => :scope_interpolate,
+    'literal' => :literal_interpolate,
+    'alias' => :alias_interpolate
+  }.freeze
+
   class << self
+    # These two patterns are never used but kept here anyway since they used to be public and therefore
+    # must be considered API. The class is now marked @api private and these should be removed in a
+    # future version
+    #
+    # @deprecated
     INTERPOLATION = /%\{([^\}]*)\}/
+
+    # @deprecated
     METHOD_INTERPOLATION = /%\{(scope|hiera|literal|alias)\(['"]([^"']*)["']\)\}/
 
     def interpolate(data, scope, extra_data, context)
       if data.is_a?(String)
         # Wrapping do_interpolation in a gsub block ensures we process
         # each interpolation site in isolation using separate recursion guards.
-        context ||= {}
-        new_context = context.clone
+        new_context = context.nil? ? {} : context.clone
         new_context[:recurse_guard] ||= Hiera::RecursiveGuard.new
-        data.gsub(INTERPOLATION) do |match|
-          interp_val = do_interpolation(match, scope, extra_data, new_context)
-
-          # Get interp method in case we are aliasing
-          if data.is_a?(String) && (match = data.match(INTERPOLATION))
-            interpolate_method, key = get_interpolation_method_and_key(data, new_context)
-          else
-            interpolate_method = nil
-          end
+        data.gsub(RX_INTERPOLATION) do |match|
+          (interp_val, interpolate_method) = do_interpolation(match, scope, extra_data, new_context)
 
-          if ( (interpolate_method == :alias_interpolate) and (!interp_val.is_a?(String)) )
-            if data.match("^#{INTERPOLATION}$")
-              return interp_val
-            else
-              raise Hiera::InterpolationInvalidValue, "Cannot call alias in the string context"
-            end
+          if (interpolate_method == :alias_interpolate) && !interp_val.is_a?(String)
+            return interp_val if data.match(RX_ONLY_INTERPOLATION)
+            raise Hiera::InterpolationInvalidValue, "Cannot call alias in the string context"
           else
             interp_val
           end
@@ -42,47 +59,45 @@ class Hiera::Interpolate
     end
 
     def do_interpolation(data, scope, extra_data, context)
-      if data.is_a?(String) && (match = data.match(INTERPOLATION))
+      if data.is_a?(String) && (match = data.match(RX_INTERPOLATION))
         interpolation_variable = match[1]
 
         # HI-494
-        case interpolation_variable.strip
-        when '', '::'
-          return ''
-        end
+        return ['', nil] if EMPTY_INTERPOLATIONS[interpolation_variable.strip]
 
         context[:recurse_guard].check(interpolation_variable) do
-          interpolate_method, key = get_interpolation_method_and_key(data, context)
+          interpolate_method, key = get_interpolation_method_and_key(interpolation_variable, context)
           interpolated_data = send(interpolate_method, data, key, scope, extra_data, context)
 
           # Halt recursion if we encounter a literal.
-          return interpolated_data if interpolate_method == :literal_interpolate
+          return [interpolated_data, interpolate_method] if interpolate_method == :literal_interpolate
 
-          do_interpolation(interpolated_data, scope, extra_data, context)
+          [do_interpolation(interpolated_data, scope, extra_data, context)[0], interpolate_method]
         end
       else
-        data
+        [data, nil]
       end
     end
     private :do_interpolation
 
-    def get_interpolation_method_and_key(data, context)
-      if (match = data.match(METHOD_INTERPOLATION))
+    def get_interpolation_method_and_key(interpolation_variable, context)
+      if (match = interpolation_variable.match(RX_METHOD_AND_ARG))
         Hiera.warn('Use of interpolation methods in hiera configuration file is deprecated') if context[:is_interpolate_config]
-        case match[1]
-        when 'hiera' then [:hiera_interpolate, match[2]]
-        when 'scope' then [:scope_interpolate, match[2]]
-        when 'literal' then [:literal_interpolate, match[2]]
-        when 'alias' then [:alias_interpolate, match[2]]
-        end
-      elsif (match = data.match(INTERPOLATION))
-        [:scope_interpolate, match[1]]
+        method = match[1]
+        method_sym = INTERPOLATION_METHODS[method]
+        raise Hiera::InterpolationInvalidValue, "Invalid interpolation method '#{method}'" unless method_sym
+        arg = match[2]
+        match_data = arg.match(Hiera::QUOTED_KEY)
+        raise Hiera::InterpolationInvalidValue, "Argument to interpolation method '#{method}' must be quoted, got '#{arg}'" unless match_data
+        [method_sym, match_data[1] || match_data[2]]
+      else
+        [:scope_interpolate, interpolation_variable]
       end
     end
     private :get_interpolation_method_and_key
 
     def scope_interpolate(data, key, scope, extra_data, context)
-      segments = key.split('.')
+      segments = Hiera::Util.split_key(key) { |problem| Hiera::InterpolationInvalidValue.new("#{problem} in interpolation expression: #{data}") }
       catch(:no_such_key) { return Hiera::Backend.qualified_lookup(segments, scope) }
       catch(:no_such_key) { Hiera::Backend.qualified_lookup(segments, extra_data) }
     end

data/lib/hiera/util.rb

@@ -1,4 +1,9 @@
 class Hiera
+
+  # Matches a key that is quoted using a matching pair of either single or double quotes.
+  QUOTED_KEY = /^(?:"([^"]+)"|'([^']+)')$/
+  QUOTES = /[",]/
+
   module Util
     module_function
 
@@ -42,6 +47,23 @@ class Hiera
     def common_appdata
       Dir::COMMON_APPDATA
     end
+
+    def split_key(key)
+      segments = key.split(/(?:"([^"]+)"|'([^']+)'|([^'".]+))/)
+      if segments.empty?
+        # Only happens if the original key was an empty string
+        ''
+      elsif segments.shift == ''
+        count = segments.size
+        raise yield('Syntax error') unless count > 0
+
+        segments.keep_if { |seg| seg != '.' }
+        raise yield('Syntax error') unless segments.size * 2 == count + 1
+        segments
+      else
+        raise yield('Syntax error')
+      end
+    end
   end
 end
 

data/lib/hiera/version.rb

@@ -7,7 +7,7 @@
 
 
 class Hiera
-  VERSION = "3.1.0"
+  VERSION = "3.1.1"
 
   ##
   # version is a public API method intended to always provide a fast and

data/spec/unit/fixtures/interpolate/config/hiera.yaml

@@ -4,4 +4,8 @@
 :hierarchy:
   - recursive
   - niltest
+  - complex
   - empty_%{}inter%{::}polation
+  - dotted_keys
+  - weird_keys
+  - bad_interpolation

data/spec/unit/fixtures/interpolate/data/bad_interpolation.yaml

@@ -0,0 +1,9 @@
+---
+quote_mismatch: 'Key delimited with singe quote on one side aand double qoute on the other: %{''the.key"}'
+quote_mismatch_arg: 'Arg delimited with singe quote on one side and double qoute on the other: %{hiera(''the.key")}'
+non_existing_method: 'The method flubber does not exist: %{flubber("hello")}'
+
+one_quote: 'Key with only one quote: %{the.''key}'
+empty_segment: 'Key with only one quote: %{the..key}'
+empty_quoted_segment: 'Key with only one quote: %{the.''''.key}'
+partly_quoted_segment: 'Key with only one quote: %{the.''pa''key}'

data/spec/unit/fixtures/interpolate/data/complex.yaml

@@ -0,0 +1,12 @@
+---
+root:
+  a:
+    aa: "%{alias('aaa')}"
+
+aaa:
+  b:
+    bb: "%{alias('bbb')}"
+
+bbb: [ "%{alias('ccc')}" ]
+
+ccc: text

data/spec/unit/fixtures/interpolate/data/dotted_keys.yaml

@@ -0,0 +1,40 @@
+---
+a.b: '(hiera) a dot b'
+a.c.scope: "a dot c: %{'a.b'}"
+a.c.hiera: 'a dot c: %{hiera("''a.b''")}'
+a.c.scope: "a dot c: %{'a.b'}"
+a.c.hiera: 'a dot c: %{hiera("''a.b''")}'
+a.c.alias: '%{alias("''a.b''")}'
+a:
+  d: '(hiera) a dot d is a hash entry'
+  d.x: '(hiera) a dot d.x is a hash entry'
+  d.z:
+    g: '(hiera) a dot d.z dot g is a hash entry'
+
+a.x:
+  d: '(hiera) a.x dot d is a hash entry'
+  d.x: '(hiera) a.x dot d.x is a hash entry'
+  d.z:
+    g: '(hiera) a.x dot d.z dot g is a hash entry'
+
+a.e.scope: "a dot e: %{a.d}"
+a.e.hiera: "a dot e: %{hiera('a.d')}"
+
+a.ex.scope: "a dot ex: %{a.'d.x'}"
+a.ex.hiera: 'a dot ex: %{hiera("a.''d.x''")}'
+
+a.xe.scope: "a dot xe: %{'a.x'.d}"
+a.xe.hiera: 'a dot xe: %{hiera("''a.x''.d")}'
+
+a.xm.scope: "a dot xm: %{a.'d.z'.g}"
+a.xm.hiera: 'a dot xm: %{hiera("a.''d.z''.g")}'
+
+a.xx.scope: "a dot xx: %{'a.x'.'d.z'.g}"
+a.xx.hiera: 'a dot xx: %{hiera("''a.x''.''d.z''.g")}'
+
+a.f.scope: "a dot f: %{'a.d'}"
+a.f.hiera: 'a dot f: %{hiera("''a.d''")}'
+
+x.1: '(hiera) x dot 1'
+x.2.scope: "x dot 2: %{'x.1'}"
+x.2.hiera: 'x dot 2: %{hiera("''x.1''")}'

data/spec/unit/fixtures/interpolate/data/empty_interpolation.yaml

@@ -4,3 +4,10 @@ only_empty_interpolation: '%{}'
 empty_namespace: '%{::}'
 whitespace1: '%{ :: }'
 whitespace2: '%{   }'
+
+quoted_empty_interpolation: 'clown%{""}shoe'
+quoted_escaped_empty_interpolation: 'clown%%{""}{shoe}s'
+quoted_only_empty_interpolation: '%{""}'
+quoted_empty_namespace: '%{"::"}'
+quoted_whitespace1: '%{ "::" }'
+quoted_whitespace2: '%{ "" }'

data/spec/unit/fixtures/interpolate/data/weird_keys.yaml

@@ -0,0 +1,12 @@
+---
+
+'a key with whitespace': 'value for a ws key'
+ws_key: '%{alias("a key with whitespace")}'
+
+'#@!&%|§': 'not happy'
+angry: '%{alias("#@!&%|§")}'
+
+'!$\%!':
+  '#@!&%|§': 'not happy at all'
+
+very_angry: '%{alias("!$\%!.#@!&%|§")}'

data/spec/unit/interpolate_spec.rb

@@ -2,98 +2,233 @@ require 'spec_helper'
 require 'hiera/util'
 
 describe "Hiera" do
-  context "when doing interpolation" do
-    let(:fixtures) { File.join(HieraSpec::FIXTURE_DIR, 'interpolate') }
+  let!(:fixtures) { File.join(HieraSpec::FIXTURE_DIR, 'interpolate') }
+  let!(:fixture_data) { File.join(fixtures, 'data') }
+  let(:hiera) { Hiera.new(:config => File.join(fixtures, 'config', 'hiera.yaml')) }
+
+  before(:each) do
+    Hiera::Util.expects(:var_dir).at_most(3).returns(fixture_data)
+  end
 
+  context "when doing interpolation" do
     it 'should prevent endless recursion' do
-      Hiera::Util.expects(:var_dir).at_least_once.returns(File.join(fixtures, 'data'))
       hiera = Hiera.new(:config => File.join(fixtures, 'config', 'hiera.yaml'))
       expect do
         hiera.lookup('foo', nil, {})
       end.to raise_error Hiera::InterpolationLoop, 'Lookup recursion detected in [hiera("bar"), hiera("foo")]'
     end
+
+    it 'produces a nested hash with arrays from nested aliases with hashes and arrays' do
+      Hiera::Util.expects(:var_dir).at_least_once.returns(File.join(fixtures, 'data'))
+      hiera = Hiera.new(:config => File.join(fixtures, 'config', 'hiera.yaml'))
+      expect(hiera.lookup('root', nil, {}, nil, :hash)).to eq({'a'=>{'aa'=>{'b'=>{'bb'=>['text']}}}})
+    end
+
+    it 'allows keys with white space' do
+      expect(hiera.lookup('ws_key', nil, {})).to eq('value for a ws key')
+    end
+
+    it 'allows keys with non alphanumeric characters' do
+      expect(hiera.lookup('angry', nil, {})).to eq('not happy')
+    end
   end
 
   context "when not finding value for interpolated key" do
-    let(:fixtures) { File.join(HieraSpec::FIXTURE_DIR, 'interpolate') }
-
     it 'should resolve the interpolation to an empty string' do
-      Hiera::Util.expects(:var_dir).at_least_once.returns(File.join(fixtures, 'data'))
-      hiera = Hiera.new(:config => File.join(fixtures, 'config', 'hiera.yaml'))
       expect(hiera.lookup('niltest', nil, {})).to eq('Missing key ##. Key with nil ##')
     end
   end
 
   context "when there are empty interpolations %{} in data" do
-    let(:fixtures) { File.join(HieraSpec::FIXTURE_DIR, 'interpolate') }
-
     it 'should should produce an empty string for the interpolation' do
-      Hiera::Util.expects(:var_dir).at_least_once.returns(File.join(fixtures, 'data'))
-      hiera = Hiera.new(:config => File.join(fixtures, 'config', 'hiera.yaml'))
       expect(hiera.lookup('empty_interpolation', nil, {})).to eq('clownshoe')
     end
 
     it 'the empty interpolation can be escaped' do
-      Hiera::Util.expects(:var_dir).at_least_once.returns(File.join(fixtures, 'data'))
-      hiera = Hiera.new(:config => File.join(fixtures, 'config', 'hiera.yaml'))
       expect(hiera.lookup('escaped_empty_interpolation', nil, {})).to eq('clown%{shoe}s')
     end
 
     it 'the value can consist of only an empty escape' do
-      Hiera::Util.expects(:var_dir).at_least_once.returns(File.join(fixtures, 'data'))
-      hiera = Hiera.new(:config => File.join(fixtures, 'config', 'hiera.yaml'))
       expect(hiera.lookup('only_empty_interpolation', nil, {})).to eq('')
     end
 
     it 'the value can consist of an empty namespace %{::}' do
-      Hiera::Util.expects(:var_dir).at_least_once.returns(File.join(fixtures, 'data'))
-      hiera = Hiera.new(:config => File.join(fixtures, 'config', 'hiera.yaml'))
       expect(hiera.lookup('empty_namespace', nil, {})).to eq('')
     end
 
     it 'the value can consist of whitespace %{ :: }' do
-      Hiera::Util.expects(:var_dir).at_least_once.returns(File.join(fixtures, 'data'))
-      hiera = Hiera.new(:config => File.join(fixtures, 'config', 'hiera.yaml'))
       expect(hiera.lookup('whitespace1', nil, {})).to eq('')
     end
 
     it 'the value can consist of whitespace %{  }' do
-      Hiera::Util.expects(:var_dir).at_least_once.returns(File.join(fixtures, 'data'))
-      hiera = Hiera.new(:config => File.join(fixtures, 'config', 'hiera.yaml'))
       expect(hiera.lookup('whitespace2', nil, {})).to eq('')
     end
   end
 
-  context "when doing interpolation with override" do
-    let(:fixtures) { File.join(HieraSpec::FIXTURE_DIR, 'override') }
+  context 'when there are quoted empty interpolations %{} in data' do
+    it 'should should produce an empty string for the interpolation' do
+      expect(hiera.lookup('quoted_empty_interpolation', nil, {})).to eq('clownshoe')
+    end
+
+    it 'the empty interpolation can be escaped' do
+      expect(hiera.lookup('quoted_escaped_empty_interpolation', nil, {})).to eq('clown%{shoe}s')
+    end
+
+    it 'the value can consist of only an empty escape' do
+      expect(hiera.lookup('quoted_only_empty_interpolation', nil, {})).to eq('')
+    end
+
+    it 'the value can consist of an empty namespace %{::}' do
+      expect(hiera.lookup('quoted_empty_namespace', nil, {})).to eq('')
+    end
+
+    it 'the value can consist of whitespace %{ :: }' do
+      expect(hiera.lookup('quoted_whitespace1', nil, {})).to eq('')
+    end
+
+    it 'the value can consist of whitespace %{  }' do
+      expect(hiera.lookup('quoted_whitespace2', nil, {})).to eq('')
+    end
+  end
+
+  context 'when using dotted keys' do
+    it 'should find an entry using a quoted interpolation' do
+      expect(hiera.lookup('"a.c.scope"', nil, {'a.b' => '(scope) a dot b'})).to eq('a dot c: (scope) a dot b')
+    end
+
+    it 'should find an entry using a quoted interpolation with method hiera' do
+      expect(hiera.lookup('"a.c.hiera"', nil, {'a.b' => '(scope) a dot b'})).to eq('a dot c: (hiera) a dot b')
+    end
+
+    it 'should find an entry using a quoted interpolation with method alias' do
+      expect(hiera.lookup('"a.c.alias"', nil, {'a.b' => '(scope) a dot b'})).to eq('(hiera) a dot b')
+    end
+
+    it 'should use a dotted key to navigate into a structure when it is not quoted' do
+      expect(hiera.lookup('"a.e.scope"', nil, {'a' => { 'd' => '(scope) a dot d is a hash entry'}})).to eq('a dot e: (scope) a dot d is a hash entry')
+    end
+
+    it 'should use a dotted key to navigate into a structure when when it is not quoted with method hiera' do
+      expect(hiera.lookup('"a.e.hiera"', nil, {'a' => { 'd' => '(scope) a dot d is a hash entry'}})).to eq('a dot e: (hiera) a dot d is a hash entry')
+    end
+
+    it 'should use a mix of quoted and dotted keys to navigate into a structure containing dotted keys and quoted key is last' do
+      expect(hiera.lookup('"a.ex.scope"', nil, {'a' => { 'd.x' => '(scope) a dot d.x is a hash entry'}})).to eq('a dot ex: (scope) a dot d.x is a hash entry')
+    end
+
+    it 'should use a mix of quoted and dotted keys to navigate into a structure containing dotted keys and quoted key is last and method is hiera' do
+      expect(hiera.lookup('"a.ex.hiera"', nil, {'a' => { 'd.x' => '(scope) a dot d.x is a hash entry'}})).to eq('a dot ex: (hiera) a dot d.x is a hash entry')
+    end
+
+    it 'should use a mix of quoted and dotted keys to navigate into a structure containing dotted keys and quoted key is first' do
+      expect(hiera.lookup('"a.xe.scope"', nil, {'a.x' => { 'd' => '(scope) a.x dot d is a hash entry'}})).to eq('a dot xe: (scope) a.x dot d is a hash entry')
+    end
+
+    it 'should use a mix of quoted and dotted keys to navigate into a structure containing dotted keys and quoted key is first and method is hiera' do
+      expect(hiera.lookup('"a.xe.hiera"', nil, {'a.x' => { 'd' => '(scope) a.x dot d is a hash entry'}})).to eq('a dot xe: (hiera) a.x dot d is a hash entry')
+    end
+
+    it 'should use a mix of quoted and dotted keys to navigate into a structure containing dotted keys and quoted key is in the middle' do
+      expect(hiera.lookup('"a.xm.scope"', nil, {'a' => { 'd.z' => { 'g' => '(scope) a dot d.z dot g is a hash entry'}}})).to eq('a dot xm: (scope) a dot d.z dot g is a hash entry')
+    end
+
+    it 'should use a mix of quoted and dotted keys to navigate into a structure containing dotted keys and quoted key is in the middle and method is hiera' do
+      expect(hiera.lookup('"a.xm.hiera"', nil, {'a' => { 'd.z' => { 'g' => '(scope) a dot d.z dot g is a hash entry'}}})).to eq('a dot xm: (hiera) a dot d.z dot g is a hash entry')
+    end
+
+    it 'should use a mix of several quoted and dotted keys to navigate into a structure containing dotted keys and quoted key is in the middle' do
+      expect(hiera.lookup('"a.xx.scope"', nil, {'a.x' => { 'd.z' => { 'g' => '(scope) a.x dot d.z dot g is a hash entry'}}})).to eq('a dot xx: (scope) a.x dot d.z dot g is a hash entry')
+    end
+
+    it 'should use a mix of several quoted and dotted keys to navigate into a structure containing dotted keys and quoted key is in the middle and method is hiera' do
+      expect(hiera.lookup('"a.xx.hiera"', nil, {'a.x' => { 'd.z' => { 'g' => '(scope) a.x dot d.z dot g is a hash entry'}}})).to eq('a dot xx: (hiera) a.x dot d.z dot g is a hash entry')
+    end
+
+    it 'should find an entry using using a quoted interpolation on dotted key containing numbers' do
+      expect(hiera.lookup('"x.2.scope"', nil, {'x.1' => '(scope) x dot 1'})).to eq('x dot 2: (scope) x dot 1')
+    end
+
+    it 'should find an entry using using a quoted interpolation on dotted key containing numbers using method hiera' do
+      expect(hiera.lookup('"x.2.hiera"', nil, {'x.1' => '(scope) x dot 1'})).to eq('x dot 2: (hiera) x dot 1')
+    end
+
+    it 'will allow strange characters in the key' do
+      expect(hiera.lookup('very_angry', nil, {})).to eq('not happy at all')
+    end
+
+    it 'should not find a subkey when the dotted key is quoted' do
+      expect(hiera.lookup('"a.f.scope"', nil, {'a' => { 'f' => '(scope) a dot f is a hash entry'}})).to eq('a dot f: ')
+    end
+
+    it 'should not find a subkey when the dotted key is quoted with method hiera' do
+      expect(hiera.lookup('"a.f.hiera"', nil, {'a' => { 'f' => '(scope) a dot f is a hash entry'}})).to eq('a dot f: ')
+    end
+  end
+
+  context 'when bad interpolation expressions are encountered' do
+    it 'should produce an error when different quotes are used on either side' do
+      expect { hiera.lookup('quote_mismatch', nil, {}) }.to raise_error(/Syntax error in interpolation expression: \%\{'the\.key"\}/)
+    end
+
+    it 'should produce an if there is only one quote' do
+      expect { hiera.lookup('one_quote', nil, {}) }.to raise_error(/Syntax error in interpolation expression: \%\{the\.'key\}/)
+    end
+
+    it 'should produce an error for an empty segment' do
+      expect { hiera.lookup('empty_segment', nil, {}) }.to raise_error(/Syntax error in interpolation expression: \%\{the\.\.key\}/)
+    end
+
+    it 'should produce an error for an empty quoted segment' do
+      expect { hiera.lookup('empty_quoted_segment', nil, {}) }.to raise_error(/Syntax error in interpolation expression: \%\{the\.''\.key\}/)
+    end
+
+    it 'should produce an error for an partly quoted segment' do
+      expect { hiera.lookup('partly_quoted_segment', nil, {}) }.to raise_error(/Syntax error in interpolation expression: \%\{the\.'pa'key\}/)
+    end
+
+    it 'should produce an error when different quotes are used on either side in a method argument' do
+      expect { hiera.lookup('quote_mismatch_arg', nil, {}) }.to raise_error(/Argument to interpolation method 'hiera' must be quoted, got ''the.key"'/)
+    end
+
+    it 'should produce an error unless a known interpolation method is used' do
+      expect { hiera.lookup('non_existing_method', nil, {}) }.to raise_error(/Invalid interpolation method 'flubber'/)
+    end
+
+    it 'should produce an error if there is only one quote' do
+      expect { hiera.lookup('one_quote', nil, {}) }.to raise_error(/Syntax error/)
+    end
+
+    it 'should produce an error when different quotes are used on either side in a top-level key' do
+      expect { hiera.lookup("'the.key\"", nil, {}) }.to raise_error(/Syntax error in key: 'the.key"/)
+    end
+  end
+
+  context 'when doing interpolation with override' do
+    let!(:fixtures) { File.join(HieraSpec::FIXTURE_DIR, 'override') }
 
     it 'should resolve interpolation using the override' do
-      Hiera::Util.expects(:var_dir).at_least_once.returns(File.join(fixtures, 'data'))
-      hiera = Hiera.new(:config => File.join(fixtures, 'config', 'hiera.yaml'))
       expect(hiera.lookup('foo', nil, {}, 'alternate')).to eq('alternate')
     end
   end
 
   context 'when doing interpolation in config file' do
-    let(:fixtures) { File.join(HieraSpec::FIXTURE_DIR, 'interpolate') }
+    let(:hiera) { Hiera.new(:config => File.join(fixtures, 'config', 'hiera_iplm_hiera.yaml')) }
 
     it 'should allow and resolve a correctly configured interpolation using "hiera" method' do
-      Hiera::Util.expects(:var_dir).at_least_once.returns(File.join(fixtures, 'data'))
-      hiera = Hiera.new(:config => File.join(fixtures, 'config', 'hiera_iplm_hiera.yaml'))
       expect(hiera.lookup('foo', nil, {})).to eq('Foo')
     end
 
-    it 'should detect interpolation recursion when using "hiera" method' do
-      Hiera::Util.expects(:var_dir).at_least_once.returns(File.join(fixtures, 'data'))
-      hiera = Hiera.new(:config => File.join(fixtures, 'config', 'hiera_iplm_hiera_bad.yaml'))
-      expect{ hiera.lookup('foo', nil, {}) }.to raise_error(Hiera::InterpolationLoop, "Lookup recursion detected in [hiera('role')]")
-    end
-
     it 'should issue warning when interpolation methods are used' do
       Hiera.expects(:warn).with('Use of interpolation methods in hiera configuration file is deprecated').at_least_once
-      Hiera::Util.expects(:var_dir).at_least_once.returns(File.join(fixtures, 'data'))
-      hiera = Hiera.new(:config => File.join(fixtures, 'config', 'hiera_iplm_hiera.yaml'))
       expect(hiera.lookup('foo', nil, {})).to eq('Foo')
     end
   end
+
+  context 'when doing interpolation in bad config file' do
+    let(:hiera) { Hiera.new(:config => File.join(fixtures, 'config', 'hiera_iplm_hiera_bad.yaml')) }
+
+    it 'should detect interpolation recursion when using "hiera" method' do
+      expect{ hiera.lookup('foo', nil, {}) }.to raise_error(Hiera::InterpolationLoop, "Lookup recursion detected in [hiera('role')]")
+    end
+  end
 end

metadata

@@ -1,27 +1,30 @@
 --- !ruby/object:Gem::Specification
 name: hiera
 version: !ruby/object:Gem::Version
-  version: 3.1.0
+  version: 3.1.1
+  prerelease: 
 platform: ruby
 authors:
 - Puppet Labs
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-11 00:00:00.000000000 Z
+date: 2016-03-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json_pure
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
 description: A pluggable data store for hierarcical data
@@ -61,11 +64,15 @@ files:
 - spec/unit/fixtures/interpolate/config/hiera.yaml
 - spec/unit/fixtures/interpolate/config/hiera_iplm_hiera.yaml
 - spec/unit/fixtures/interpolate/config/hiera_iplm_hiera_bad.yaml
+- spec/unit/fixtures/interpolate/data/bad_interpolation.yaml
+- spec/unit/fixtures/interpolate/data/complex.yaml
+- spec/unit/fixtures/interpolate/data/dotted_keys.yaml
 - spec/unit/fixtures/interpolate/data/empty_interpolation.yaml
 - spec/unit/fixtures/interpolate/data/frontend.json
 - spec/unit/fixtures/interpolate/data/niltest.yaml
 - spec/unit/fixtures/interpolate/data/recursive.yaml
 - spec/unit/fixtures/interpolate/data/role.json
+- spec/unit/fixtures/interpolate/data/weird_keys.yaml
 - spec/unit/fixtures/override/config/hiera.yaml
 - spec/unit/fixtures/override/data/alternate.yaml
 - spec/unit/fixtures/override/data/common.yaml
@@ -76,26 +83,27 @@ files:
 - spec/unit/version_spec.rb
 homepage: https://github.com/puppetlabs/hiera
 licenses: []
-metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
   requirements:
-  - - '>='
+  - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
   requirements:
-  - - '>='
+  - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.14
+rubygems_version: 1.8.23
 signing_key: 
-specification_version: 4
+specification_version: 3
 summary: Light weight hierarchical data store
 test_files:
 - spec/spec_helper.rb
@@ -109,11 +117,15 @@ test_files:
 - spec/unit/fixtures/interpolate/config/hiera.yaml
 - spec/unit/fixtures/interpolate/config/hiera_iplm_hiera.yaml
 - spec/unit/fixtures/interpolate/config/hiera_iplm_hiera_bad.yaml
+- spec/unit/fixtures/interpolate/data/bad_interpolation.yaml
+- spec/unit/fixtures/interpolate/data/complex.yaml
+- spec/unit/fixtures/interpolate/data/dotted_keys.yaml
 - spec/unit/fixtures/interpolate/data/empty_interpolation.yaml
 - spec/unit/fixtures/interpolate/data/frontend.json
 - spec/unit/fixtures/interpolate/data/niltest.yaml
 - spec/unit/fixtures/interpolate/data/recursive.yaml
 - spec/unit/fixtures/interpolate/data/role.json
+- spec/unit/fixtures/interpolate/data/weird_keys.yaml
 - spec/unit/fixtures/override/config/hiera.yaml
 - spec/unit/fixtures/override/data/alternate.yaml
 - spec/unit/fixtures/override/data/common.yaml

checksums.yaml

@@ -1,7 +0,0 @@
----
-SHA1:
-  metadata.gz: b028f3d8c5d7d62503173b3a2460efe345866293
-  data.tar.gz: 6fd01d4e6590e18449bc6a70a43c46288e55e7ce
-SHA512:
-  metadata.gz: 35c2f04b974c34ea63366d97b9f74a90bbaba1ee9c6ff6a4189e8965d9bcc72edfe94b944b03d56fc14f059566e5a6570acf086c0396ec91689af49cc8e9f6da
-  data.tar.gz: 0a5dfdc722e1c800339811f74a6e76354b380681f6d727f33285e383ff2a049bac1acaaface1705afea3e8c4e3f8cf205f7d935157f95419962593646877d39c