puppet 4.9.1-universal-darwin → 4.9.2-universal-darwin

data/Gemfile

@@ -64,6 +64,7 @@ group(:development, :test) do
   gem 'webmock', '~> 1.24'
   gem 'vcr', '~> 2.9'
   gem "hocon", :require => false
+  gem "hiera-eyaml", :require => false
 end
 
 group(:development) do

data/lib/puppet/forge/repository.rb

@@ -45,7 +45,7 @@ class Puppet::Forge
     # Return a Net::HTTPResponse read for this +path+.
     def make_http_request(path, io = nil)
       Puppet.debug "HTTP GET #{@host}#{path}"
-      request = get_request_object(path)
+      request = get_request_object(@uri.path.chomp('/')+path)
       return read_response(request, io)
     end
 

data/lib/puppet/functions/assert_type.rb

@@ -50,7 +50,7 @@
 #
 # @since 4.0.0
 #
-Puppet::Functions.create_function(:assert_type, Puppet::Functions::InternalFunction) do
+Puppet::Functions.create_function(:assert_type) do
   dispatch :assert_type do
     param 'Type', :type
     param 'Any', :value
@@ -58,7 +58,6 @@ Puppet::Functions.create_function(:assert_type, Puppet::Functions::InternalFunct
   end
 
   dispatch :assert_type_s do
-    scope_param
     param 'String', :type_string
     param 'Any', :value
     optional_block_param 'Callable[Type, Type]', :block
@@ -84,12 +83,11 @@ Puppet::Functions.create_function(:assert_type, Puppet::Functions::InternalFunct
     value
   end
 
-  # @param scope [Puppet::Parser::Scope] scope used when obtaining loader for defined types
   # @param type_string [String] the type the value must be an instance of given in String form
   # @param value [Object] the value to assert
   #
-  def assert_type_s(scope, type_string, value, &proc)
-    t = Puppet::Pops::Types::TypeParser.singleton.parse(type_string, scope)
+  def assert_type_s(type_string, value, &proc)
+    t = Puppet::Pops::Types::TypeParser.singleton.parse(type_string)
     block_given? ? assert_type(t, value, &proc) : assert_type(t, value)
   end
 end

data/lib/puppet/functions/yaml_data.rb

@@ -10,7 +10,12 @@ Puppet::Functions.create_function(:yaml_data) do
 
   def yaml_data(options, context)
     begin
-      data = YAML.load_file(options['path'])
+      path = options['path']
+      data = YAML.load_file(path)
+      unless data.is_a?(Hash)
+        Puppet.warning("#{path}: file does not contain a valid yaml hash")
+        data = {}
+      end
       Puppet::Pops::Lookup::HieraConfig.symkeys_to_string(data.nil? ? {} : data)
     rescue YAML::SyntaxError => ex
       # Psych errors includes the absolute path to the file, so no need to add that

data/lib/puppet/pops/adapters.rb

@@ -118,19 +118,18 @@ module Adapters
 
     # Finds the loader to use when loading originates from the source position of the given argument.
     #
-    # @param [Model::PopsObject] instance The model object
-    # @param [Puppet::Parser::Scope] scope The scope to use
-    # @param [String] file the file from where the model was parsed
-    # @return [Loader,nil] the found loader or `nil` if it could not be found
+    # @param instance [Model::PopsObject] The model object
+    # @param file [String] the file from where the model was parsed
+    # @param default_loader [Loader] the loader to return if no loader is found for the model
+    # @return [Loader] the found loader or default_loader if it could not be found
     #
-    def self.loader_for_model_object(model, scope, file = nil)
-      if scope.nil?
-        loaders = Puppet.lookup(:loaders) { nil }
-        loaders.nil? ? nil : loaders.private_environment_loader
+    def self.loader_for_model_object(model, file = nil, default_loader = nil)
+      loaders = Puppet.lookup(:loaders) { nil }
+      if loaders.nil?
+        default_loader
       else
-        loaders = scope.compiler.loaders
-        loader_name = loader_name_by_source(scope.environment, model, file)
-        loader_name.nil? ? loaders.private_environment_loader : loaders[loader_name]
+        loader_name = loader_name_by_source(loaders.environment, model, file)
+        loader_name.nil? ? default_loader || loaders.find_loader(nil) : loaders[loader_name]
       end
     end
 

data/lib/puppet/pops/evaluator/evaluator_impl.rb

@@ -309,7 +309,7 @@ class EvaluatorImpl
   # A QualifiedReference (i.e. a  capitalized qualified name such as Foo, or Foo::Bar) evaluates to a PType
   #
   def eval_QualifiedReference(o, scope)
-    type = Types::TypeParser.singleton.interpret(o, scope)
+    type = Types::TypeParser.singleton.interpret(o)
     fail(Issues::UNKNOWN_RESOURCE_TYPE, o, {:type_name => type.type_string }) if type.is_a?(Types::PTypeReferenceType)
     type
   end
@@ -473,7 +473,7 @@ class EvaluatorImpl
     keys = o.keys || []
     if left.is_a?(Types::PHostClassType)
       # Evaluate qualified references without errors no undefined types
-      keys = keys.map {|key| key.is_a?(Model::QualifiedReference) ? Types::TypeParser.singleton.interpret(key, scope) : evaluate(key, scope) }
+      keys = keys.map {|key| key.is_a?(Model::QualifiedReference) ? Types::TypeParser.singleton.interpret(key) : evaluate(key, scope) }
     else
       keys = keys.map {|key| evaluate(key, scope) }
       # Resource[File] becomes File

data/lib/puppet/pops/evaluator/relationship_operator.rb

@@ -56,7 +56,7 @@ class RelationshipOperator
   # A string must be a type reference in string format
   # @api private
   def transform_String(o, scope)
-    assert_catalog_type(Types::TypeParser.singleton.parse(o, scope), scope)
+    assert_catalog_type(Types::TypeParser.singleton.parse(o), scope)
   end
 
   # A qualified name is short hand for a class with this name

data/lib/puppet/pops/evaluator/runtime3_support.rb

@@ -277,7 +277,7 @@ module Runtime3Support
 
   def call_function(name, args, o, scope, &block)
     file, line = extract_file_line(o)
-    loader = Adapters::LoaderAdapter.loader_for_model_object(o, scope, file)
+    loader = Adapters::LoaderAdapter.loader_for_model_object(o, file)
     if loader && func = loader.load(:function, name)
       Puppet::Util::Profiler.profile(name, [:functions, name]) do
         # Add stack frame when calling. See Puppet::Pops::PuppetStack

data/lib/puppet/pops/loader/loader_paths.rb

@@ -110,7 +110,10 @@ module Puppet::Pops::Loader::LoaderPaths
       # Puppet name to path always skips the name-space as that is part of the generic path
       # i.e. <module>/mymodule/functions/foo.pp is the function mymodule::foo
       parts = typed_name.name_parts
-      parts = parts[start_index_in_name..-1] if parts.size > 1
+      if start_index_in_name > 0
+        return nil if start_index_in_name >= parts.size
+        parts = parts[start_index_in_name..-1]
+      end
       "#{File.join(generic_path, parts)}.pp"
     end
   end

data/lib/puppet/pops/loaders.rb

@@ -16,6 +16,7 @@ class Loaders
   attr_reader :public_environment_loader
   attr_reader :private_environment_loader
   attr_reader :implementation_registry
+  attr_reader :environment
 
   def self.new(environment, for_agent = false)
     obj = environment.loaders
@@ -30,6 +31,7 @@ class Loaders
     # Protect against environment havoc
     raise ArgumentError.new("Attempt to redefine already initialized loaders for environment") unless environment.loaders.nil?
     environment.loaders = self
+    @environment = environment
     @loaders_by_name = {}
 
     add_loader_by_name(self.class.static_loader)

data/lib/puppet/pops/lookup/environment_data_provider.rb

@@ -11,8 +11,16 @@ class EnvironmentDataProvider < ConfiguredDataProvider
   protected
 
   def assert_config_version(config)
-    raise Puppet::DataBinding::LookupError, "#{config.name} cannot be used in an environment" unless config.version > 3
-    config
+    if config.version > 3
+      config
+    else
+      if Puppet[:strict] == :error
+        raise Puppet::DataBinding::LookupError, "#{config.name} cannot be used in an environment"
+      else
+        Puppet.warn_once(:hiera_v3_at_env_root, config.config_path, 'hiera.yaml version 3 found at the environment root was ignored')
+      end
+      nil
+    end
   end
 
   # Return the root of the environment

data/lib/puppet/pops/lookup/hiera_config.rb

@@ -12,11 +12,11 @@ class ScopeLookupCollectingInvocation < Invocation
 
   def initialize(scope)
     super(scope)
-    @scope_interpolations = {}
+    @scope_interpolations = []
   end
 
-  def remember_scope_lookup(key, value)
-    @scope_interpolations[key] = value
+  def remember_scope_lookup(*lookup_result)
+    @scope_interpolations << lookup_result
   end
 end
 
@@ -155,20 +155,28 @@ class HieraConfig
   # @param parent_data_provider [DataProvider] The data provider that loaded this configuration
   # @return [Array<DataProvider>] the data providers
   def configured_data_providers(lookup_invocation, parent_data_provider)
-    scope = lookup_invocation.scope
-    unless @data_providers && scope_interpolations_stable?(scope)
+    unless @data_providers && scope_interpolations_stable?(lookup_invocation)
       if @data_providers
         lookup_invocation.report_text { 'Hiera configuration recreated due to change of scope variables used in interpolation expressions' }
       end
-      slc_invocation = ScopeLookupCollectingInvocation.new(scope)
+      slc_invocation = ScopeLookupCollectingInvocation.new(lookup_invocation.scope)
       @data_providers = create_configured_data_providers(slc_invocation, parent_data_provider)
       @scope_interpolations = slc_invocation.scope_interpolations
     end
     @data_providers
   end
 
-  def scope_interpolations_stable?(scope)
-    @scope_interpolations.all? { |key, value| scope[key].eql?(value) }
+  def scope_interpolations_stable?(lookup_invocation)
+    scope = lookup_invocation.scope
+    @scope_interpolations.all? do |key, root_key, segments, old_value|
+      value = scope[root_key]
+      unless value.nil? || segments.empty?
+        found = '';
+        catch(:no_such_key) { found = sub_lookup(key, lookup_invocation, segments, value) }
+        value = found;
+      end
+      old_value.eql?(value)
+    end
   end
 
   # @api private
@@ -207,6 +215,30 @@ class HieraConfig
         Hiera.logger = 'puppet'
       end
     end
+
+    unless Hiera::Interpolate.const_defined?(:PATCHED_BY_HIERA_5)
+      # Replace the class methods 'hiera_interpolate' and 'alias_interpolate' with a method that wires back and performs global
+      # lookups using the lookup framework. This is necessary since the classic Hiera is made aware only of custom backends.
+      class << Hiera::Interpolate
+        hiera_interpolate = Proc.new do |data, key, scope, extra_data, context|
+          override = context[:order_override]
+          invocation = Puppet::Pops::Lookup::Invocation.current
+          unless override.nil? && invocation.global_only?
+            invocation = Puppet::Pops::Lookup::Invocation.new(scope)
+            invocation.set_global_only
+            invocation.set_hiera_v3_location_overrides(override) unless override.nil?
+          end
+          Puppet::Pops::Lookup::LookupAdapter.adapt(scope.compiler).lookup(key, invocation, nil)
+        end
+
+        send(:remove_method, :hiera_interpolate)
+        send(:remove_method, :alias_interpolate)
+        send(:define_method, :hiera_interpolate, hiera_interpolate)
+        send(:define_method, :alias_interpolate, hiera_interpolate)
+      end
+      Hiera::Interpolate.send(:const_set, :PATCHED_BY_HIERA_5, true)
+    end
+
     Hiera::Config.instance_variable_set(:@config, hiera3_config)
 
     # Use a special lookup_key that delegates to the backend

data/lib/puppet/pops/lookup/interpolation.rb

@@ -20,7 +20,9 @@ module Interpolation
     when Array
       value.map { |element| interpolate(element, context, allow_methods) }
     when Hash
-      Hash[value.map { |k, v| [k, interpolate(v, context, allow_methods)] }]
+      result = {}
+      value.each_pair { |k, v| result[interpolate(k, context, allow_methods)] = interpolate(v, context, allow_methods) }
+      result
     else
       value
     end
@@ -95,7 +97,7 @@ module Interpolation
           catch(:no_such_key) { found = sub_lookup(key, lookup_invocation, segments, value) }
           value = found;
         end
-        lookup_invocation.remember_scope_lookup(key, value)
+        lookup_invocation.remember_scope_lookup(key, root_key, segments, value)
         value
       end
 

data/lib/puppet/pops/lookup/invocation.rb

@@ -74,7 +74,7 @@ class Invocation
     rescue Puppet::DataBinding::LookupError
       raise
     rescue Puppet::Error => detail
-      raise Puppet::DataBinding::LookupError.new(detail.message, detail)
+      raise Puppet::DataBinding::LookupError.new(detail.message, nil, nil, nil, detail)
     ensure
       @name_stack.pop
     end
@@ -93,7 +93,7 @@ class Invocation
   # values that the configuration was based on
   #
   # @api private
-  def remember_scope_lookup(key, value)
+  def remember_scope_lookup(*lookup_result)
     # Does nothing by default
   end
 

data/lib/puppet/pops/lookup/lookup_adapter.rb

@@ -318,7 +318,10 @@ class LookupAdapter < DataAdapter
     if mod.has_hiera_conf?
       mp = ModuleDataProvider.new(module_name)
       # A version 5 hiera.yaml trumps a data provider setting or binding in the module
-      if mp.config(lookup_invocation).version >= 5
+      mp_config = mp.config(lookup_invocation)
+      if mp_config.nil?
+        mp = nil
+      elsif mp_config.version >= 5
         unless provider_name.nil? || Puppet[:strict] == :off
           if binding
             Puppet.warn_once(:deprecation, "ModuleBinding#data_provider-#{module_name}",
@@ -388,7 +391,10 @@ class LookupAdapter < DataAdapter
     if config_path.exist?
       ep = EnvironmentDataProvider.new
       # A version 5 hiera.yaml trumps any data provider setting in the environment.conf
-      if ep.config(lookup_invocation).version >= 5
+      ep_config = ep.config(lookup_invocation)
+      if ep_config.nil?
+        ep = nil
+      elsif ep_config.version >= 5
         unless provider_name.nil? || Puppet[:strict] == :off
           Puppet.warn_once(:deprecation, 'environment.conf#data_provider',
             "Defining environment_data_provider='#{provider_name}' in environment.conf is deprecated", env_path + 'environment.conf')

data/lib/puppet/pops/lookup/lookup_key_function_provider.rb

@@ -97,13 +97,17 @@ class V3BackendFunctionProvider < LookupKeyFunctionProvider
       # Equivalent to Hiera :hash with default :native merge behavior. A Hash must be passed here
       # to override possible Hiera deep merge config settings.
       { :behavior => :native }
-    when 'deep'
+    when 'deep', 'unconstrained_deep'
       # Equivalent to Hiera :hash with :deeper merge behavior.
       { :behavior => :deeper }
+    when 'reverse_deep'
+      # Equivalent to Hiera :hash with :deep merge behavior.
+      { :behavior => :deep }
     when Hash
       strategy = merge['strategy']
-      if strategy == 'deep'
-        result = { :behavior => :deeper }
+      case strategy
+      when 'deep', 'unconstrained_deep', 'reverse_deep'
+        result = { :behavior => strategy == 'reverse_deep' ? :deep : :deeper }
         # Remaining entries must have symbolic keys
         merge.each_pair { |k,v| result[k.to_sym] = v unless k == 'strategy' }
         result

data/lib/puppet/pops/merge_strategy.rb

@@ -380,7 +380,7 @@ module Puppet::Pops
     end
 
     def value_t
-      @value_t ||= Types::TypeParser.singleton.parse('Variant[Array[Data],Hash[String,Data]]')
+      @value_t ||= Types::PAnyType::DEFAULT
     end
 
     MergeStrategy.add_strategy(self)

data/lib/puppet/pops/types/type_parser.rb

@@ -25,9 +25,9 @@ class TypeParser
   #     parser.parse('Array[String]')
   #     parser.parse('Hash[Integer, Array[String]]')
   #
-  # @param string [String] a string with the type expressed in stringified form as produced by the 
+  # @param string [String] a string with the type expressed in stringified form as produced by the
   #   types {"#to_s} method.
-  # @param context [Puppet::Parser::Scope,Loader::Loader] scope or loader to use when loading type aliases
+  # @param context [Loader::Loader] optional loader used as no adapted loader is found
   # @return [PAnyType] a specialization of the PAnyType representing the type.
   #
   # @api public
@@ -44,11 +44,11 @@ class TypeParser
   end
 
   # @param ast [Puppet::Pops::Model::PopsObject] the ast to interpret
-  # @param context [Puppet::Parser::Scope,Loader::Loader, nil] scope or loader to use when loading type aliases
+  # @param context [Loader::Loader] optional loader used when no adapted loader is found
   # @return [PAnyType] a specialization of the PAnyType representing the type.
   #
   # @api public
-  def interpret(ast, context)
+  def interpret(ast, context = nil)
     result = @type_transformer.visit_this_1(self, ast, context)
     raise_invalid_type_specification_error(ast) unless result.is_a?(PAnyType)
     result
@@ -200,13 +200,7 @@ class TypeParser
 
   # @api private
   def loader_from_context(ast, context)
-    if context.nil?
-      nil
-    elsif context.is_a?(Puppet::Pops::Loader::Loader)
-      context
-    else
-      Puppet::Pops::Adapters::LoaderAdapter.loader_for_model_object(ast, context)
-    end
+    Adapters::LoaderAdapter.loader_for_model_object(ast, nil, context)
   end
 
   # @api private

data/lib/puppet/ssl/certificate.rb

@@ -69,7 +69,7 @@ DOC
     # is where the extensions are stored."
     @extensions_tag ||= 3
 
-    @exts_seq ||= OpenSSL::ASN1.decode(content.to_der).value[0].find do |data|
+    @exts_seq ||= OpenSSL::ASN1.decode(content.to_der).value[0].value.find do |data|
       (data.tag == @extensions_tag) && (data.tag_class == :CONTEXT_SPECIFIC)
     end.value[0]
   end

data/lib/puppet/ssl/certificate_request.rb

@@ -204,7 +204,7 @@ DOC
     end
 
     x509_attributes.map do |attr|
-      {"oid" => attr.oid, "value" => attr.value.first.value}
+      {"oid" => attr.oid, "value" => attr.value.value.first.value}
     end
   end
 

data/lib/puppet/version.rb

@@ -7,7 +7,7 @@
 
 
 module Puppet
-  PUPPETVERSION = '4.9.1'
+  PUPPETVERSION = '4.9.2'
 
   ##
   # version is a public API method intended to always provide a fast and

data/spec/lib/puppet_spec/language.rb

@@ -21,7 +21,9 @@ module PuppetSpec::Language
 
           compiler.send(:instance_variable_set, :@catalog, catalog)
 
-          expect(evaluator.evaluate_string(compiler.topscope, resources)).to eq(true)
+          Puppet.override(:loaders => compiler.loaders) do
+            expect(evaluator.evaluate_string(compiler.topscope, resources)).to eq(true)
+          end
         when Array
           catalog = PuppetSpec::Compiler.compile_to_catalog(manifest)
 

data/spec/unit/face/module/search_spec.rb

@@ -171,7 +171,7 @@ describe "puppet module search" do
       end
     end
 
-    it "should accept the --module-repository option" do
+    it "should accept the --module_repository option" do
       forge = mock("Puppet::Forge")
       searcher = mock("Searcher")
       options[:module_repository] = "http://forge.example.com"

data/spec/unit/forge/repository_spec.rb

@@ -6,6 +6,11 @@ require 'puppet/forge/cache'
 require 'puppet/forge/errors'
 
 describe Puppet::Forge::Repository do
+  before(:all) do
+    # any local http proxy will break these tests
+    ENV['http_proxy'] = nil
+    ENV['HTTP_PROXY'] = nil
+  end
   let(:agent) { "Test/1.0" }
   let(:repository) { Puppet::Forge::Repository.new('http://fake.com', agent) }
   let(:ssl_repository) { Puppet::Forge::Repository.new('https://fake.com', agent) }
@@ -43,6 +48,28 @@ describe Puppet::Forge::Repository do
       expect(repository.make_http_request("the_path")).to eq(result)
     end
 
+    it "merges forge URI and path specified" do
+      result = "#{Object.new}"
+
+      performs_an_http_request result do |http|
+        http.expects(:request).with(responds_with(:path, "/test/the_path/"))
+      end
+
+      repository = Puppet::Forge::Repository.new('http://fake.com/test', agent)
+      expect(repository.make_http_request("/the_path/")).to eq(result)
+    end
+
+    it "handles trailing slashes when merging URI and path" do
+      result = "#{Object.new}"
+
+      performs_an_http_request result do |http|
+        http.expects(:request).with(responds_with(:path, "/test/the_path"))
+      end
+
+      repository = Puppet::Forge::Repository.new('http://fake.com/test/', agent)
+      expect(repository.make_http_request("/the_path")).to eq(result)
+    end
+
     it 'returns the result object from a request with ssl' do
       result = "#{Object.new}"
       performs_an_https_request result do |http|