puppet 5.3.3-x86-mingw32 → 5.3.4-x86-mingw32

data/lib/puppet/pops/model/factory.rb

@@ -790,7 +790,9 @@ class Factory
       end
     else
       # Bad number should already have been caught by lexer - this should never happen
-      raise ArgumentError, "Internal Error, NUMBER token does not contain a valid number, #{name_or_numeric}"
+      #TRANSLATORS 'NUMBER' refers to a method name and the 'name_or_numeric' was the passed in value and should not be translated
+      raise ArgumentError, _("Internal Error, NUMBER token does not contain a valid number, %{name_or_numeric}") %
+          { name_or_numeric: name_or_numeric }
     end
   end
 
@@ -1082,7 +1084,7 @@ class Factory
       elsif e.is_a?(String)
         result << e
       else
-        raise ArgumentError, "can only concatenate strings, got #{e.class}"
+        raise ArgumentError, _("can only concatenate strings, got %{class_name}") % { class_name: e.class }
       end
     end
     infer(result)

data/lib/puppet/pops/resource/resource_type_impl.rb

@@ -164,7 +164,7 @@ class ResourceTypeImpl
           # the 'package' type where 'provider' attribute is handled as part of the key without being
           # set from the title.
           #
-          raise Puppet::DevError,"you must specify title patterns when there are two or more key attributes"
+          raise Puppet::DevError, _("you must specify title patterns when there are two or more key attributes")
         end
         @title_patterns_hash.nil? ? [] : @title_patterns_hash.map { |k,v| [ k, v.map { |n| [ n.to_sym] } ] }
       end

data/lib/puppet/pops/serialization/abstract_writer.rb

@@ -99,7 +99,8 @@ class AbstractWriter
   #
   # @api private
   def write_tpl(ep, value)
-    raise ArgumentError, 'Internal error. Integers cannot be tabulated in extension payload' if value.is_a?(Integer)
+    #TRANSLATORS 'Integers' is a Ruby class for numbers and should not be translated
+    raise ArgumentError, _('Internal error. Integers cannot be tabulated in extension payload') if value.is_a?(Integer)
     if @tabulate
       index = @written[value]
       if index.nil?

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

@@ -79,6 +79,8 @@ module Puppet::Pops::Types
         o.finite_range? ? IntegerRangeIterator.new(o) : nil
       when PEnumType
         Iterator.new(o, o.values.each)
+      when PTypeAliasType
+        on(o.resolved_type)
       when Range
         min = o.min
         max = o.max

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

@@ -132,7 +132,10 @@ class PObjectType < PMetaType
     def assert_override(parent_members)
       parent_member = parent_members[@name]
       if parent_member.nil?
-        raise Puppet::ParseError, "expected #{label} to override an inherited #{feature_type}, but no such #{feature_type} was found" if @override
+        if @override
+          raise Puppet::ParseError, _("expected %{label} to override an inherited %{feature_type}, but no such %{feature_type} was found") %
+              { label: label, feature_type: feature_type }
+        end
         self
       else
         parent_member.assert_can_be_overridden(self)
@@ -146,10 +149,19 @@ class PObjectType < PMetaType
     # @raises [Puppet::ParseError] if the assertion fails
     # @api private
     def assert_can_be_overridden(member)
-      raise Puppet::ParseError, "#{member.label} attempts to override #{label}" unless self.class == member.class
-      raise Puppet::ParseError, "#{member.label} attempts to override final #{label}" if @final && !(constant? && member.constant?)
-      raise Puppet::ParseError, "#{member.label} attempts to override #{label} without having override => true" unless member.override?
-      raise Puppet::ParseError, "#{member.label} attempts to override #{label} with a type that does not match" unless @type.assignable?(member.type)
+      unless self.class == member.class
+        raise Puppet::ParseError, _("%{member} attempts to override %{label}") % { member: member.label, label: label }
+      end
+      if @final && !(constant? && member.constant?)
+        raise Puppet::ParseError, _("%{member} attempts to override final %{label}") % { member: member.label, label: label }
+      end
+      unless member.override?
+        #TRANSLATOR 'override => true' is a puppet syntax and should not be translated
+        raise Puppet::ParseError, _("%{member} attempts to override %{label} without having override => true") % { member: member.label, label: label }
+      end
+      unless @type.assignable?(member.type)
+        raise Puppet::ParseError, _("%{member} attempts to override %{label} with a type that does not match") % { member: member.label, label: label }
+      end
       member
     end
 
@@ -264,19 +276,20 @@ class PObjectType < PMetaType
       @kind = init_hash[KEY_KIND]
       if @kind == ATTRIBUTE_KIND_CONSTANT # final is implied
         if init_hash.include?(KEY_FINAL) && !@final
-          raise Puppet::ParseError, "#{label} of kind 'constant' cannot be combined with final => false"
+          #TRANSLATOR 'final => false' is puppet syntax and should not be translated
+          raise Puppet::ParseError, _("%{label} of kind 'constant' cannot be combined with final => false") % { label: label }
         end
         @final = true
       end
 
       if init_hash.include?(KEY_VALUE)
         if @kind == ATTRIBUTE_KIND_DERIVED || @kind == ATTRIBUTE_KIND_GIVEN_OR_DERIVED
-          raise Puppet::ParseError, "#{label} of kind '#{@kind}' cannot be combined with an attribute value"
+          raise Puppet::ParseError, _("%{label} of kind '%{kind}' cannot be combined with an attribute value") % { label: label, kind: @kind }
         end
         v = init_hash[KEY_VALUE]
         @value = v == :default ? v : TypeAsserter.assert_instance_of(nil, type, v) {"#{label} #{KEY_VALUE}" }
       else
-        raise Puppet::ParseError, "#{label} of kind 'constant' requires a value" if @kind == ATTRIBUTE_KIND_CONSTANT
+        raise Puppet::ParseError, _("%{label} of kind 'constant' requires a value") % { label: label } if @kind == ATTRIBUTE_KIND_CONSTANT
         @value = :undef # Not to be confused with nil or :default
       end
     end
@@ -618,7 +631,9 @@ class PObjectType < PMetaType
     attr_specs = init_hash[KEY_ATTRIBUTES] || {}
     unless constants.nil? || constants.empty?
       constants.each do |key, value|
-        raise Puppet::ParseError, "attribute #{label}[#{key}] is defined as both a constant and an attribute" if attr_specs.include?(key)
+        if attr_specs.include?(key)
+          raise Puppet::ParseError, _("attribute %{label}[%{key}] is defined as both a constant and an attribute") % { label: label, key: key }
+        end
         attr_spec = {
           # Type must be generic here, or overrides would become impossible
           KEY_TYPE => TypeCalculator.infer(value).generalize,
@@ -649,7 +664,7 @@ class PObjectType < PMetaType
         func_spec = { KEY_TYPE => TypeAsserter.assert_instance_of(nil, TYPE_FUNCTION_TYPE, func_spec) { "function #{label}[#{key}]" } } unless func_spec.is_a?(Hash)
         func = PFunction.new(key, self, func_spec)
         name = func.name
-        raise Puppet::ParseError, "#{func.label} conflicts with attribute with the same name" if @attributes.include?(name)
+        raise Puppet::ParseError, _("%{label} conflicts with attribute with the same name") % { label: func.label } if @attributes.include?(name)
         [name, func.assert_override(parent_members)]
       end].freeze
     end
@@ -661,7 +676,8 @@ class PObjectType < PMetaType
     equality = [equality] if equality.is_a?(String)
     if equality.is_a?(Array)
       unless equality.empty?
-        raise Puppet::ParseError, 'equality_include_type = false cannot be combined with non empty equality specification' unless @equality_include_type
+        #TRANSLATORS equality_include_type = false should not be translated
+        raise Puppet::ParseError, _('equality_include_type = false cannot be combined with non empty equality specification') unless @equality_include_type
         parent_eq_attrs = nil
         equality.each do |attr_name|
 
@@ -673,16 +689,21 @@ class PObjectType < PMetaType
             parent_eq_attrs ||= parent_object_type.equality_attributes
             if parent_eq_attrs.include?(attr_name)
               including_parent = find_equality_definer_of(attr)
-              raise Puppet::ParseError, "#{label} equality is referencing #{attr.label} which is included in equality of #{including_parent.label}"
+              raise Puppet::ParseError, _("%{label} equality is referencing %{attribute} which is included in equality of %{including_parent}") %
+                  { label: label, attribute: attr.label, including_parent: including_parent.label }
             end
           end
 
           unless attr.is_a?(PAttribute)
-            raise Puppet::ParseError, "#{label} equality is referencing non existent attribute '#{attr_name}'" if attr.nil?
-            raise Puppet::ParseError, "#{label} equality is referencing #{attr.label}. Only attribute references are allowed"
+            if attr.nil?
+              raise Puppet::ParseError, _("%{label} equality is referencing non existent attribute '%{attribute}'") % { label: label, attribute: attr_name }
+            end
+            raise Puppet::ParseError, _("%{label} equality is referencing %{attribute}. Only attribute references are allowed") %
+                { label: label, attribute: attr.label }
           end
           if attr.kind == ATTRIBUTE_KIND_CONSTANT
-            raise Puppet::ParseError, "#{label} equality is referencing constant #{attr.label}. Reference to constant is not allowed in equality"
+            raise Puppet::ParseError, _("%{label} equality is referencing constant %{attribute}.") % { label: label, attribute: attr.label } + ' ' +
+                _("Reference to constant is not allowed in equality")
           end
         end
       end

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

@@ -163,7 +163,8 @@ class TypeCalculator
 
   # Returns an iterable if the t represents something that can be iterated
   def enumerable(t)
-    Puppet.deprecation_warning('TypeCalculator.enumerable is deprecated. Use iterable')
+    #TRANSLATOR 'TypeCalculator.enumerable' and 'iterable' are methods and should not be translated
+    Puppet.deprecation_warning(_('TypeCalculator.enumerable is deprecated. Use iterable'))
     iterable(t)
   end
 

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

@@ -100,7 +100,9 @@ module TypeFactory
       size_type_or_value.nil? ? PStringType::DEFAULT : PStringType.new(size_type_or_value)
     else
       if Puppet[:strict] != :off
-        Puppet.warn_once('deprecations', "TypeFactory#string_multi_args", "Passing more than one argument to TypeFactory#string is deprecated")
+        #TRANSLATORS 'TypeFactory#string' is a class and method name and should not be translated
+        message = _("Passing more than one argument to TypeFactory#string is deprecated")
+        Puppet.warn_once('deprecations', "TypeFactory#string_multi_args", message)
       end
       deprecated_second_argument.size == 1 ? PStringType.new(deprecated_second_argument[0]) : PEnumType.new(*deprecated_second_argument)
     end

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

@@ -286,8 +286,8 @@ module Types
           a = detailed_actual_to_s(e, a)
           e = e.map { |t| t.to_alias_expanded_s }
         else
-          e = e.map { |t| t.simple_name }.uniq
-          a = a.simple_name
+          e = e.map { |t| short_name(t) }.uniq
+          a = short_name(a)
         end
         e.insert(0, 'Undef') if optional
         case e.size
@@ -305,8 +305,8 @@ module Types
           a = detailed_actual_to_s(e, a)
           e = e.to_alias_expanded_s
         else
-          e = e.simple_name
-          a = a.simple_name
+          e = short_name(e)
+          a = short_name(a)
         end
         if optional
           e = "Undef or #{e}"
@@ -326,6 +326,16 @@ module Types
 
     private
 
+    def short_name(t)
+      # Ensure that Optional, NotUndef, Sensitive, and Type are reported with included
+      # type parameter.
+      if t.is_a?(PTypeWithContainedType) && !(t.type.nil? || t.type.class == PAnyType)
+        "#{t.name}[#{t.type.name}]"
+      else
+        t.name.nil? ? t.simple_name : t.name
+      end
+    end
+
     # Answers the question if `e` is a specialized type of `a`
     # @param e [PAnyType] the expected type
     # @param a [PAnyType] the actual type
@@ -430,7 +440,7 @@ module Types
 
     def actual_string
       a = actual
-      a.is_a?(PStringType) && !a.value.nil? ? "'#{a.value}'" : a.simple_name
+      a.is_a?(PStringType) && !a.value.nil? ? "'#{a.value}'" : short_name(a)
     end
   end
 
@@ -502,7 +512,10 @@ module Types
     end
 
     def tense_deprecated
-      Puppet.warn_once('deprecations', 'typemismatch#tense', "Passing a 'tense' argument to the TypeMismatchDescriber is deprecated and ignored. Everything is now reported using present tense")
+      #TRANSLATORS TypeMismatchDescriber is a class name and 'tense' is a method name and should not be translated
+      message = _("Passing a 'tense' argument to the TypeMismatchDescriber is deprecated and ignored.")
+      message += ' ' + _("Everything is now reported using present tense")
+      Puppet.warn_once('deprecations', 'typemismatch#tense', message)
     end
 
     # Validates that all entries in the give_hash exists in the given param_struct, that their type conforms

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

@@ -342,7 +342,7 @@ class TypeParser
     when 'enum'
       # 1..m parameters being strings
       raise_invalid_parameters_error('Enum', '1 or more', parameters.size) unless parameters.size >= 1
-      parameters.each { |p|  raise Puppet::ParseError, 'Enum parameters must be identifiers or strings' unless p.is_a?(String) }
+      parameters.each { |p| raise Puppet::ParseError, _('Enum parameters must be identifiers or strings') unless p.is_a?(String) }
       TypeFactory.enum(*parameters)
 
     when 'pattern'
@@ -565,21 +565,21 @@ class TypeParser
   end
 
   def raise_invalid_type_specification_error(ast)
-    raise Puppet::ParseError,
-      "The expression <#{original_text_of(ast)}> is not a valid type specification."
+    raise Puppet::ParseError, _("The expression <%{expression}> is not a valid type specification.") %
+        { expression: original_text_of(ast) }
   end
 
   def raise_invalid_parameters_error(type, required, given)
-    raise Puppet::ParseError,
-      "Invalid number of type parameters specified: #{type} requires #{required}, #{given} provided"
+    raise Puppet::ParseError, _("Invalid number of type parameters specified: %{type} requires %{required}, %{given} provided") %
+        { type: type, required: required, given: given }
   end
 
   def raise_unparameterized_type_error(ast)
-    raise Puppet::ParseError, "Not a parameterized type <#{original_text_of(ast)}>"
+    raise Puppet::ParseError, _("Not a parameterized type <%{type}>") % { type: original_text_of(ast) }
   end
 
   def raise_unknown_type_error(ast)
-    raise Puppet::ParseError, "Unknown type <#{original_text_of(ast)}>"
+    raise Puppet::ParseError, _("Unknown type <%{type}>") % { type: original_text_of(ast) }
   end
 
   def original_text_of(ast)

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

@@ -939,7 +939,7 @@ class PNumericType < PScalarDataType
   end
 
   def instance?(o, guard = nil)
-    o.is_a?(Numeric) && o >= @from && o <= @to
+    (o.is_a?(Float) || o.is_a?(Integer)) && o >= @from && o <= @to
   end
 
   def unbounded?
@@ -1341,6 +1341,8 @@ class PIterableType < PTypeWithContainedType
         o >= 0
       when PIntegerType
         o.finite_range?
+      when PTypeAliasType
+        instance?(o.resolved_type, guard)
       else
         false
       end
@@ -1427,7 +1429,9 @@ class PStringType < PScalarDataType
   def initialize(size_type_or_value, deprecated_multi_args = EMPTY_ARRAY)
     unless deprecated_multi_args.empty?
       if Puppet[:strict] != :off
-        Puppet.warn_once('deprecations', "PStringType#initialize_multi_args", "Passing more than one argument to PStringType#initialize is deprecated")
+        #TRANSLATORS 'PStringType#initialize' is a class and method name and should not be translated
+        Puppet.warn_once('deprecations', "PStringType#initialize_multi_args",
+                         _("Passing more than one argument to PStringType#initialize is deprecated"))
       end
       size_type_or_value = deprecated_multi_args[0]
     end
@@ -1480,7 +1484,8 @@ class PStringType < PScalarDataType
   # @api private
   def values
     if Puppet[:strict] != :off
-      Puppet.warn_once('deprecations', "PStringType#values", "Method PStringType#values is deprecated. Use #value instead")
+      #TRANSLATORS 'PStringType#values' and '#value' are classes and method names and should not be translated
+      Puppet.warn_once('deprecations', "PStringType#values", _("Method PStringType#values is deprecated. Use #value instead"))
     end
     @value.is_a?(String) ? [@value] : EMPTY_ARRAY
   end
@@ -2599,8 +2604,9 @@ class PHashType < PCollectionType
 
   def element_type
     if Puppet[:strict] != :off
+      #TRANSLATOR 'Puppet::Pops::Types::PHashType#element_type' and '#value_type' are class and method names and should not be translated
       Puppet.warn_once('deprecations', 'Puppet::Pops::Types::PHashType#element_type',
-        'Puppet::Pops::Types::PHashType#element_type is deprecated, use #value_type instead')
+        _('Puppet::Pops::Types::PHashType#element_type is deprecated, use #value_type instead'))
     end
     @value_type
   end

data/lib/puppet/pops/validation.rb

@@ -125,9 +125,15 @@ module Validation
     # @api public
     #
     def []=(issue, level)
-      raise Puppet::DevError.new("Attempt to set validation severity for something that is not an Issue. (Got #{issue.class})") unless issue.is_a? Issues::Issue
-      raise Puppet::DevError.new("Illegal severity level: #{level} for '#{issue.issue_code}'") unless @@severity_hash[level]
-      raise Puppet::DevError.new("Attempt to demote the hard issue '#{issue.issue_code}' to #{level}") unless issue.demotable? || level == :error
+      unless issue.is_a? Issues::Issue
+        raise Puppet::DevError.new(_("Attempt to set validation severity for something that is not an Issue. (Got %{issue})") % { issue: issue.class })
+      end
+      unless @@severity_hash[level]
+        raise Puppet::DevError.new(_("Illegal severity level: %{level} for '%{issue_code}'") % { issue_code: issue.issue_code, level: level })
+      end
+      unless issue.demotable? || level == :error
+        raise Puppet::DevError.new(_("Attempt to demote the hard issue '%{issue_code}' to %{level}") % { issue_code: issue.issue_code, level: level })
+      end
       @severities[issue] = level
     end
 
@@ -145,14 +151,9 @@ module Validation
     # @api private
     #
     def assert_issue issue
-      raise Puppet::DevError.new("Attempt to get validation severity for something that is not an Issue. (Got #{issue.class})") unless issue.is_a? Issues::Issue
-    end
-
-    # Checks if the given severity level is valid.
-    # @api private
-    #
-    def assert_severity level
-      raise Puppet::DevError.new("Illegal severity level: #{option}") unless @@severity_hash[level]
+      unless issue.is_a? Issues::Issue
+        raise Puppet::DevError.new(_("Attempt to get validation severity for something that is not an Issue. (Got %{issue})") % { issue: issue.class })
+      end
     end
   end
 
@@ -203,7 +204,8 @@ module Validation
       # Accept an Error as semantic if it supports methods #file(), #line(), and #pos()
       if semantic.is_a?(StandardError)
         unless semantic.respond_to?(:file) && semantic.respond_to?(:line) && semantic.respond_to?(:pos)
-          raise Puppet::DevError("Issue #{issue.issue_code}: Cannot pass a #{semantic.class} as a semantic object when it does not support #pos(), #file() and #line()")
+          raise Puppet::DevError, _("Issue %{issue_code}: Cannot pass a %{class_name} as a semantic object when it does not support #pos(), #file() and #line()") %
+              { issue_code: issue.issue_code, class_name: semantic.class }
         end
       end
 

data/lib/puppet/property.rb

@@ -95,7 +95,8 @@ class Puppet::Property < Puppet::Parameter
     #
     def array_matching=(value)
       value = value.intern if value.is_a?(String)
-      raise ArgumentError, "Supported values for Property#array_matching are 'first' and 'all'" unless [:first, :all].include?(value)
+      #TRANSLATORS 'Property#array_matching', 'first', and 'all' should not be translated
+      raise ArgumentError, _("Supported values for Property#array_matching are 'first' and 'all'") unless [:first, :all].include?(value)
       @array_matching = value
     end
 
@@ -167,7 +168,7 @@ class Puppet::Property < Puppet::Parameter
       method = value.method.to_sym
       if value.block
         if instance_methods(false).include?(method)
-          raise ArgumentError, "Attempt to redefine method #{method} with block"
+          raise ArgumentError, _("Attempt to redefine method %{method} with block") % { method: method }
         end
         define_method(method, &value.block)
       else
@@ -211,7 +212,7 @@ class Puppet::Property < Puppet::Parameter
     rescue Puppet::Error, Puppet::DevError
       raise
     rescue => detail
-      message = "Could not convert change '#{name}' to string: #{detail}"
+      message = _("Could not convert change '%{name}' to string: %{detail}") % { name: name, detail: detail }
       Puppet.log_exception(detail, message)
       raise Puppet::DevError, message, detail.backtrace
     end
@@ -367,7 +368,9 @@ class Puppet::Property < Puppet::Parameter
     rescue => detail
       # Certain operations may fail, but we don't want to fail the transaction if we can
       # avoid it
-      msg = "Unknown failure using insync_values? on type: #{self.resource.ref} / property: #{self.name} to compare values #{should} and #{is}"
+      #TRANSLATORS 'insync_values?' should not be translated
+      msg = _("Unknown failure using insync_values? on type: %{type} / property: %{name} to compare values %{should} and %{is}") %
+          { type: self.resource.ref, name: self.name, should: should, is: is }
       Puppet.info(msg)
 
       # Return nil, ie. unknown
@@ -489,7 +492,8 @@ class Puppet::Property < Puppet::Parameter
       rescue Puppet::Error
         raise
       rescue => detail
-        error = Puppet::ResourceError.new("Could not set '#{value}' on #{self.class.name}: #{detail}", @resource.file, @resource.line, detail)
+        error = Puppet::ResourceError.new(_("Could not set '%{value}' on %{class_name}: %{detail}") %
+                                              { value: value, class_name: self.class.name, detail: detail }, @resource.file, @resource.line, detail)
         error.set_backtrace detail.backtrace
         Puppet.log_exception(detail, error.message)
         raise error
@@ -584,7 +588,11 @@ class Puppet::Property < Puppet::Parameter
     if features = self.class.value_option(self.class.value_name(value), :required_features)
       features = Array(features)
       needed_features = features.collect { |f| f.to_s }.join(", ")
-      raise ArgumentError, "Provider #{provider.class.name} must have features '#{needed_features}' to set '#{self.class.name}' to '#{value}'" unless provider.satisfies?(features)
+      unless provider.satisfies?(features)
+        #TRANSLATORS 'Provider' refers to a Puppet provider class
+        raise ArgumentError, _("Provider %{provider} must have features '%{needed_features}' to set '%{property}' to '%{value}'") %
+            { provider: provider.class.name, needed_features: needed_features, property: self.class.name, value: value }
+      end
     end
   end
 

data/lib/puppet/property/ensure.rb

@@ -59,7 +59,7 @@ class Puppet::Property::Ensure < Puppet::Property
     rescue Puppet::Error, Puppet::DevError
       raise
     rescue => detail
-      raise Puppet::DevError, "Could not convert change #{self.name} to string: #{detail}", detail.backtrace
+      raise Puppet::DevError, _("Could not convert change %{name} to string: %{detail}") % { name: self.name, detail: detail }, detail.backtrace
     end
   end
 
@@ -82,7 +82,7 @@ class Puppet::Property::Ensure < Puppet::Property
     elsif @resource.respond_to?(:exists?)
       result = @resource.exists?
     else
-      raise Puppet::DevError, "No ability to determine if #{@resource.class.name} exists"
+      raise Puppet::DevError, _("No ability to determine if %{name} exists") % { name: @resource.class.name }
     end
     if result
       return :present