puppet 4.4.0 → 4.5.0

data/lib/puppet/functions.rb

@@ -290,6 +290,45 @@ module Puppet::Functions
         dispatch(meth_name, &block)
       end
     end
+
+    # Allows types local to the function to be defined to ease the use of complex types
+    # in a 4.x function. Within the given block, calls to `type` can be made with a string
+    # 'AliasType = ExistingType` can be made to define aliases. The defined aliases are
+    # available for further aliases, and in all dispatchers.
+    #
+    # @since 4.5.0
+    # @api public
+    #
+    def self.local_types(&block)
+      if loader.nil?
+        raise ArgumentError, "No loader present. Call create_loaded_function(:myname, loader,...), instead of 'create_function' if running tests"
+      end
+      aliases = LocalTypeAliasesBuilder.new(loader, name)
+      aliases.instance_eval(&block)
+      # Add the loaded types to the builder
+      aliases.local_types.each do |type_alias_expr|
+        # Bind the type alias to the local_loader using the alias
+        t = Puppet::Pops::Loader::TypeDefinitionInstantiator.create_from_model(type_alias_expr, aliases.loader)
+
+        # Also define a method for convenient access to the defined type alias.
+        # Since initial capital letter in Ruby means a Constant these names use a prefix of 
+        # `type`. As an example, the type 'MyType' is accessed by calling `type_MyType`.
+        define_method("type_#{t.name}") { t }
+      end
+      # Store the loader in the class
+      @loader = aliases.loader
+    end
+
+    # Creates a new function instance in the given closure scope (visibility to variables), and a loader
+    # (visibility to other definitions). The created function will either use the `given_loader` or
+    # (if it has local type aliases) a loader that was constructed from the loader used when loading
+    # the function's class.
+    #
+    # TODO: It would be of value to get rid of the second parameter here, but that would break API.
+    #
+    def self.new(closure_scope, given_loader)
+      super(closure_scope, @loader || given_loader)
+    end
   end
 
   # Base class for all functions implemented in the puppet language
@@ -497,6 +536,36 @@ module Puppet::Functions
     end
   end
 
+  # The LocalTypeAliasBuilder is used by the 'local_types' method to collect the individual
+  # type aliases given by the function's author.
+  # 
+  class LocalTypeAliasesBuilder
+    attr_reader :local_types, :parser, :loader
+
+    def initialize(loader, name)
+      @loader = Puppet::Pops::Loader::PredefinedLoader.new(loader, :"local_function_#{name}")
+      @local_types = []
+      # get the shared parser used by puppet's compiler
+      @parser = Puppet::Pops::Parser::EvaluatingParser.singleton()
+    end
+
+    # Defines a local type alias, the given string should be a Puppet Language type alias expression
+    # in string form without the leading 'type' keyword.
+    # Calls to local_type must be made before the first parameter definition or an error will
+    # be raised.
+    # 
+    # @param assignment_string [String] a string on the form 'AliasType = ExistingType'
+    # @api public
+    #
+    def type(assignment_string)
+      result = parser.parse_string("type #{assignment_string}", nil) # no file source :-(
+      unless result.body.kind_of?(Puppet::Pops::Model::TypeAlias)
+        raise ArgumentError, "Expected a type alias assignment on the form 'AliasType = T', got '#{assignment_string}'"
+      end
+      @local_types << result.body
+    end
+  end
+
   private
 
   # @note WARNING: This style of creating functions is not public. It is a system

data/lib/puppet/indirector/catalog/compiler.rb

@@ -254,7 +254,8 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
       raise Puppet::Error, "Unable to find a common checksum type between agent '#{options[:checksum_type]}' and master '#{known_checksum_types}'." unless checksum_type
     end
 
-    str = "Compiled %s for #{node.name}" % [checksum_type ? 'static catalog' : 'catalog']
+    str = "Compiled %s for " % [checksum_type ? 'static catalog' : 'catalog']
+    str += node.name
     str += " in environment #{node.environment}" if node.environment
     config = nil
 
@@ -266,6 +267,8 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
         rescue Puppet::Error => detail
           Puppet.err(detail.to_s) if networked?
           raise
+        ensure
+          Puppet::Type.clear_misses unless Puppet[:always_retry_plugins]
         end
 
         if checksum_type && config.is_a?(model)

data/lib/puppet/indirector/msgpack.rb

@@ -58,7 +58,7 @@ class Puppet::Indirector::Msgpack < Puppet::Indirector::Terminus
     msgpack = nil
 
     begin
-      msgpack = File.read(file)
+      msgpack = Puppet::FileSystem.read(file, :encoding => 'utf-8')
     rescue Errno::ENOENT
       return nil
     rescue => detail

data/lib/puppet/indirector/resource_type/parser.rb

@@ -100,4 +100,9 @@ class Puppet::Indirector::ResourceType::Parser < Puppet::Indirector::Code
     environment.check_for_reparse
     environment.known_resource_types
   end
+
+  def allow_remote_requests?
+    Puppet.deprecation_warning("The resource_type endpoint is deprecated in favor of the environment_classes endpoint. See https://docs.puppet.com/puppetserver/latest/puppet-api/v3/environment_classes.html")
+    super
+  end
 end

data/lib/puppet/indirector/rest.rb

@@ -43,8 +43,12 @@ class Puppet::Indirector::REST < Puppet::Indirector::Terminus
 
   # Provide appropriate headers.
   def headers
+    # yaml is not allowed on the network
+    network_formats = model.supported_formats.reject do |format|
+      [:yaml, :b64_zlib_yaml].include?(format)
+    end
     common_headers = {
-      "Accept"                                     => model.supported_formats.join(", "),
+      "Accept"                                     => network_formats.join(", "),
       Puppet::Network::HTTP::HEADER_PUPPET_VERSION => Puppet.version
     }
 

data/lib/puppet/indirector/terminus.rb

@@ -66,18 +66,18 @@ class Puppet::Indirector::Terminus
       # Yay, class/instance confusion.
       subclass.terminus_type = self.name
 
-      # Our subclass is specifically associated with an indirection.
+      # This subclass is specifically associated with an indirection.
       raise("Invalid name #{longname}") unless names.length > 0
-      indirection_name = names.pop.sub(/^[A-Z]/) { |i| i.downcase }.gsub(/[A-Z]/) { |i| "_#{i.downcase}" }.intern
+      processed_name = names.pop.sub(/^[A-Z]/) { |i| i.downcase }.gsub(/[A-Z]/) { |i| "_#{i.downcase}" }
 
-      if indirection_name == "" or indirection_name.nil?
+      if processed_name.empty?
         raise Puppet::DevError, "Could not discern indirection model from class constant"
       end
 
       # This will throw an exception if the indirection instance cannot be found.
       # Do this last, because it also registers the terminus type with the indirection,
       # which needs the above information.
-      subclass.indirection = indirection_name
+      subclass.indirection = processed_name.intern
 
       # And add this instance to the instance hash.
       Puppet::Indirector::Terminus.register_terminus_class(subclass)

data/lib/puppet/loaders.rb

@@ -10,11 +10,13 @@ module Puppet
       require 'puppet/pops/loader/dependency_loader'
       require 'puppet/pops/loader/null_loader'
       require 'puppet/pops/loader/static_loader'
+      require 'puppet/pops/loader/runtime3_type_loader'
       require 'puppet/pops/loader/ruby_function_instantiator'
       require 'puppet/pops/loader/puppet_function_instantiator'
       require 'puppet/pops/loader/type_definition_instantiator'
       require 'puppet/pops/loader/loader_paths'
       require 'puppet/pops/loader/simple_environment_loader'
+      require 'puppet/pops/loader/predefined_loader'
     end
   end
 

data/lib/puppet/metatype/manager.rb

@@ -20,6 +20,16 @@ module Manager
     }
   end
 
+  # Clears any types that were used but absent when types were last loaded.
+  # @note Used after each catalog compile when always_retry_plugins is false
+  # @api private
+  #
+  def clear_misses
+    unless @types.nil?
+      @types.delete_if {|_, v| v.nil? }
+    end
+  end
+
   # Iterates over all already loaded Type subclasses.
   # @yield [t] a block receiving each type
   # @yieldparam t [Puppet::Type] each defined type
@@ -116,6 +126,10 @@ module Manager
     klass.providerloader.loadall Puppet.lookup(:current_environment)
     klass.providify unless klass.providers.empty?
 
+    loc = block_given? ? block.source_location : nil
+    uri = loc.nil? ? nil : URI("#{Puppet::Util.path_to_uri(loc[0])}?line=#{loc[1]}")
+    Puppet::Pops::Loaders.register_runtime3_type(name, uri)
+
     klass
   end
 
@@ -146,16 +160,19 @@ module Manager
     # We are overwhelmingly symbols here, which usually match, so it is worth
     # having this special-case to return quickly.  Like, 25K symbols vs. 300
     # strings in this method. --daniel 2012-07-17
-    return @types[name] if @types[name]
+    return @types[name] if @types.include? name
 
     # Try mangling the name, if it is a string.
     if name.is_a? String
       name = name.downcase.intern
-      return @types[name] if @types[name]
+      return @types[name] if @types.include? name
     end
     # Try loading the type.
     if typeloader.load(name, Puppet.lookup(:current_environment))
       Puppet.warning "Loaded puppet/type/#{name} but no class was created" unless @types.include? name
+    elsif !Puppet[:always_retry_plugins]
+      # PUP-5482 - Only look for a type once if plugin retry is disabled
+      @types[name] = nil
     end
 
     # ...and I guess that is that, eh.

data/lib/puppet/module.rb

@@ -48,7 +48,7 @@ class Puppet::Module
 
   def self.is_module_namespaced_name?(name)
     # it must match the full module name according to forge validator
-    return true if name =~ /^[a-zA-Z0-9]+[-][a-z][a-z0-9_]*$/   
+    return true if name =~ /^[a-zA-Z0-9]+[-][a-z][a-z0-9_]*$/
     return false
   end
 
@@ -90,7 +90,7 @@ class Puppet::Module
     return false unless Puppet::FileSystem.exist?(metadata_file)
 
     begin
-      metadata =  JSON.parse(File.read(metadata_file))
+      metadata =  JSON.parse(File.read(metadata_file, :encoding => 'utf-8'))
     rescue JSON::JSONError => e
       Puppet.debug("#{name} has an invalid and unparsable metadata.json file.  The parse error: #{e.message}")
       return false
@@ -145,7 +145,7 @@ class Puppet::Module
   end
 
   def load_metadata
-    @metadata = data = JSON.parse(File.read(metadata_file))
+    @metadata = data = JSON.parse(File.read(metadata_file, :encoding => 'utf-8'))
     @forge_name = data['name'].gsub('-', '/') if data['name']
 
     [:source, :author, :version, :license, :dependencies].each do |attr|

data/lib/puppet/module_tool/applications/application.rb

@@ -41,7 +41,7 @@ module Puppet::ModuleTool
         end
 
         if require_metadata && !Puppet::ModuleTool.is_module_root?(@path)
-          raise ArgumentError, "Unable to find metadata.json in module root at #{@path} See https://docs.puppetlabs.com/puppet/latest/reference/modules_publishing.html for required file format."
+          raise ArgumentError, "Unable to find metadata.json in module root at #{@path} See https://docs.puppet.com/puppet/latest/reference/modules_publishing.html for required file format."
         end
 
         metadata_path   = File.join(@path, 'metadata.json')

data/lib/puppet/module_tool/applications/builder.rb

@@ -65,9 +65,9 @@ module Puppet::ModuleTool
           gitignore = File.join(@path, '.gitignore')
 
           if File.file? pmtignore
-            @ignored_files = PathSpec.new File.read(pmtignore)
+            @ignored_files = PathSpec.new Puppet::FileSystem.read(pmtignore, :encoding => 'utf-8')
           elsif File.file? gitignore
-            @ignored_files = PathSpec.new File.read(gitignore)
+            @ignored_files = PathSpec.new Puppet::FileSystem.read(gitignore, :encoding => 'utf-8')
           else
             @ignored_files = PathSpec.new
           end

data/lib/puppet/module_tool/skeleton/templates/generator/Gemfile

@@ -1,6 +1,6 @@
 source ENV['GEM_SOURCE'] || 'https://rubygems.org'
 
-puppetversion = ENV.key?('PUPPET_VERSION') ? "#{ENV['PUPPET_VERSION']}" : ['>= 3.3']
+puppetversion = ENV.key?('PUPPET_VERSION') ? ENV['PUPPET_VERSION'] : ['>= 3.3']
 gem 'metadata-json-lint'
 gem 'puppet', puppetversion
 gem 'puppetlabs_spec_helper', '>= 1.0.0'
@@ -9,6 +9,10 @@ gem 'facter', '>= 1.7.0'
 gem 'rspec-puppet'
 
 # rspec must be v2 for ruby 1.8.7
-if RUBY_VERSION >= '1.8.7' and RUBY_VERSION < '1.9'
+if RUBY_VERSION >= '1.8.7' && RUBY_VERSION < '1.9'
   gem 'rspec', '~> 2.0'
+  gem 'rake', '~> 10.0'
+else
+  # rubocop requires ruby >= 1.9
+  gem 'rubocop'
 end

data/lib/puppet/module_tool/skeleton/templates/generator/Rakefile

@@ -1,17 +1,32 @@
 require 'puppetlabs_spec_helper/rake_tasks'
 require 'puppet-lint/tasks/puppet-lint'
+require 'metadata-json-lint/rake_task'
+
+if RUBY_VERSION >= '1.9'
+  require 'rubocop/rake_task'
+  RuboCop::RakeTask.new
+end
+
 PuppetLint.configuration.send('disable_80chars')
-PuppetLint.configuration.ignore_paths = ["spec/**/*.pp", "pkg/**/*.pp"]
+PuppetLint.configuration.relative = true
+PuppetLint.configuration.ignore_paths = ['spec/**/*.pp', 'pkg/**/*.pp']
 
-desc "Validate manifests, templates, and ruby files"
+desc 'Validate manifests, templates, and ruby files'
 task :validate do
   Dir['manifests/**/*.pp'].each do |manifest|
     sh "puppet parser validate --noop #{manifest}"
   end
-  Dir['spec/**/*.rb','lib/**/*.rb'].each do |ruby_file|
-    sh "ruby -c #{ruby_file}" unless ruby_file =~ /spec\/fixtures/
+  Dir['spec/**/*.rb', 'lib/**/*.rb'].each do |ruby_file|
+    sh "ruby -c #{ruby_file}" unless ruby_file =~ %r{spec/fixtures}
   end
   Dir['templates/**/*.erb'].each do |template|
     sh "erb -P -x -T '-' #{template} | ruby -c"
   end
 end
+
+desc 'Run metadata_lint, lint, validate, and spec tests.'
+task :test do
+  [:metadata_lint, :lint, :validate, :spec].each do |test|
+    Rake::Task[test].invoke
+  end
+end

data/lib/puppet/module_tool/skeleton/templates/generator/{tests → examples}/init.pp.erb

@@ -7,6 +7,6 @@
 # environment (to compare the resulting system state to the desired state).
 #
 # Learn more about module testing here:
-# https://docs.puppetlabs.com/guides/tests_smoke.html
+# https://docs.puppet.com/guides/tests_smoke.html
 #
 include ::<%= metadata.name %>

data/lib/puppet/module_tool/skeleton/templates/generator/spec/classes/init_spec.rb.erb

@@ -1,6 +1,5 @@
 require 'spec_helper'
 describe '<%= metadata.name %>' do
-
   context 'with default values for all parameters' do
     it { should contain_class('<%= metadata.name %>') }
   end

data/lib/puppet/network/auth_config_parser.rb

@@ -4,7 +4,7 @@ module Puppet::Network
 class AuthConfigParser
 
   def self.new_from_file(file)
-    self.new(File.read(file))
+    self.new(Puppet::FileSystem.read(file, :encoding => 'utf-8'))
   end
 
   def initialize(string)

data/lib/puppet/network/http/api/indirected_routes.rb

@@ -104,8 +104,6 @@ class Puppet::Network::HTTP::API::IndirectedRoutes
       raise ArgumentError, "No request key specified in #{uri}"
     end
 
-    key = URI.unescape(key)
-
     [indirection, method, key, params]
   end
 

data/lib/puppet/network/http/api/master/v3/environment.rb

@@ -5,14 +5,18 @@ class Puppet::Network::HTTP::API::Master::V3::Environment
   def call(request, response)
     env_name = request.routing_path.split('/').last
     env = Puppet.lookup(:environments).get(env_name)
+    code_id = request.params[:code_id]
 
     if env.nil?
       raise Puppet::Network::HTTP::Error::HTTPNotFoundError.new("#{env_name} is not a known environment", Puppet::Network::HTTP::Issues::RESOURCE_NOT_FOUND)
     end
 
-    catalog = Puppet::Parser::EnvironmentCompiler.compile(env).to_resource
+    catalog = Puppet::Parser::EnvironmentCompiler.compile(env, code_id).to_resource
 
-    env_graph = {:environment => env.name, :applications => {}}
+    # This reads code_id off the catalog rather than using the one from the
+    # request. There shouldn't really be a case where the two differ, but if
+    # they do, the one from the catalog itself is authoritative.
+    env_graph = {:environment => env.name, :applications => {}, :code_id => catalog.code_id}
     applications = catalog.resources.select do |res|
       type = res.resource_type
       type.is_a?(Puppet::Resource::Type) && type.application?

data/lib/puppet/network/http/rack/rest.rb

@@ -2,6 +2,7 @@ require 'openssl'
 require 'cgi'
 require 'puppet/network/http/handler'
 require 'puppet/util/ssl'
+require 'uri'
 
 class Puppet::Network::HTTP::RackREST
   include Puppet::Network::HTTP::Handler
@@ -79,7 +80,15 @@ class Puppet::Network::HTTP::RackREST
 
   # what path was requested? (this is, without any query parameters)
   def path(request)
-    request.path
+    # The value that Passenger provides for 'path' is escaped
+    # (URL percent-encoded), see
+    # https://github.com/phusion/passenger/blob/release-5.0.26/src/apache2_module/Hooks.cpp#L885
+    # for the implementation as hooked up to an Apache web server.  Code
+    # in the indirector / HTTP layer which consumes this path, however, assumes
+    # that it has already been unescaped, so it is unescaped here.
+    if request.path
+      URI.unescape(request.path)
+    end
   end
 
   # return the request body

data/lib/puppet/parser/ast/pops_bridge.rb

@@ -102,6 +102,10 @@ class Puppet::Parser::AST::PopsBridge
           # The 3x logic calling this will not know what to do with the result, it is compacted away at the end
           instantiate_TypeAlias(d, modname)
           next
+        when Puppet::Pops::Model::TypeMapping
+          # The 3x logic calling this will not know what to do with the result, it is compacted away at the end
+          instantiate_TypeMapping(d, modname)
+          next
         when Puppet::Pops::Model::Application
           instantiate_ApplicationDefinition(d, modname)
         else
@@ -189,7 +193,9 @@ class Puppet::Parser::AST::PopsBridge
     end
 
     def instantiate_ResourceTypeDefinition(o, modname)
-      Puppet::Resource::Type.new(:definition, o.name, @context.merge(args_from_definition(o, modname)))
+      instance = Puppet::Resource::Type.new(:definition, o.name, @context.merge(args_from_definition(o, modname)))
+      Puppet::Pops::Loaders.register_runtime3_type(instance.name, Puppet::Pops::Adapters::SourcePosAdapter.adapt(o).to_uri)
+      instance
     end
 
     def instantiate_CapabilityMapping(o, modname)
@@ -262,12 +268,23 @@ class Puppet::Parser::AST::PopsBridge
       loader = Puppet::Pops::Loaders.find_loader(modname)
 
       # Bind the type alias to the loader using the alias
-      typed_name, t = Puppet::Pops::Loader::TypeDefinitionInstantiator.create_from_model(type_alias, loader)
-      loader.set_entry(typed_name, t, Puppet::Pops::Adapters::SourcePosAdapter.adapt(type_alias).to_uri)
+      Puppet::Pops::Loader::TypeDefinitionInstantiator.create_from_model(type_alias, loader)
 
       nil # do not want the type alias to inadvertently leak into 3x
     end
 
+    # Adds the TypeMapping to the ImplementationRegistry
+    # This is for 4x evaluator/loader
+    #
+    def instantiate_TypeMapping(type_mapping, modname)
+      loader = Puppet::Pops::Loaders.find_loader(modname)
+      tf = Puppet::Pops::Types::TypeParser.new
+      lhs = tf.interpret(type_mapping.type_expr, loader)
+      rhs = tf.interpret_any(type_mapping.mapping_expr, loader)
+      Puppet::Pops::Loaders.implementation_registry.register_type_mapping(lhs, rhs, loader)
+      nil
+    end
+
     def code()
       Expression.new(:value => @value)
     end

data/lib/puppet/parser/compiler/catalog_validator/relationship_validator.rb

@@ -15,9 +15,31 @@ class Puppet::Parser::Compiler
 
     private
 
+    # A hash lookup is 6x avg times faster than find among 3 values.
+    CAPABILITY_ACCEPTED_METAPARAMS = {:require => true, :consume => true, :export => true}.freeze
+
     def validate_relationship(param)
-      unless [:require, :consume, :export].find {|pname| pname == param.name }
-        raise CatalogValidationError.new("'#{param.name}' is not a valid relationship to a capability", param.file, param.line) if has_capability?(param.value)
+      # when relationship is to a capability
+      if has_capability?(param.value)
+        unless CAPABILITY_ACCEPTED_METAPARAMS[param.name]
+          raise CatalogValidationError.new(
+            "'#{param.name}' is not a valid relationship to a capability", 
+              param.file, param.line)
+        end
+      elsif Puppet[:strict] != :off
+        # all other relationships requires the referenced resource to exist when mode is strict
+        refs = param.value.is_a?(Array) ? param.value.flatten : [param.value]
+        refs.each do |r|
+          next if r.nil?
+          unless catalog.resource(r.to_s)
+            msg = "Could not find resource '#{r.to_s}' in parameter '#{param.name.to_s}'"
+            if Puppet[:strict] == :error
+              raise CatalogValidationError.new(msg, param.file, param.line)
+            else
+              Puppet.warn_once(:undefined_resources, r.to_s, msg, param.file, param.line)
+            end
+          end
+        end
       end
     end
 

data/lib/puppet/parser/e4_parser_adapter.rb

@@ -1,16 +1,16 @@
 require 'puppet/pops'
 
-module Puppet; module Parser; end; end;
+module Puppet
+module Parser
 # Adapts an egrammar/eparser to respond to the public API of the classic parser
 # and makes use of the new evaluator.
 #
-class Puppet::Parser::E4ParserAdapter
+class E4ParserAdapter
 
   def initialize
     @file = ''
     @string = ''
     @use = :unspecified
-    @@evaluating_parser ||= Puppet::Pops::Parser::EvaluatingParser.new()
   end
 
   def file=(file)
@@ -20,15 +20,15 @@ class Puppet::Parser::E4ParserAdapter
 
   def parse(string = nil)
     self.string= string if string
-
+    parser = Pops::Parser::EvaluatingParser.singleton
     parse_result =
     if @use == :string
       # Parse with a source_file to set in created AST objects (it was either given, or it may be unknown
       # if caller did not set a file and the present a string.
       #
-      @@evaluating_parser.parse_string(@string, @file || "unknown-source-location")
+      parser.parse_string(@string, @file || "unknown-source-location")
     else
-      @@evaluating_parser.parse_file(@file)
+      parser.parse_file(@file)
     end
 
     # the parse_result may be
@@ -38,19 +38,18 @@ class Puppet::Parser::E4ParserAdapter
     #
     model = parse_result.nil? ? nil : parse_result.current
     args = {}
-    Puppet::Pops::Model::AstTransformer.new(@file).merge_location(args, model)
+    Pops::Model::AstTransformer.new(@file).merge_location(args, model)
 
     ast_code =
-    if model.is_a? Puppet::Pops::Model::Program
-      Puppet::Parser::AST::PopsBridge::Program.new(model, args)
+    if model.is_a? Pops::Model::Program
+      AST::PopsBridge::Program.new(model, args)
     else
       args[:value] = model
-      Puppet::Parser::AST::PopsBridge::Expression.new(args)
+      AST::PopsBridge::Expression.new(args)
     end
 
     # Create the "main" class for the content - this content will get merged with all other "main" content
-    Puppet::Parser::AST::Hostclass.new('', :code => ast_code)
-
+    AST::Hostclass.new('', :code => ast_code)
   end
 
   def string=(string)
@@ -58,3 +57,5 @@ class Puppet::Parser::E4ParserAdapter
     @use = :string
   end
 end
+end
+end

data/lib/puppet/parser/environment_compiler.rb

@@ -1,13 +1,13 @@
 require 'puppet/parser/compiler'
 
 class Puppet::Parser::EnvironmentCompiler < Puppet::Parser::Compiler
-  def self.compile(env)
+  def self.compile(env, code_id=nil)
     begin
       env.check_for_reparse
 
       node = Puppet::Node.new(env)
       node.environment = env
-      new(node).compile
+      new(node, :code_id => code_id).compile
     rescue => detail
       message = "#{detail} in environment #{env.name}"
       Puppet.log_exception(detail, message)

data/lib/puppet/parser/functions/hiera_include.rb

@@ -6,7 +6,7 @@ module Puppet::Parser::Functions
     :arity => -2,
     :doc => <<-DOC
 Assigns classes to a node using an
-[array merge lookup](https://docs.puppetlabs.com/hiera/latest/lookup_types.htmlarray-merge)
+[array merge lookup](https://docs.puppetlabs.com/hiera/latest/lookup_types.html#array-merge)
 that retrieves the value for a user-specified key from Hiera's data.
 
 The `hiera_include` function requires:
@@ -31,7 +31,7 @@ top of the hierarchy. This lets you temporarily modify the hierarchy for a singl
     searching the rest of the hierarchy.
 
 The function uses an
-[array merge lookup](https://docs.puppetlabs.com/hiera/latest/lookup_types.htmlarray-merge)
+[array merge lookup](https://docs.puppetlabs.com/hiera/latest/lookup_types.html#array-merge)
 to retrieve the `classes` array, so every node gets every class from the hierarchy.
 
 **Example**: Using `hiera_include`

data/lib/puppet/parser/functions/inline_epp.rb

@@ -29,7 +29,7 @@ parameter tag without default values. Puppet produces an error if the
 `inline_epp` function fails to pass any required parameter.
 
 An inline EPP template should be written as a single-quoted string or
-[heredoc](puppet/latest/reference/lang_data_string.html#heredocs).
+[heredoc](/puppet/latest/reference/lang_data_string.html#heredocs).
 A double-quoted string is subject to expression interpolation before the string
 is parsed as an EPP template.
 

data/lib/puppet/parser/functions/lookup.rb

@@ -101,9 +101,6 @@ but can adjust the merge with additional options. The available options are:
     disables this feature.
     * `'sort_merged_arrays'` (boolean) --- Whether to sort all arrays that are
     merged together. Defaults to `false`.
-    * `'unpack_arrays'` (string or undef) --- A delimiter string; Puppet will
-    join merged arrays with this delimiter, then split them again. Defaults to
-    `undef`, which disables this feature.
     * `'merge_hash_arrays'` (boolean) --- Whether to merge hashes within arrays.
     Defaults to `false`.
 

data/lib/puppet/parser/resource.rb

@@ -182,11 +182,20 @@ class Puppet::Parser::Resource < Puppet::Resource
   alias []= set_parameter
 
   def to_hash
-    @parameters.inject({}) do |hash, ary|
-      param = ary[1]
-      # Skip "undef" and nil values.
-      hash[param.name] = param.value if param.value != :undef && !param.value.nil?
-      hash
+    @parameters.reduce({}) do |result, (_, param)|
+      value = param.value
+      value = (value == :undef) ? nil : value
+
+      unless value.nil?
+        case param.name
+        when :before, :subscribe, :notify, :require
+          value = value.flatten if value.is_a?(Array)
+          result[param.name] = value
+        else
+          result[param.name] = value
+        end
+      end
+      result
     end
   end