puppet 5.3.7-x64-mingw32 → 5.4.0-x64-mingw32

data/lib/puppet/environments.rb

@@ -138,6 +138,23 @@ module Puppet::Environments
     end
   end
 
+  class StaticDirectory < Static
+    # Accepts a single environment in the given directory having the given name (not required to be reflected as the name
+    # of the directory)
+    # 
+    def initialize(env_name, env_dir, environment)
+      super(environment)
+      @env_dir = env_dir
+      @env_name = env_name
+    end
+
+    # @!macro loader_get_conf
+    def get_conf(name)
+      return nil unless name == @env_name
+      Puppet::Settings::EnvironmentConf.load_from(@env_dir, '')
+    end
+  end
+
   # Reads environments from a directory on disk. Each environment is
   # represented as a sub-directory. The environment's manifest setting is the
   # `manifest` directory of the environment directory. The environment's

data/lib/puppet/error.rb

@@ -68,6 +68,23 @@ module Puppet
       msg = _("%{message} on node %{node}") % { message: msg, node: node } if node
       msg
     end
+
+    def self.from_issue_and_stack(issue, args = {})
+      stacktrace = Puppet::Pops::PuppetStack.stacktrace()
+      if stacktrace.size > 0
+        filename, line = stacktrace[0]
+      else
+        filename = nil
+        line = nil
+      end
+      self.new(
+            issue.format(args),
+            filename,
+            line,
+            nil,
+            nil,
+            issue.issue_code)
+    end
   end
 
   # An error that already contains location information in the message text

data/lib/puppet/etc.rb

@@ -109,7 +109,7 @@ module Puppet::Etc
     # Defines Puppet::Etc::Passwd struct class. Contains all of the original
     # member fields of Etc::Passwd, and additional "canonical_" versions of
     # these fields as well. API compatible with Etc::Passwd. Because Struct.new
-    # defines a new Class object, we memozie to avoid superfluous extra Class
+    # defines a new Class object, we memoize to avoid superfluous extra Class
     # instantiations.
     def puppet_etc_passwd_class
       @password_class ||= Struct.new(*Etc::Passwd.members, *Etc::Passwd.members.map { |member| "canonical_#{member}".to_sym })
@@ -133,7 +133,7 @@ module Puppet::Etc
     # @api private
     # @param [Etc::Passwd or Etc::Group struct]
     # @return [Puppet::Etc::Passwd or Puppet::Etc::Group struct] a new struct
-    #   object with the original struct values overidden to UTF-8, if valid. For
+    #   object with the original struct values overridden to UTF-8, if valid. For
     #   invalid values originating in UTF-8, invalid characters are replaced with
     #   '?'. For each member the struct also contains a corresponding
     #   :canonical_<member name> struct member.

data/lib/puppet/external/pson/pure/generator.rb

@@ -341,7 +341,7 @@ module PSON
             '"' << PSON.utf8_to_pson(self) << '"'
           end
 
-          # Module that holds the extinding methods if, the String module is
+          # Module that holds the extending methods if, the String module is
           # included.
           module Extend
             # Raw Strings are PSON Objects (the raw bytes are stored in an array for the

data/lib/puppet/external/pson/pure/parser.rb

@@ -44,7 +44,7 @@ module PSON
         /(?=\*/)      # single slash before this comment's end
         )*
         \*/               # the End of this comment
-        |[ \t\r\n]+       # whitespaces: space, horicontal tab, lf, cr
+        |[ \t\r\n]+       # whitespaces: space, horizontal tab, lf, cr
       )+
       )mx
 

data/lib/puppet/face/config.rb

@@ -129,4 +129,49 @@ https://puppet.com/docs/puppet/latest/configuration.html#environment
       nil
     end
   end
+
+  action(:delete) do
+    summary _("Delete a Puppet setting.")
+    arguments _("(<setting>")
+    #TRANSLATORS 'main' is a specific section name and should not be translated
+    description "Deletes a setting from the specified section. (The default is the section 'main')."
+    notes <<-'EOT'
+      By default, this action deletes the configuration setting from the 'main'
+      configuration domain. Use the '--section' flags to delete settings from other
+      configuration domains.
+    EOT
+    examples <<-'EOT'
+      Delete the setting 'setting_name' from the 'main' configuration domain:
+
+      $ puppet config delete setting_name
+
+      Delete the setting 'setting_name' from the 'master' configuration domain:
+
+      $ puppet config delete setting_name --section master
+    EOT
+
+    when_invoked do |name, options|
+      options[:section] = options[:section].to_s # If value was left as default - set to default string
+
+      path = Puppet::FileSystem.pathname(Puppet.settings.which_configuration_file)
+      if Puppet::FileSystem.exist?(path)
+        Puppet::FileSystem.open(path, nil, 'r+:UTF-8') do |file|
+          Puppet::Settings::IniFile.update(file) do |config|
+            setting_string = config.delete(options[:section], name)
+            if setting_string
+              puts(_("Deleted setting from '%{section_name}': '%{setting_string}'") %
+                       { section_name: options[:section], name: name, setting_string: setting_string.strip })
+            else
+              Puppet.warning(_("No setting found in configuration file for section '%{section_name}' setting name '%{name}'") %
+                                 { section_name: options[:section], name: name })
+            end
+          end
+        end
+      else
+        #TRANSLATORS the 'puppet.conf' is a specific file and should not be translated
+        Puppet.warning(_("The puppet.conf file does not exist %{puppet_conf}") % { puppet_conf: path })
+      end
+      nil
+    end
+  end
 end

data/lib/puppet/face/epp.rb

@@ -63,7 +63,7 @@ Puppet::Face.define(:epp, '0.0.1') do
     when_invoked do |*args|
       options = args.pop
       # pass a dummy node, as facts are not needed for validation
-      options[:node] = node = Puppet::Node.new("testnode", :facts => Puppet::Node::Facts.new("facts", {}))
+      options[:node] = Puppet::Node.new("testnode", :facts => Puppet::Node::Facts.new("facts", {}))
       compiler = create_compiler(options)
 
       status = true # no validation error yet
@@ -145,7 +145,7 @@ Puppet::Face.define(:epp, '0.0.1') do
       require 'puppet/pops'
       options = args.pop
       # pass a dummy node, as facts are not needed for dump
-      options[:node] = node = Puppet::Node.new("testnode", :facts => Puppet::Node::Facts.new("facts", {}))
+      options[:node] = Puppet::Node.new("testnode", :facts => Puppet::Node::Facts.new("facts", {}))
       options[:header] = options[:header].nil? ? true : options[:header]
       options[:validate] = options[:validate].nil? ? true : options[:validate]
 
@@ -176,7 +176,7 @@ Puppet::Face.define(:epp, '0.0.1') do
         end
 
         show_filename = templates.count > 1
-        dumps = templates.each do |file|
+        templates.each do |file|
           buffer.print dump_parse(Puppet::FileSystem.read(file, :encoding => 'utf-8'), file, options, show_filename)
         end
 

data/lib/puppet/face/help/action.erb

@@ -1,4 +1,7 @@
 <%# encoding: UTF-8%>
+<% if action.deprecated? -%>
+  <%= "Warning: 'puppet #{action.face.name} #{action.name}' is deprecated and will be removed in a future release." %>
+<% end %>
 <% if action.synopsis -%>
 USAGE: <%= action.synopsis %>
 

data/lib/puppet/face/module/build.rb

@@ -4,6 +4,7 @@ Puppet::Face.define(:module, '1.0.0') do
     description <<-EOT
       Prepares a local module for release on the Puppet Forge by building a
       ready-to-upload archive file.
+      Note: Module build uses MD5 checksums, which are prohibited on FIPS enabled systems.
 
       This action uses the metadata.json file in the module directory to set metadata
       used by the Forge. See <https://docs.puppetlabs.com/puppet/latest/reference/modules_publishing.html> for more

data/lib/puppet/face/module/generate.rb

@@ -129,6 +129,8 @@ Puppet::Face.define(:module, '1.0.0') do
       puts _("Finished; module generated in %{path}.") % { path: path }
       result.join("\n")
     end
+
+    deprecate
   end
 end
 
@@ -136,6 +138,9 @@ module Puppet::ModuleTool::Generate
   module_function
 
   def generate(metadata, skip_interview = false)
+    #TRANSLATORS 'puppet module generate' is the name of the puppet command and 'Puppet Development Kit' is the name of the software package replacing this action and should not be translated. 
+    Puppet.deprecation_warning _("`puppet module generate` is deprecated and will be removed in a future release. This action has been replaced by Puppet Development Kit. For more information visit https://puppet.com/docs/pdk/latest/pdk.html.")
+
     interview(metadata) unless skip_interview
     destination = duplicate_skeleton(metadata)
     all_files = destination.basename + '**/*'

data/lib/puppet/face/module/install.rb

@@ -8,6 +8,7 @@ Puppet::Face.define(:module, '1.0.0') do
     summary _("Install a module from the Puppet Forge or a release archive.")
     description <<-EOT
       Installs a module from the Puppet Forge or from a release archive file.
+      Note: Module install uses MD5 checksums, which are prohibited on FIPS enabled systems.
 
       The specified module will be installed into the directory
       specified with the `--target-dir` option, which defaults to the first

data/lib/puppet/face/module/search.rb

@@ -44,13 +44,15 @@ Puppet::Face.define(:module, '1.0.0') do
       min_widths = Hash[ *headers.map { |k,v| [k, v.length] }.flatten ]
       min_widths['full_name'] = min_widths['author'] = 12
 
-      min_width = min_widths.inject(0) { |sum,pair| sum += pair.last } + (padding.length * (headers.length - 1))
+      min_width = min_widths.inject(0) { |sum,pair| sum + pair.last } + (padding.length * (headers.length - 1))
 
       terminal_width = [Puppet::Util::Terminal.width, min_width].max
 
       columns = results[:answers].inject(min_widths) do |hash, result|
+        deprecated_buffer = result['deprecated_at'].nil? ? 0 : 11 # ' DEPRECATED'.length
+
         {
-          'full_name' => [ hash['full_name'], result['full_name'].length          ].max,
+          'full_name' => [ hash['full_name'], result['full_name'].length + deprecated_buffer ].max,
           'desc'      => [ hash['desc'],      result['desc'].length               ].max,
           'author'    => [ hash['author'],    "@#{result['author']}".length       ].max,
           'tag_list'  => [ hash['tag_list'],  result['tag_list'].join(' ').length ].max,
@@ -80,12 +82,14 @@ Puppet::Face.define(:module, '1.0.0') do
       highlight = proc do |s|
         s = s.gsub(term, colorize(:green, term))
         s = s.gsub(term.gsub('/', '-'), colorize(:green, term.gsub('/', '-'))) if term =~ /\//
+        s = s.gsub(' DEPRECATED', colorize(:red, ' DEPRECATED'))
         s
       end
 
       format % [ headers['full_name'], headers['desc'], headers['author'], headers['tag_list'] ] +
       results[:answers].map do |match|
         name, desc, author, keywords = %w{full_name desc author tag_list}.map { |k| match[k] }
+        name += ' DEPRECATED' unless match['deprecated_at'].nil?
         desc = desc[0...(columns['desc'] - 3)] + '...' if desc.length > columns['desc']
         highlight[format % [ name.sub('/', '-'), desc, "@#{author}", [keywords].flatten.join(' ') ]]
       end.join

data/lib/puppet/face/module/uninstall.rb

@@ -4,6 +4,7 @@ Puppet::Face.define(:module, '1.0.0') do
     description <<-EOT
       Uninstalls a puppet module from the modulepath (or a specific
       target directory).
+      Note: Module uninstall uses MD5 checksums, which are prohibited on FIPS enabled systems.
     EOT
 
     returns _("Hash of module objects representing uninstalled modules and related errors.")

data/lib/puppet/face/module/upgrade.rb

@@ -5,6 +5,7 @@ Puppet::Face.define(:module, '1.0.0') do
     summary _("Upgrade a puppet module.")
     description <<-EOT
       Upgrades a puppet module.
+      Note: Module upgrade uses MD5 checksums, which are prohibited on FIPS enabled systems.
     EOT
 
     returns "Hash"

data/lib/puppet/face/parser.rb

@@ -99,7 +99,6 @@ Puppet::Face.define(:parser, '0.0.1') do
           raise Puppet::Error, _("No input to parse given on command line or stdin")
         end
       else
-        missing_files = []
         files = args
         available_files = files.select do |file|
           Puppet::FileSystem.exist?(file)

data/lib/puppet/face/plugin.rb

@@ -1,5 +1,4 @@
 require 'puppet/face'
-require 'puppet/configurer/downloader_factory'
 require 'puppet/configurer/plugin_handler'
 
 Puppet::Face.define(:plugin, '0.0.1') do
@@ -42,8 +41,7 @@ Puppet::Face.define(:plugin, '0.0.1') do
     when_invoked do |options|
       remote_environment_for_plugins = Puppet::Node::Environment.remote(Puppet[:environment])
 
-      factory = Puppet::Configurer::DownloaderFactory.new
-      handler = Puppet::Configurer::PluginHandler.new(factory)
+      handler = Puppet::Configurer::PluginHandler.new()
       handler.download_plugins(remote_environment_for_plugins)
     end
 

data/lib/puppet/feature/base.rb

@@ -83,7 +83,7 @@ Puppet.features.add(:manages_symlinks) do
           attach_function :CreateSymbolicLinkW, [:lpwstr, :lpwstr, :dword], :boolean
 
           true
-        rescue LoadError => err
+        rescue LoadError
           Puppet.debug("CreateSymbolicLink is not available")
           false
         end

data/lib/puppet/feature/bolt.rb

@@ -0,0 +1,3 @@
+require 'puppet/util/feature'
+
+Puppet.features.add(:bolt, :libs => ['bolt'])

data/lib/puppet/file_bucket/dipper.rb

@@ -17,7 +17,6 @@ class Puppet::FileBucket::Dipper
     # Emulate the XMLRPC client
     server      = hash[:Server]
     port        = hash[:Port] || Puppet[:masterport]
-    environment = Puppet[:environment]
 
     if hash.include?(:Path)
       @local_path = hash[:Path]
@@ -46,7 +45,7 @@ class Puppet::FileBucket::Dipper
 
       # Make a HEAD request for the file so that we don't waste time
       # uploading it if it already exists in the bucket.
-      unless Puppet::FileBucket::File.indirection.head(file_bucket_path)
+      unless Puppet::FileBucket::File.indirection.head(file_bucket_path, :bucket_path => file_bucket_file.bucket_path)
         Puppet::FileBucket::File.indirection.save(file_bucket_file, dest_path)
       end
 

data/lib/puppet/file_serving/http_metadata.rb

@@ -37,7 +37,7 @@ class Puppet::FileServing::HttpMetadata < Puppet::FileServing::Metadata
   def collect
     # Prefer the checksum_type from the indirector request options
     # but fall back to the alternative otherwise
-    [ @checksum_type, :md5, :mtime ].each do |type|
+    [ @checksum_type, :md5, :sha256, :sha384, :sha512, :sha224, :mtime ].each do |type|
       @checksum_type = type
       @checksum = @checksums[type]
       return if @checksum

data/lib/puppet/file_system/uniquefile.rb

@@ -144,7 +144,7 @@ class Puppet::FileSystem::Uniquefile < DelegateClass(File)
   def try_convert_to_hash(h)
     begin
       h.to_hash
-    rescue NoMethodError => e
+    rescue NoMethodError
       nil
     end
   end
@@ -154,7 +154,7 @@ class Puppet::FileSystem::Uniquefile < DelegateClass(File)
   def tmpdir
     tmp = '.'
     if $SAFE > 0
-      tmp = @@systmpdir
+      @@systmpdir
     else
       for dir in [ Puppet::Util.get_env('TMPDIR'), Puppet::Util.get_env('TMP'), Puppet::Util.get_env('TEMP'), @@systmpdir, '/tmp']
         if dir and stat = File.stat(dir) and stat.directory? and stat.writable?

data/lib/puppet/forge.rb

@@ -167,6 +167,8 @@ class Puppet::Forge < SemanticPuppet::Dependency::Source
     def prepare
       return @unpacked_into if @unpacked_into
 
+      Puppet.warning "#{@metadata['name']} has been deprecated by its author! View module on Puppet Forge for more info." if deprecated?
+
       download(@data['file_uri'], tmpfile)
       validate_checksum(tmpfile, @data['file_md5'])
       unpack(tmpfile, tmpdir)
@@ -210,6 +212,10 @@ class Puppet::Forge < SemanticPuppet::Dependency::Source
         raise RuntimeError, _("Could not extract contents of module archive: %{message}") % { message: e.message }
       end
     end
+
+    def deprecated?
+      @data['module'] && (@data['module']['deprecated_at'] != nil)
+    end
   end
 
   private

data/lib/puppet/functions.rb

@@ -186,8 +186,12 @@ module Puppet::Functions
     # and it will fail unless protected with an if defined? if the local
     # variable does not exist in the block's binder.
     #
-    loader = block.binding.eval('loader_injected_arg if defined?(loader_injected_arg)')
-    create_loaded_function(func_name, loader, function_base, &block)
+    begin
+      loader = block.binding.eval('loader_injected_arg if defined?(loader_injected_arg)')
+      create_loaded_function(func_name, loader, function_base, &block)
+    rescue StandardError => e
+      raise ArgumentError, _("Function Load Error for function '%{function_name}': %{message}") % {function_name: func_name, message: e.message}
+    end
   end
 
   # Creates a function in, or in a local loader under the given loader.
@@ -474,8 +478,8 @@ module Puppet::Functions
         type = @all_callables
         name = type_and_name[0]
       when 2
-        type_string, name = type_and_name
-        type = Puppet::Pops::Types::TypeParser.singleton.parse(type_string, loader)
+        type, name = type_and_name
+        type = Puppet::Pops::Types::TypeParser.singleton.parse(type, loader) unless type.is_a?(Puppet::Pops::Types::PAnyType)
       else
         raise ArgumentError, _("block_param accepts max 2 arguments (type, name), got %{size}.") % { size: type_and_name.size }
       end
@@ -513,7 +517,9 @@ module Puppet::Functions
     #
     # @api public
     def return_type(type)
-      raise ArgumentError, _("Argument to 'return_type' must be a String reference to a Puppet Data Type. Got %{type_class}") % { type_class: type.class } unless type.is_a?(String)
+      unless type.is_a?(String) || type.is_a?(Puppet::Pops::Types::PAnyType)
+        raise ArgumentError, _("Argument to 'return_type' must be a String reference to a Puppet Data Type. Got %{type_class}") % { type_class: type.class }
+      end
       @return_type = type
     end
 
@@ -528,7 +534,7 @@ module Puppet::Functions
         raise ArgumentError, _("Parameter name argument must be a Symbol. Got %{name_class}") % { name_class: name.class }
       end
 
-      if type.is_a?(String)
+      if type.is_a?(String) || type.is_a?(Puppet::Pops::Types::PAnyType)
         @types << type
         @names << name
         # mark what should be picked for this position when dispatching
@@ -571,14 +577,27 @@ module Puppet::Functions
     # @api private
     def create_callable(types, block_type, return_type, from, to)
       mapped_types = types.map do |t|
-        Puppet::Pops::Types::TypeParser.singleton.parse(t, loader)
+        t.is_a?(Puppet::Pops::Types::PAnyType) ? t : internal_type_parse(t, loader)
       end
       param_types = Puppet::Pops::Types::PTupleType.new(mapped_types, from > 0 && from == to ? nil : Puppet::Pops::Types::PIntegerType.new(from, to))
-      return_type = Puppet::Pops::Types::TypeParser.singleton.parse(return_type, loader) unless return_type.nil?
+      return_type = internal_type_parse(return_type, loader) unless return_type.nil? || return_type.is_a?(Puppet::Pops::Types::PAnyType)
       Puppet::Pops::Types::PCallableType.new(param_types, block_type, return_type)
     end
+
+    def internal_type_parse(type_string, loader)
+      begin
+        Puppet::Pops::Types::TypeParser.singleton.parse(type_string, loader)
+      rescue StandardError => e
+        raise ArgumentError, _("Parsing of type string '\"%{type_string}\"' failed with message: <%{message}>.\n") % {
+            type_string: type_string,
+            message: e.message
+        }
+      end
+    end
+    private :internal_type_parse
   end
 
+
   # The LocalTypeAliasBuilder is used by the 'local_types' method to collect the individual
   # type aliases given by the function's author.
   #
@@ -601,9 +620,31 @@ module Puppet::Functions
     # @api public
     #
     def type(assignment_string)
-      result = parser.parse_string("type #{assignment_string}", nil) # no file source :-(
+      # Get location to use in case of error - this produces ruby filename and where call to 'type' occurred
+      # but strips off the rest of the internal "where" as it is not meaningful to user.
+      #
+      rb_location = caller[0]
+
+      begin
+        result = parser.parse_string("type #{assignment_string}", nil)
+      rescue StandardError => e
+        rb_location = rb_location.gsub(/:in.*$/, '')
+        # Create a meaningful location for parse errors - show both what went wrong with the parsing
+        # and in which ruby file it was found.
+        raise ArgumentError, _("Parsing of 'type \"%{assignment_string}\"' failed with message: <%{message}>.\n" +
+          "Called from <%{ruby_file_location}>") % {
+            assignment_string: assignment_string,
+            message: e.message,
+            ruby_file_location: rb_location
+        }
+      end
       unless result.body.kind_of?(Puppet::Pops::Model::TypeAlias)
-        raise ArgumentError, _("Expected a type alias assignment on the form 'AliasType = T', got '%{assignment_string}'") % { assignment_string: assignment_string }
+        rb_location = rb_location.gsub(/:in.*$/, '')
+        raise ArgumentError, _("Expected a type alias assignment on the form 'AliasType = T', got '%{assignment_string}'.\n"+
+        "Called from <%{ruby_file_location}>") % {
+          assignment_string: assignment_string,
+          ruby_file_location: rb_location
+        }
       end
       @local_types << result.body
     end
@@ -616,30 +657,7 @@ module Puppet::Functions
   #
   # This is a private, internal, system for creating functions. It supports
   # everything that the public function definition system supports as well as a
-  # few extra features.
-  #
-  # Injection Support
-  # ===
-  # The Function API supports injection of data and services. It is possible to
-  # make injection that takes effect when the function is loaded (for services
-  # and runtime configuration that does not change depending on how/from where
-  # in what context the function is called. It is also possible to inject and
-  # weave argument values into a call.
-  #
-  # Injection of attributes
-  # ---
-  # Injection of attributes is performed by one of the methods `attr_injected`,
-  # and `attr_injected_producer`.  The injected attributes are available via
-  # accessor method calls.
-  #
-  # @example using injected attributes
-  #   Puppet::Functions.create_function('test') do
-  #     attr_injected String, :larger, 'message_larger'
-  #     attr_injected String, :smaller, 'message_smaller'
-  #     def test(a, b)
-  #       a > b ? larger() : smaller()
-  #     end
-  #   end
+  # few extra features such as injection of well known parameters.
   #
   # @api private
   class InternalFunction < Function
@@ -663,26 +681,22 @@ module Puppet::Functions
     end
   end
 
-  # @note WARNING: This style of creating functions is not public. It is a system
-  #   under development that will be used for creating "system" functions.
-  #
   # Injection and Weaving of parameters
   # ---
-  # It is possible to inject and weave parameters into a call. These extra
-  # parameters are not part of the parameters passed from the Puppet logic, and
-  # they can not be overridden by parameters given as arguments in the call.
-  # They are invisible to the Puppet Language.
+  # It is possible to inject and weave a set of well known parameters into a call.
+  # These extra parameters are not part of the parameters passed from the Puppet
+  # logic, and  they can not be overridden by parameters given as arguments in the
+  # call. They are invisible to the Puppet Language.
   #
   # @example using injected parameters
   #   Puppet::Functions.create_function('test') do
   #     dispatch :test do
   #       param 'Scalar', 'a'
   #       param 'Scalar', 'b'
-  #       injected_param 'String', 'larger', 'message_larger'
-  #       injected_param 'String', 'smaller', 'message_smaller'
+  #       scope_param
   #     end
-  #     def test(a, b, larger, smaller)
-  #       a > b ? larger : smaller
+  #     def test(a, b, scope)
+  #       a > b ? scope['a'] : scope['b']
   #     end
   #   end
   #
@@ -690,54 +704,22 @@ module Puppet::Functions
   #
   #     test(10, 20)
   #
-  # Using injected value as default
-  # ---
-  # Default value assignment is handled by using the regular Ruby mechanism (a
-  # value is assigned to the variable).  The dispatch simply indicates that the
-  # value is optional. If the default value should be injected, it can be
-  # handled different ways depending on what is desired:
-  #
-  # * by calling the accessor method for an injected Function class attribute.
-  #   This is suitable if the value is constant across all instantiations of the
-  #   function, and across all calls.
-  # * by injecting a parameter into the call
-  #   to the left of the parameter, and then assigning that as the default value.
-  # * One of the above forms, but using an injected producer instead of a
-  #   directly injected value.
-  #
-  # @example method with injected default values
-  #   Puppet::Functions.create_function('test') do
-  #     dispatch :test do
-  #       injected_param String, 'b_default', 'b_default_value_key'
-  #       param 'Scalar', 'a'
-  #       param 'Scalar', 'b'
-  #     end
-  #     def test(b_default, a, b = b_default)
-  #       # ...
-  #     end
-  #   end
-  #
   # @api private
   class InternalDispatchBuilder < DispatcherBuilder
-    def scope_param()
-      @injections << [:scope, 'scope', '', :dispatcher_internal]
-      # mark what should be picked for this position when dispatching
-      @weaving << [@injections.size()-1]
+    # Inject parameter for `Puppet::Parser::Scope`
+    def scope_param
+      inject(:scope)
     end
-    # TODO: is param name really needed? Perhaps for error messages? (it is unused now)
-    #
-    # @api private
-    def injected_param(type, name, injection_name = '')
-      @injections << [type, name, injection_name]
-      # mark what should be picked for this position when dispatching
-      @weaving << [@injections.size() -1]
+
+    # Inject parameter for `Puppet::Pal::ScriptCompiler`
+    def script_compiler_param
+      inject(:pal_script_compiler)
     end
 
-    # TODO: is param name really needed? Perhaps for error messages? (it is unused now)
-    #
-    # @api private
-    def injected_producer_param(type, name, injection_name = '')
-      @injections << [type, name, injection_name, :producer]
+    private
+
+    def inject(injection_name)
+      @injections << injection_name
       # mark what should be picked for this position when dispatching
       @weaving << [@injections.size()-1]
     end