puppet 4.10.0 → 5.0.0

data/lib/puppet/functions/eyaml_lookup_key.rb

@@ -1,3 +1,7 @@
+# The `eyaml_lookup_key` is a hiera 5 `lookup_key` data provider function.
+# See [the configuration guide documentation](https://docs.puppet.com/puppet/latest/hiera_config_yaml_5.html#configuring-a-hierarchy-level-hiera-eyaml) for
+# how to use this function.
+#
 # @since 5.0.0
 #
 Puppet::Functions.create_function(:eyaml_lookup_key) do
@@ -29,17 +33,11 @@ Puppet::Functions.create_function(:eyaml_lookup_key) do
     # nil key is used to indicate that the cache contains the raw content of the eyaml file
     raw_data = context.cached_value(nil)
     if raw_data.nil?
-      options.each_pair do |k, v|
-        unless k == 'path'
-          Hiera::Backend::Eyaml::Options[k.to_sym] = v
-          context.explain { "Setting Eyaml option '#{k}' to '#{v}'" }
-        end
-      end
       raw_data = load_data_hash(options, context)
       context.cache(nil, raw_data)
     end
     context.not_found unless raw_data.include?(key)
-    context.cache(key, decrypt_value(raw_data[key], context))
+    context.cache(key, decrypt_value(raw_data[key], context, options))
   end
 
   def load_data_hash(options, context)
@@ -61,23 +59,29 @@ Puppet::Functions.create_function(:eyaml_lookup_key) do
     end
   end
 
-  def decrypt_value(value, context)
+  def decrypt_value(value, context, options)
     case value
     when String
-      decrypt(value, context)
+      decrypt(value, context, options)
     when Hash
       result = {}
-      value.each_pair { |k, v| result[context.interpolate(k)] = decrypt_value(v, context) }
+      value.each_pair { |k, v| result[context.interpolate(k)] = decrypt_value(v, context, options) }
       result
     when Array
-      value.map { |v| decrypt_value(v, context) }
+      value.map { |v| decrypt_value(v, context, options) }
     else
       value
     end
   end
 
-  def decrypt(data, context)
+  def decrypt(data, context, options)
     if encrypted?(data)
+      # Options must be set prior to each call to #parse since they end up as static variables in
+      # the Options class. They cannot be set once before #decrypt_value is called, since each #decrypt
+      # might cause a new lookup through interpolation. That lookup in turn, might use a different eyaml
+      # config.
+      #
+      Hiera::Backend::Eyaml::Options.set(options)
       tokens = Hiera::Backend::Eyaml::Parser::ParserFactory.hiera_backend_parser.parse(data)
       data = tokens.map(&:to_plain_text).join.chomp
     end

data/lib/puppet/functions/hiera.rb

@@ -2,6 +2,11 @@ require 'hiera/puppet_function'
 # Performs a standard priority lookup of the hierarchy and returns the most specific value
 # for a given key. The returned value can be any type of data.
 #
+# This function is deprecated in favor of the `lookup` function. While this function
+# continues to work, it does **not** support:
+# * `lookup_options` stored in the data
+# * lookup across global, environment, and module layers
+#
 # The function takes up to three arguments, in this order:
 #
 # 1. A string key that Hiera searches for in the hierarchy. **Required**.
@@ -71,8 +76,10 @@ require 'hiera/puppet_function'
 # above, Hiera matches the 'users' key and returns it as a hash.
 #
 # See
-# [the documentation](https://docs.puppetlabs.com/hiera/latest/puppet.html#hiera-lookup-functions)
-# for more information about Hiera lookup functions.
+# [the 'Using the lookup function' documentation](https://docs.puppet.com/puppet/latest/hiera_use_function.html) for how to perform lookup of data.
+# Also see
+# [the 'Using the deprecated hiera functions' documentation](https://docs.puppet.com/puppet/latest/hiera_use_hiera_functions.html)
+# for more information about the Hiera 3 functions.
 #
 # @since 4.0.0
 #

data/lib/puppet/functions/hiera_array.rb

@@ -5,6 +5,11 @@ require 'hiera/puppet_function'
 # included in the results. This is called an
 # [array merge lookup](https://docs.puppetlabs.com/hiera/latest/lookup_types.html#array-merge).
 #
+# This function is deprecated in favor of the `lookup` function. While this function
+# continues to work, it does **not** support:
+# * `lookup_options` stored in the data
+# * lookup across global, environment, and module layers
+#
 # The `hiera_array` function takes up to three arguments, in this order:
 #
 # 1. A string key that Hiera searches for in the hierarchy. **Required**.
@@ -60,8 +65,10 @@ require 'hiera/puppet_function'
 # value is a hash, Puppet raises a type mismatch error.
 #
 # See
-# [the documentation](https://docs.puppetlabs.com/hiera/latest/puppet.html#hiera-lookup-functions)
-# for more information about Hiera lookup functions.
+# [the 'Using the lookup function' documentation](https://docs.puppet.com/puppet/latest/hiera_use_function.html) for how to perform lookup of data.
+# Also see
+# [the 'Using the deprecated hiera functions' documentation](https://docs.puppet.com/puppet/latest/hiera_use_hiera_functions.html)
+# for more information about the Hiera 3 functions.
 #
 # @since 4.0.0
 #

data/lib/puppet/functions/hiera_hash.rb

@@ -1,6 +1,12 @@
 require 'hiera/puppet_function'
 
 # Finds all matches of a key throughout the hierarchy and returns them in a merged hash.
+#
+# This function is deprecated in favor of the `lookup` function. While this function
+# continues to work, it does **not** support:
+# * `lookup_options` stored in the data
+# * lookup across global, environment, and module layers
+#
 # If any of the matched hashes share keys, the final hash uses the value from the
 # highest priority match. This is called a
 # [hash merge lookup](https://docs.puppetlabs.com/hiera/latest/lookup_types.html#hash-merge).
@@ -70,8 +76,10 @@ require 'hiera/puppet_function'
 # found in the data sources are strings or arrays, Puppet raises a type mismatch error.
 #
 # See
-# [the documentation](https://docs.puppetlabs.com/hiera/latest/puppet.html#hiera-lookup-functions)
-# for more information about Hiera lookup functions.
+# [the 'Using the lookup function' documentation](https://docs.puppet.com/puppet/latest/hiera_use_function.html) for how to perform lookup of data.
+# Also see
+# [the 'Using the deprecated hiera functions' documentation](https://docs.puppet.com/puppet/latest/hiera_use_hiera_functions.html)
+# for more information about the Hiera 3 functions.
 #
 # @since 4.0.0
 #

data/lib/puppet/functions/hiera_include.rb

@@ -4,6 +4,18 @@ require 'hiera/puppet_function'
 # [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.
 #
+# This function is deprecated in favor of the `lookup` function in combination with `include`.
+# While this function continues to work, it does **not** support:
+# * `lookup_options` stored in the data
+# * lookup across global, environment, and module layers
+#
+# @example Using `lookup` and `include` instead of of the deprecated `hiera_include`
+# 
+# ~~~puppet
+# # In site.pp, outside of any node definitions and below any top-scope variables:
+# lookup('classes', Array[String], 'unique').include
+# ~~~
+#
 # The `hiera_include` function requires:
 #
 # - A string key name to use for classes.
@@ -70,9 +82,11 @@ require 'hiera/puppet_function'
 # # "Key 'classes' not found".
 # ~~~
 #
-# See [the documentation](http://links.puppetlabs.com/hierainclude) for more information
-# and a more detailed example of how `hiera_include` uses array merge lookups to classify
-# nodes.
+# See
+# [the 'Using the lookup function' documentation](https://docs.puppet.com/puppet/latest/hiera_use_function.html) for how to perform lookup of data.
+# Also see
+# [the 'Using the deprecated hiera functions' documentation](https://docs.puppet.com/puppet/latest/hiera_use_hiera_functions.html)
+# for more information about the Hiera 3 functions.
 #
 # @since 4.0.0
 #
@@ -84,7 +98,7 @@ Puppet::Functions.create_function(:hiera_include, Hiera::PuppetFunction) do
   end
 
   def post_lookup(scope, key, value)
-    raise Puppet::ParseError, "Could not find data item #{key}" if value.nil?
+    raise Puppet::ParseError, _("Could not find data item %{key}") % { key: key } if value.nil?
     call_function_with_scope(scope, 'include', value) unless value.empty?
   end
 end

data/lib/puppet/functions/hocon_data.rb

@@ -1,8 +1,14 @@
+# The `hocon_data` is a hiera 5 `data_hash` data provider function.
+# See [the configuration guide documentation](https://docs.puppet.com/puppet/latest/hiera_config_yaml_5.html#configuring-a-hierarchy-level-built-in-backends) for
+# how to use this function.
+#
+# Note that this function is not supported without a hocon library being present.
+#
 # @since 4.9.0
 #
 Puppet::Functions.create_function(:hocon_data) do
   unless Puppet.features.hocon?
-    raise Puppet::DataBinding::LookupError, 'Lookup using Hocon data_hash function is not supported without hocon library'
+    raise Puppet::DataBinding::LookupError, _('Lookup using Hocon data_hash function is not supported without hocon library')
   end
 
   require 'hocon'
@@ -24,7 +30,7 @@ Puppet::Functions.create_function(:hocon_data) do
       begin
         Hocon.parse(content)
       rescue Hocon::ConfigError => ex
-        raise Puppet::DataBinding::LookupError, "Unable to parse (#{path}): #{ex.message}"
+        raise Puppet::DataBinding::LookupError, _("Unable to parse (%{path}): %{message}") % { path: path, message: ex.message }
       end
     end
   end

data/lib/puppet/functions/json_data.rb

@@ -1,3 +1,7 @@
+# The `json_data` is a hiera 5 `data_hash` data provider function.
+# See [the configuration guide documentation](https://docs.puppet.com/puppet/latest/hiera_config_yaml_5.html#configuring-a-hierarchy-level-built-in-backends) for
+# how to use this function.
+#
 # @since 4.8.0
 #
 Puppet::Functions.create_function(:json_data) do
@@ -18,7 +22,7 @@ Puppet::Functions.create_function(:json_data) do
         JSON.parse(content)
       rescue JSON::ParserError => ex
         # Filename not included in message, so we add it here.
-        raise Puppet::DataBinding::LookupError, "Unable to parse (#{path}): #{ex.message}"
+        raise Puppet::DataBinding::LookupError, "Unable to parse (%{path}): %{message}" % { path: path, message: ex.message }
       end
     end
   end

data/lib/puppet/functions/match.rb

@@ -78,7 +78,7 @@ Puppet::Functions.create_function(:match) do
   protected
 
   def match_Object(obj, s)
-    msg = "match() expects pattern of T, where T is String, Regexp, Regexp[r], Pattern[p], or Array[T]. Got #{obj.class}"
+    msg = _("match() expects pattern of T, where T is String, Regexp, Regexp[r], Pattern[p], or Array[T]. Got %{klass}") % { klass: obj.class }
     raise ArgumentError, msg
   end
 
@@ -91,7 +91,7 @@ Puppet::Functions.create_function(:match) do
   end
 
   def match_PRegexpType(regexp_t, s)
-    raise ArgumentError, "Given Regexp Type has no regular expression" unless regexp_t.pattern
+    raise ArgumentError, _("Given Regexp Type has no regular expression") unless regexp_t.pattern
     do_match(s, regexp_t.regexp)
   end
 

data/lib/puppet/functions/reduce.rb

@@ -111,11 +111,23 @@ Puppet::Functions.create_function(:reduce) do
 
   def reduce_without_memo(enumerable)
     enum = Puppet::Pops::Types::Iterable.asserted_iterable(self, enumerable)
-    enum.reduce {|memo, x| yield(memo, x) }
+    enum.reduce do |memo, x|
+      begin
+        yield(memo, x)
+      rescue StopIteration
+        return memo
+      end
+    end
   end
 
   def reduce_with_memo(enumerable, given_memo)
     enum = Puppet::Pops::Types::Iterable.asserted_iterable(self, enumerable)
-    enum.reduce(given_memo) {|memo, x| yield(memo, x) }
+    enum.reduce(given_memo) do |memo, x|
+      begin
+        yield(memo, x)
+      rescue StopIteration
+        return memo
+      end
+    end
   end
 end

data/lib/puppet/functions/require.rb

@@ -27,7 +27,7 @@ Puppet::Functions.create_function(:require, Puppet::Functions::InternalFunction)
     classes.each do |klass|
       # lookup the class in the scopes
       klass = (classobj = krt.find_hostclass(klass)) ? classobj.name : nil
-      raise Puppet::ParseError.new("Could not find class #{klass}") unless klass
+      raise Puppet::ParseError.new(_("Could not find class %{klass}") % { klass: klass }) unless klass
       ref = Puppet::Resource.new(:class, klass)
       resource = scope.resource
       resource.set_parameter(:require, [resource[:require]].flatten.compact << ref)

data/lib/puppet/functions/slice.rb

@@ -99,11 +99,11 @@ Puppet::Functions.create_function(:slice) do
       serving_size = 1
     end
     if serving_size == 0
-      raise ArgumentError, "slice(): block must define at least one parameter. Block has 0."
+      raise ArgumentError, _("slice(): block must define at least one parameter. Block has 0.")
     end
     unless serving_size == 1 || serving_size == slice_size
-      raise ArgumentError, "slice(): block must define one parameter, or " +
-        "the same number of parameters as the given size of the slice (#{slice_size}). Block has #{serving_size}; "+
+      raise ArgumentError, _("slice(): block must define one parameter, or ") +
+        _("the same number of parameters as the given size of the slice (%{slice_size}). Block has %{serving_size}; ") % { slice_size: slice_size, serving_size: serving_size }+
       pblock.parameter_names.join(', ')
     end
     serving_size

data/lib/puppet/functions/strftime.rb

@@ -28,8 +28,16 @@ Puppet::Functions.create_function(:strftime) do
   end
 
   def legacy_strftime(format, timezone = nil)
-    Puppet.warn_once('deprecation', 'legacy#strftime',
-      'The argument signature (String format, [String timezone]) is deprecated for #strfime. See #strftime documentation and Timespan type for more info')
+    stacktrace = Puppet::Pops::PuppetStack.stacktrace()
+    if stacktrace.size > 0
+      file, line = stacktrace[0]
+    else
+      file = nil
+      line = nil
+    end
+    Puppet.warn_once('deprecations', 'legacy#strftime',
+      _('The argument signature (String format, [String timezone]) is deprecated for #strfime. See #strftime documentation and Timespan type for more info'),
+      file, line)
     Puppet::Pops::Time::Timestamp.format_time(format, Time.now.utc, timezone)
   end
 end

data/lib/puppet/functions/unique.rb

@@ -0,0 +1,132 @@
+# The `unique` function returns a unique set of values from an `Iterable` argument.
+#
+# * If the argument is a `String`, the unique set of characters are returned as a new `String`.
+# * If the argument is a `Hash`, the resulting hash associates a set of keys with a set of unique values.
+# * For all other types of `Iterable` (`Array`, `Iterator`) the result is an `Array` with
+#   a unique set of entries.
+# * Comparison of all `String` values are case sensitive.
+# * An optional code block can be given - if present it is given each candidate value and its return is used instead of the given value. This
+#   enables transformation of the value before comparison. The result of the lambda is only used for comparison.
+# * The optional code block when used with a hash is given each value (not the keys).
+#
+# @example Using unique with a String
+#
+# ~~~puppet
+# # will produce 'abc'
+# "abcaabb".unique
+# ~~~
+#
+# @example Using unique with an Array
+#
+# ~~~puppet
+# # will produce ['a', 'b', 'c']
+# ['a', 'b', 'c', 'a', 'a', 'b'].unique
+# ~~~
+#
+# @example Using unique with a Hash
+#
+# ~~~puppet
+# # will produce { ['a', 'b'] => [10], ['c'] => [20]}
+# {'a' => 10, 'b' => 10, 'c' => 20}.unique
+#
+# # will produce { 'a' => 10, 'c' => 20 } (use first key with first value)
+# Hash.new({'a' => 10, 'b' => 10, 'c' => 20}.unique.map |$k, $v| { [ $k[0] , $v[0]] })
+#
+# # will produce { 'b' => 10, 'c' => 20 } (use last key with first value)
+# Hash.new({'a' => 10, 'b' => 10, 'c' => 20}.unique.map |$k, $v| { [ $k[-1] , $v[0]] })
+# ~~~
+#
+# @example Using unique with an Iterable
+#
+# ~~~
+# # will produce [3, 2, 1]
+# [1,2,2,3,3].reverse_each.unique
+# ~~~
+#
+# @example Using unique with a lambda
+#
+# ~~~puppet
+# # will produce [['sam', 'smith'], ['sue', 'smith']]
+# [['sam', 'smith'], ['sam', 'brown'], ['sue', 'smith']].unique |$x| { $x[0] }
+#
+# # will produce [['sam', 'smith'], ['sam', 'brown']]
+# [['sam', 'smith'], ['sam', 'brown'], ['sue', 'smith']].unique |$x| { $x[1] }
+#
+# # will produce ['aBc', 'bbb'] (using a lambda to make comparison using downcased (%d) strings)
+# ['aBc', 'AbC', 'bbb'].unique |$x| { String($x,'%d') }
+#
+# # will produce {[a] => [10], [b, c, d, e] => [11, 12, 100]}
+# {a => 10, b => 11, c => 12, d => 100, e => 11}.unique |$v| { if $v > 10 { big } else { $v } } 
+# ~~~
+#
+# Note that for `Hash` the result is slightly different than for the other data types. For those the result contains the
+# *first-found* unique value, but for `Hash` it contains associations from a set of keys to the set of values clustered by the
+# equality lambda (or the default value equality if no lambda was given). This makes the `unique` function more versatile for hashes
+# in general, while requiring that the simple computation of "hash's unique set of values" is performed as `$hsh.map |$k, $v| { $v }.unique`.
+# (A unique set of hash keys is in general meaningless (since they are unique by definition) - although if processed with a different
+# lambda for equality that would be different. First map the hash to an array of its keys if such a unique computation is wanted). 
+# If the more advanced clustering is wanted for one of the other data types, simply transform it into a `Hash` as shown in the
+# following example.
+#
+# @example turning a string or array into a hash with index keys
+#
+# ~~puppet
+# # Array ['a', 'b', 'c'] to Hash with index results in
+# # {0 => 'a', 1 => 'b', 2 => 'c'}
+# Hash(['a', 'b', 'c'].map |$i, $v| { [$i, $v]})
+#
+# # String "abc" to Hash with index results in
+# # {0 => 'a', 1 => 'b', 2 => 'c'}
+# Hash(Array("abc").map |$i,$v| { [$i, $v]})
+# "abc".to(Array).map |$i,$v| { [$i, $v]}.to(Hash)
+# ~~~
+#
+# @since Puppet 5.0.0
+#
+Puppet::Functions.create_function(:unique) do
+  dispatch :unique_string do
+    param 'String', :string
+    optional_block_param 'Callable[String]', :block
+  end
+
+  dispatch :unique_hash do
+    param 'Hash', :hash
+    optional_block_param 'Callable[Any]', :block
+  end
+
+  dispatch :unique_array do
+    param 'Array', :array
+    optional_block_param 'Callable[Any]', :block
+  end
+
+  dispatch :unique_iterable do
+    param 'Iterable', :iterable
+    optional_block_param 'Callable[Any]', :block
+  end
+
+  def unique_string(string, &block)
+    string.split('').uniq(&block).join('')
+  end
+
+  def unique_hash(hash, &block)
+    block = lambda {|v| v } unless block_given?
+    result = Hash.new {|h, k| h[k] = {:keys =>[], :values =>[]} }
+    hash.each_pair do |k,v|
+      rc = result[ block.call(v) ]
+      rc[:keys] << k
+      rc[:values] << v
+    end
+    # reduce the set of possibly duplicated value entries
+    inverted = {}
+    result.each_pair {|k,v| inverted[v[:keys]] = v[:values].uniq }
+    inverted
+  end
+
+  def unique_array(array,&block)
+    array.uniq(&block)
+  end
+
+  def unique_iterable(iterable, &block)
+    Puppet::Pops::Types::Iterable.on(iterable).uniq(&block)
+  end
+end

data/lib/puppet/functions/yaml_data.rb

@@ -1,3 +1,7 @@
+# The `yaml_data` is a hiera 5 `data_hash` data provider function.
+# See [the configuration guide documentation](https://docs.puppet.com/puppet/latest/hiera_config_yaml_5.html#configuring-a-hierarchy-level-built-in-backends) for
+# how to use this function.
+#
 # @since 4.8.0
 #
 require 'yaml'

data/lib/puppet/functions.rb

@@ -205,7 +205,7 @@ module Puppet::Functions
   # @api public
   def self.create_loaded_function(func_name, loader, function_base = Function, &block)
     if function_base.ancestors.none? { |s| s == Puppet::Pops::Functions::Function }
-      raise ArgumentError, "Functions must be based on Puppet::Pops::Functions::Function. Got #{function_base}"
+      raise ArgumentError, _("Functions must be based on Puppet::Pops::Functions::Function. Got %{function_base}") % { function_base: function_base }
     end
 
     func_name = func_name.to_s
@@ -265,7 +265,7 @@ module Puppet::Functions
   # @api private
   def self.default_dispatcher(the_class, func_name)
     unless the_class.method_defined?(func_name)
-      raise ArgumentError, "Function Creation Error, cannot create a default dispatcher for function '#{func_name}', no method with this name found"
+      raise ArgumentError, _("Function Creation Error, cannot create a default dispatcher for function '%{func_name}', no method with this name found") % { func_name: func_name }
     end
     any_signature(*min_max_param(the_class.instance_method(func_name)))
   end
@@ -343,7 +343,7 @@ module Puppet::Functions
     #
     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"
+        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)
@@ -407,7 +407,7 @@ module Puppet::Functions
     # @api public
     def param(type, name)
       internal_param(type, name)
-      raise ArgumentError, 'A required parameter cannot be added after an optional parameter' if @min != @max
+      raise ArgumentError, _('A required parameter cannot be added after an optional parameter') if @min != @max
       @min += 1
       @max += 1
     end
@@ -456,7 +456,7 @@ module Puppet::Functions
     # @api public
     def required_repeated_param(type, name)
       internal_param(type, name, true)
-      raise ArgumentError, 'A required repeated parameter cannot be added after an optional parameter' if @min != @max
+      raise ArgumentError, _('A required repeated parameter cannot be added after an optional parameter') if @min != @max
       @min += 1
       @max = :default
     end
@@ -478,22 +478,22 @@ module Puppet::Functions
         type_string, name = type_and_name
         type = @type_parser.parse(type_string, loader)
       else
-        raise ArgumentError, "block_param accepts max 2 arguments (type, name), got #{type_and_name.size}."
+        raise ArgumentError, _("block_param accepts max 2 arguments (type, name), got %{size}.") % { size: type_and_name.size }
       end
 
       unless Puppet::Pops::Types::TypeCalculator.is_kind_of_callable?(type, false)
-        raise ArgumentError, "Expected PCallableType or PVariantType thereof, got #{type.class}"
+        raise ArgumentError, _("Expected PCallableType or PVariantType thereof, got %{type_class}") % { type_class: type.class }
       end
 
       unless name.is_a?(Symbol)
-        raise ArgumentError, "Expected block_param name to be a Symbol, got #{name.class}"
+        raise ArgumentError, _("Expected block_param name to be a Symbol, got %{name_class}") % { name_class: name.class }
       end
 
       if @block_type.nil?
         @block_type = type
         @block_name = name
       else
-        raise ArgumentError, 'Attempt to redefine block'
+        raise ArgumentError, _('Attempt to redefine block')
       end
     end
     alias required_block_param block_param
@@ -514,7 +514,7 @@ 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}" unless type.is_a?(String)
+      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)
       @return_type = type
     end
 
@@ -522,11 +522,11 @@ module Puppet::Functions
 
     # @api private
     def internal_param(type, name, repeat = false)
-      raise ArgumentError, 'Parameters cannot be added after a block parameter' unless @block_type.nil?
-      raise ArgumentError, 'Parameters cannot be added after a repeated parameter' if @max == :default
+      raise ArgumentError, _('Parameters cannot be added after a block parameter') unless @block_type.nil?
+      raise ArgumentError, _('Parameters cannot be added after a repeated parameter') if @max == :default
 
       if name.is_a?(String)
-        raise ArgumentError, "Parameter name argument must be a Symbol. Got #{name.class}"
+        raise ArgumentError, _("Parameter name argument must be a Symbol. Got %{name_class}") % { name_class: name.class }
       end
 
       if type.is_a?(String)
@@ -539,7 +539,7 @@ module Puppet::Functions
           @weaving << @names.size()-1
         end
       else
-        raise ArgumentError, "Parameter 'type' must be a String reference to a Puppet Data Type. Got #{type.class}"
+        raise ArgumentError, _("Parameter 'type' must be a String reference to a Puppet Data Type. Got %{type_class}") % { type_class: type.class }
       end
     end
 
@@ -604,7 +604,7 @@ module Puppet::Functions
     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}'"
+        raise ArgumentError, _("Expected a type alias assignment on the form 'AliasType = T', got '%{assignment_string}'") % { assignment_string: assignment_string }
       end
       @local_types << result.body
     end
@@ -649,34 +649,6 @@ module Puppet::Functions
       InternalDispatchBuilder.new(dispatcher, Puppet::Pops::Types::TypeParser.singleton, Puppet::Pops::Types::PCallableType::DEFAULT, loader)
     end
 
-    # Defines class level injected attribute with reader method
-    #
-    # @api private
-    def self.attr_injected(type, attribute_name, injection_name = nil)
-      define_method(attribute_name) do
-        ivar = :"@#{attribute_name.to_s}"
-        unless instance_variable_defined?(ivar)
-          injector = Puppet.lookup(:injector)
-          instance_variable_set(ivar, injector.lookup(closure_scope, type, injection_name))
-        end
-        instance_variable_get(ivar)
-      end
-    end
-
-    # Defines class level injected producer attribute with reader method
-    #
-    # @api private
-    def self.attr_injected_producer(type, attribute_name, injection_name = nil)
-      define_method(attribute_name) do
-        ivar = :"@#{attribute_name.to_s}"
-        unless instance_variable_defined?(ivar)
-          injector = Puppet.lookup(:injector)
-          instance_variable_set(ivar, injector.lookup_producer(closure_scope, type, injection_name))
-        end
-        instance_variable_get(ivar)
-      end
-    end
-
     # Allows the implementation of a function to call other functions by name and pass the caller
     # scope. The callable functions are those visible to the same loader that loaded this function
     # (the calling function).
@@ -687,8 +659,8 @@ module Puppet::Functions
     # @return [Object] The result returned by the called function
     #
     # @api public
-    def call_function_with_scope(scope, function_name, *args)
-      internal_call_function(scope, function_name, args)
+    def call_function_with_scope(scope, function_name, *args, &block)
+      internal_call_function(scope, function_name, args, &block)
     end
   end
 

data/lib/puppet/generate/models/type/type.rb

@@ -37,14 +37,15 @@ module Puppet
             @parameters = type.parameters.map do |name|
               Property.new(type.paramclass(name))
             end
+            sc = Puppet::Pops::Types::StringConverter.singleton
             @title_patterns = Hash[type.title_patterns.map do |mapping|
               [
-                "/#{mapping[0].source.gsub(/\//, '\/')}/",
-                mapping[1].map { |names|
+                sc.convert(mapping[0], '%p'),
+                sc.convert(mapping[1].map do |names|
                   next if names.empty?
-                  raise Puppet::Error, 'title patterns that use procs are not supported.' if names.size != 1
-                  Puppet::Pops::Types::StringConverter.convert(names[0].to_s, '%p')
-                }
+                  raise Puppet::Error, _('title patterns that use procs are not supported.') unless names.size == 1
+                  names[0].to_s
+                end, '%p')
               ]
             end]
             @isomorphic = type.isomorphic?

data/lib/puppet/generate/templates/type/pcore.erb

@@ -34,7 +34,7 @@ Puppet::Resource::ResourceType3.new(
   ],
   {
 <%- title_patterns.each_with_index do |mapping, index| -%>
-    <%= mapping[0] %> => [<%= mapping[1].join(', ')%>]<%= "," if index + 1 < title_patterns.size %>
+    <%= mapping[0] %> => <%= mapping[1] %><%= "," if index + 1 < title_patterns.size %>
 <%- end -%>
   },
   <%= isomorphic -%>,