puppet 4.10.0 → 5.0.0

data/lib/puppet/module_tool/errors/upgrader.rb

@@ -17,26 +17,26 @@ module Puppet::ModuleTool::Errors
       @dependency_name   = options[:dependency_name]
       @newer_versions    = options[:newer_versions]
       @possible_culprits = options[:possible_culprits]
-      super "Could not upgrade '#{@module_name}'; more recent versions not found"
+      super _("Could not upgrade '%{module_name}'; more recent versions not found") % { module_name: @module_name }
     end
 
     def multiline
       message = []
-      message << "Could not upgrade module '#{@module_name}' (#{vstring})"
+      message << _("Could not upgrade module '%{module_name}' (%{version})") % { module_name: @module_name, version: vstring }
       if @newer_versions.empty?
-        message << "  The installed version is already the latest version matching #{vstring}"
+        message << _("  The installed version is already the latest version matching %{version}") % { version: vstring }
       else
-        message << "  There are #{@newer_versions.length} newer versions"
-        message << "    No combination of dependency upgrades would satisfy all dependencies"
+        message << _("  There are %{count} newer versions") % { count: @newer_versions.length }
+        message << _("    No combination of dependency upgrades would satisfy all dependencies")
         unless @possible_culprits.empty?
-          message << "    Dependencies will not be automatically upgraded across major versions"
-          message << "    Upgrading one or more of these modules may permit the upgrade to succeed:"
+          message << _("    Dependencies will not be automatically upgraded across major versions")
+          message << _("    Upgrading one or more of these modules may permit the upgrade to succeed:")
           @possible_culprits.each do |name|
             message << "    - #{name}"
           end
         end
       end
-      message << "    Use `puppet module upgrade --force` to upgrade only this module"
+      message << _("    Use `puppet module upgrade --force` to upgrade only this module")
       message.join("\n")
     end
   end
@@ -49,13 +49,13 @@ module Puppet::ModuleTool::Errors
       @conditions        = options[:conditions]
       @action            = options[:action]
 
-      super "Could not #{@action} '#{@module_name}' (#{vstring}); downgrades are not allowed"
+      super _("Could not %{action} '%{module_name}' (%{version}); downgrades are not allowed") % { action: @action, module_name: @module_name, version: vstring }
     end
 
     def multiline
       message = []
-      message << "Could not #{@action} module '#{@module_name}' (#{vstring})"
-      message << "  Downgrading is not allowed."
+      message << _("Could not %{action} module '%{module_name}' (%{version})") % { action: @action, module_name: @module_name, version: vstring }
+      message << _("  Downgrading is not allowed.")
 
       message.join("\n")
     end

data/lib/puppet/module_tool/install_directory.rb

@@ -19,7 +19,7 @@ module Puppet
 
         begin
           @target.mkpath
-          Puppet.notice "Created target directory #{@target}"
+          Puppet.notice _("Created target directory %{dir}") % { dir: @target }
         rescue SystemCallError => orig_error
           raise converted_to_friendly_error(module_name, version, orig_error)
         end

data/lib/puppet/module_tool/installed_modules.rb

@@ -54,14 +54,14 @@ module Puppet::ModuleTool
     class ModuleRelease < SemanticPuppet::Dependency::ModuleRelease
       attr_reader :mod, :metadata
 
-      def initialize(source, mod)
+      def initialize(source, mod, strict_semver = true)
         @mod = mod
         @metadata = mod.metadata
         name = mod.forge_name.tr('/', '-')
         begin
           version = SemanticPuppet::Version.parse(mod.version)
         rescue SemanticPuppet::Version::ValidationFailure => e
-          Puppet.warning "#{mod.name} (#{mod.path}) has an invalid version number (#{mod.version}). The version has been set to 0.0.0. If you are the maintainer for this module, please update the metadata.json with a valid Semantic Version (http://semver.org)."
+          Puppet.warning _("%{module_name} (%{path}) has an invalid version number (%{version}). The version has been set to 0.0.0. If you are the maintainer for this module, please update the metadata.json with a valid Semantic Version (http://semver.org).") % { module_name: mod.name, path: mod.path, version: mod.version }
           version = SemanticPuppet::Version.parse("0.0.0")
         end
         release = "#{name}@#{version}"
@@ -70,7 +70,7 @@ module Puppet::ModuleTool
 
         if mod.dependencies
           mod.dependencies.each do |dependency|
-            results = Puppet::ModuleTool.parse_module_dependency(release, dependency)
+            results = Puppet::ModuleTool.parse_module_dependency(release, dependency, strict_semver)
             dep_name, parsed_range, range = results
 
             add_constraint('initialize', dep_name, range.to_s) do |node|

data/lib/puppet/module_tool/local_tarball.rb

@@ -8,11 +8,11 @@ module Puppet::ModuleTool
   class LocalTarball < SemanticPuppet::Dependency::Source
     attr_accessor :release
 
-    def initialize(filename)
+    def initialize(filename, strict_semver = true)
       unpack(filename, tmpdir)
       Puppet.debug "Unpacked local tarball to #{tmpdir}"
 
-      mod = Puppet::Module.new('tarball', tmpdir, nil)
+      mod = Puppet::Module.new('tarball', tmpdir, nil, strict_semver)
       @release = ModuleRelease.new(self, mod)
     end
 
@@ -52,7 +52,7 @@ module Puppet::ModuleTool
 
         if mod.dependencies
           dependencies = mod.dependencies.map do |dep|
-            Puppet::ModuleTool.parse_module_dependency(release, dep)[0..1]
+            Puppet::ModuleTool.parse_module_dependency(release, dep, mod.strict_semver?)[0..1]
           end
           dependencies = Hash[dependencies]
         end
@@ -83,7 +83,7 @@ module Puppet::ModuleTool
       begin
         Puppet::ModuleTool::Applications::Unpacker.unpack(file, destination)
       rescue Puppet::ExecutionFailure => e
-        raise RuntimeError, "Could not extract contents of module archive: #{e.message}"
+        raise RuntimeError, _("Could not extract contents of module archive: %{message}") % { message: e.message }
       end
     end
   end

data/lib/puppet/module_tool/metadata.rb

@@ -68,7 +68,7 @@ module Puppet::ModuleTool
       validate_version_range(version_requirement) if version_requirement
 
       if dup = @data['dependencies'].find { |d| d.full_module_name == name && d.version_requirement != version_requirement }
-        raise ArgumentError, "Dependency conflict for #{full_module_name}: Dependency #{name} was given conflicting version requirements #{version_requirement} and #{dup.version_requirement}. Verify that there are no duplicates in the metadata.json."
+        raise ArgumentError, _("Dependency conflict for %{module_name}: Dependency %{name} was given conflicting version requirements %{version_requirement} and %{dup_version}. Verify that there are no duplicates in the metadata.json.") % { module_name: full_module_name, name: name, version_requirement: version_requirement, dup_version: dup.version_requirement }
       end
 
       dep = Dependency.new(name, version_requirement, repository)
@@ -174,24 +174,24 @@ module Puppet::ModuleTool
 
       err = case modname
       when nil, '', :namespace_missing
-        "the field must be a namespaced module name"
+        _("the field must be a namespaced module name")
       when /[^a-z0-9_]/i
-        "the module name contains non-alphanumeric (or underscore) characters"
+        _("the module name contains non-alphanumeric (or underscore) characters")
       when /^[^a-z]/i
-        "the module name must begin with a letter"
+        _("the module name must begin with a letter")
       else
-        "the namespace contains non-alphanumeric characters"
+        _("the namespace contains non-alphanumeric characters")
       end
 
-      raise ArgumentError, "Invalid 'name' field in metadata.json: #{err}"
+      raise ArgumentError, _("Invalid 'name' field in metadata.json: %{err}") % { err: err }
     end
 
     # Validates that the version string can be parsed as per SemVer.
     def validate_version(version)
-      return if SemVer.valid?(version)
+      return if SemanticPuppet::Version.valid?(version)
 
-      err = "version string cannot be parsed as a valid Semantic Version"
-      raise ArgumentError, "Invalid 'version' field in metadata.json: #{err}"
+      err = _("version string cannot be parsed as a valid Semantic Version")
+      raise ArgumentError, _("Invalid 'version' field in metadata.json: %{err}") % { err: err }
     end
 
     # Validates that the given _value_ is a symbolic name that starts with a letter
@@ -203,19 +203,22 @@ module Puppet::ModuleTool
       err = nil
       if value.is_a?(String)
         unless value =~ /^[a-zA-Z][a-zA-Z0-9_]*$/
-          err = value =~ /^[a-zA-Z]/ ? 'contains non-alphanumeric characters' : 'must begin with a letter'
+          if value =~ /^[a-zA-Z]/
+            raise ArgumentError, _("field 'data_provider' contains non-alphanumeric characters")
+          else
+            raise ArgumentError, _("field 'data_provider' must begin with a letter")
+          end
         end
       else
-        err = 'must be a string'
+        raise ArgumentError, _("field 'data_provider' must be a string")
       end
-      raise ArgumentError, "field 'data_provider' #{err}" if err
     end
 
     # Validates that the version range can be parsed by Semantic.
     def validate_version_range(version_range)
       SemanticPuppet::VersionRange.parse(version_range)
     rescue ArgumentError => e
-      raise ArgumentError, "Invalid 'version_range' field in metadata.json: #{e}"
+      raise ArgumentError, _("Invalid 'version_range' field in metadata.json: %{err}") % { err: e }
     end
   end
 end

data/lib/puppet/module_tool/shared_behaviors.rb

@@ -29,14 +29,14 @@ module Puppet::ModuleTool::Shared
     @urls     = {}
     @versions = Hash.new { |h,k| h[k] = [] }
 
-    Puppet.notice "Downloading from #{forge.uri} ..."
+    Puppet.notice _("Downloading from %{uri} ...") % { uri: forge.uri }
     author, modname = Puppet::ModuleTool.username_and_modname_from(@module_name)
     info = forge.remote_dependency_info(author, modname, @options[:version])
     info.each do |pair|
       mod_name, releases = pair
       mod_name = mod_name.gsub('/', '-')
       releases.each do |rel|
-        semver = SemVer.new(rel['version'] || '0.0.0') rescue SemVer::MIN
+        semver = SemanticPuppet::Version.parse(rel['version']) rescue SemanticPuppet::Version::MIN
         @versions[mod_name] << { :vstring => rel['version'], :semver => semver }
         @versions[mod_name].sort! { |a, b| a[:semver] <=> b[:semver] }
         @urls["#{mod_name}@#{rel['version']}"] = rel['file']
@@ -76,10 +76,10 @@ module Puppet::ModuleTool::Shared
       }
 
       if forced?
-        range = SemVer[@version] rescue SemVer['>= 0.0.0']
+        range = SemanticPuppet::VersionRange.parse(@version, @strict_semver) rescue SemanticPuppet::VersionRange.parse('>= 0.0.0', @strict_semver)
       else
         range = (@conditions[mod]).map do |r|
-          SemVer[r[:dependency]] rescue SemVer['>= 0.0.0']
+          SemanticPuppet::VersionRange.parse(r[:dependency], @strict_semver) rescue SemanticPuppet::VersionRange.parse('>= 0.0.0', @strict_semver)
         end.inject(&:&)
       end
 
@@ -97,7 +97,7 @@ module Puppet::ModuleTool::Shared
       end
 
       if !(forced? || @installed[mod].empty? || source.last[:name] == :you)
-        next if range === SemVer.new(@installed[mod].first.version)
+        next if range === SemanticPuppet::Version.parse(@installed[mod].first.version)
         action = :upgrade
       elsif @installed[mod].empty?
         action = :install
@@ -151,7 +151,7 @@ module Puppet::ModuleTool::Shared
           cache_path = forge.retrieve(release[:file])
         end
       rescue OpenURI::HTTPError => e
-        raise RuntimeError, "Could not download module: #{e.message}", e.backtrace
+        raise RuntimeError, _("Could not download module: %{message}") % { message: e.message }, e.backtrace
       end
 
       [

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

@@ -3,7 +3,7 @@ source ENV['GEM_SOURCE'] || 'https://rubygems.org'
 puppetversion = ENV.key?('PUPPET_VERSION') ? ENV['PUPPET_VERSION'] : ['>= 3.3']
 gem 'metadata-json-lint'
 gem 'puppet', puppetversion
-gem 'puppetlabs_spec_helper', '>= 1.0.0'
+gem 'puppetlabs_spec_helper', '>= 1.2.0'
 gem 'puppet-lint', '>= 1.0.0'
 gem 'facter', '>= 1.7.0'
 gem 'rspec-puppet'

data/lib/puppet/module_tool/skeleton/templates/generator/README.md.erb

@@ -61,10 +61,16 @@ examples and code samples for doing things with your module.
 
 ## Reference
 
-Here, include a complete list of your module's classes, types, providers,
-facts, along with the parameters for each. Users refer to this section (thus
-the name "Reference") to find specific details; most users don't read it per
-se.
+Users need a complete list of your module's classes, types, defined types providers, facts, and functions, along with the parameters for each. You can provide this list either via Puppet Strings code comments or as a complete list in this Reference section.
+
+* If you are using Puppet Strings code comments, this Reference section should include Strings information so that your users know how to access your documentation.
+
+* If you are not using Puppet Strings, include a list of all of your classes, defined types, and so on, along with their parameters. Each element in this listing should include:
+
+  * The data type, if applicable.
+  * A description of what the element does.
+  * Valid values, if the data type doesn't make it obvious.
+  * Default value, if any.
 
 ## Limitations
 

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

@@ -24,9 +24,9 @@ task :validate do
   end
 end
 
-desc 'Run metadata_lint, lint, validate, and spec tests.'
+desc 'Run lint, validate, and spec tests.'
 task :test do
-  [:metadata_lint, :lint, :validate, :spec].each do |test|
+  [:lint, :validate, :spec].each do |test|
     Rake::Task[test].invoke
   end
 end

data/lib/puppet/module_tool/skeleton/templates/generator/examples/init.pp.erb

@@ -1,4 +1,4 @@
-# The baseline for module testing used by Puppet Labs is that each manifest
+# The baseline for module testing used by Puppet Inc. is that each manifest
 # should have a corresponding test manifest that declares that class or defined
 # type.
 #

data/lib/puppet/module_tool/tar.rb

@@ -6,12 +6,13 @@ module Puppet::ModuleTool::Tar
   require 'puppet/module_tool/tar/mini'
 
   def self.instance
-    if Puppet::Util.which('tar') && ! Puppet::Util::Platform.windows?
-      Gnu.new
-    elsif Puppet.features.minitar? && Puppet.features.zlib?
+    if Puppet.features.minitar? && Puppet.features.zlib?
       Mini.new
+    elsif Puppet::Util.which('tar') && ! Puppet::Util::Platform.windows?
+      Gnu.new
     else
-      raise RuntimeError, 'No suitable tar implementation found'
+      #TRANSLATORS "tar" is a program name and should not be translated
+      raise RuntimeError, _('No suitable tar implementation found')
     end
   end
 end

data/lib/puppet/module_tool.rb

@@ -34,7 +34,7 @@ module Puppet
       if matcher = full_module_name.match(FULL_MODULE_NAME_PATTERN)
         return matcher.captures
       else
-        raise ArgumentError, "Not a valid full name: #{full_module_name}"
+        raise ArgumentError, _("Not a valid full name: %{full_module_name}") % { full_module_name: full_module_name }
       end
     end
 
@@ -130,6 +130,9 @@ module Puppet
 
       # Note: environment will have expanded the path
       options[:target_dir] = face_environment.full_modulepath.first
+
+      # Default false to retain backward compatibility with SemanticPuppet 0.1.4
+      options[:strict_semver] = false
     end
 
     # Given a hash of options, we should discover or create a
@@ -162,15 +165,16 @@ module Puppet
     # @param where [String] a description of the thing we're parsing the
     #        dependency expression for
     # @param dep [Hash] the dependency description to parse
+    # @param strict_semver [Boolean] set to `false` to relax range semantics to include pre-releases
     # @return [Array(String, SemanticPuppet::VersionRange, String)] a tuple of the
     #         dependent module's name, the version range dependency, and the
     #         unparsed range expression.
-    def self.parse_module_dependency(where, dep)
+    def self.parse_module_dependency(where, dep, strict_semver = true)
       dep_name = dep['name'].tr('/', '-')
       range = dep['version_requirement'] || '>= 0.0.0'
 
       begin
-        parsed_range = SemanticPuppet::VersionRange.parse(range)
+        parsed_range = SemanticPuppet::VersionRange.parse(range, strict_semver)
       rescue ArgumentError => e
         Puppet.debug "Error in #{where} parsing dependency #{dep_name} (#{e.message}); using empty range."
         parsed_range = SemanticPuppet::VersionRange::EMPTY_RANGE

data/lib/puppet/network/auth_config_parser.rb

@@ -28,11 +28,12 @@ class AuthConfigParser
         right = rights.newright(name, count, @file)
       when /^\s*(allow(?:_ip)?|deny(?:_ip)?|method|environment|auth(?:enticated)?)\s+(.+?)(\s*#.*)?$/
         if right.nil?
-          raise Puppet::ConfigurationError, "Missing or invalid 'path' before right directive at line #{count} of #{@file}"
+          #TRANSLATORS "path" is a configuration file entry and should not be translated
+          raise Puppet::ConfigurationError, _("Missing or invalid 'path' before right directive at line %{count} of %{file}") % { count: count, file: @file }
         end
         parse_right_directive(right, $1, $2, count)
       else
-        raise Puppet::ConfigurationError, "Invalid line #{count}: #{line}"
+        raise Puppet::ConfigurationError, _("Invalid line %{count}: %{line}") % { count: count, line: line }
       end
       count += 1
     }
@@ -50,22 +51,22 @@ class AuthConfigParser
     value.strip!
     case var
     when "allow"
-      modify_right(right, :allow, value, "allowing %s access", count)
+      modify_right(right, :allow, value, _("allowing %s access"), count)
     when "deny"
-      modify_right(right, :deny, value, "denying %s access", count)
+      modify_right(right, :deny, value, _("denying %s access"), count)
     when "allow_ip"
-      modify_right(right, :allow_ip, value, "allowing IP %s access", count)
+      modify_right(right, :allow_ip, value, _("allowing IP %s access"), count)
     when "deny_ip"
-      modify_right(right, :deny_ip, value, "denying IP %s access", count)
+      modify_right(right, :deny_ip, value, _("denying IP %s access"), count)
     when "method"
-      modify_right(right, :restrict_method, value, "allowing 'method' %s", count)
+      modify_right(right, :restrict_method, value, _("allowing 'method' %s"), count)
     when "environment"
-      modify_right(right, :restrict_environment, value, "adding environment %s", count)
+      modify_right(right, :restrict_environment, value, _("adding environment %s"), count)
     when /auth(?:enticated)?/
-      modify_right(right, :restrict_authenticated, value, "adding authentication %s", count)
+      modify_right(right, :restrict_authenticated, value, _("adding authentication %s"), count)
     else
       raise Puppet::ConfigurationError,
-        "Invalid argument '#{var}' at line #{count}"
+        _("Invalid argument '%{var}' at line %{count}") % { var: var, count: count }
     end
   end
 
@@ -76,7 +77,7 @@ class AuthConfigParser
         right.info msg % val
         right.send(method, val)
       rescue Puppet::AuthStoreError => detail
-        raise Puppet::ConfigurationError, "#{detail} at line #{count} of #{@file}", detail.backtrace
+        raise Puppet::ConfigurationError, _("%{detail} at line %{count} of %{file}") % { detail: detail, count: count, file: @file }, detail.backtrace
       end
     end
   end

data/lib/puppet/network/authconfig.rb

@@ -51,7 +51,7 @@ module Puppet
     def insert_default_acl
       self.class.default_acl.each do |acl|
         unless rights[acl[:acl]]
-          Puppet.info "Inserting default '#{acl[:acl]}' (auth #{acl[:authenticated]}) ACL"
+          Puppet.info _("Inserting default '%{acl}' (auth %{auth}) ACL") % { acl: acl[:acl], auth: acl[:authenticated] }
           mk_acl(acl)
         end
       end
@@ -79,7 +79,7 @@ module Puppet
     # is denied.
     def check_authorization(method, path, params)
       if authorization_failure_exception = @rights.is_request_forbidden_and_why?(method, path, params)
-        Puppet.warning("Denying access: #{authorization_failure_exception}")
+        Puppet.warning(_("Denying access: %{authorization_failure_exception}") % { authorization_failure_exception: authorization_failure_exception })
         raise authorization_failure_exception
       end
     end

data/lib/puppet/network/authstore.rb

@@ -33,7 +33,7 @@ module Puppet
         return decl.result
       end
 
-      info "defaulting to no access for #{name}"
+      info _("defaulting to no access for %{name}") % { name: name }
       false
     end
 
@@ -254,7 +254,7 @@ module Puppet
           bits = 8*segments.length
           [:inexact, bits, IPAddr.new((segments+[0,0,0])[0,4].join(".") + "/#{bits}")]
         else
-          raise AuthStoreError, "Invalid IP pattern #{value}"
+          raise AuthStoreError, _("Invalid IP pattern %{value}") % { value: value }
         end
       end
 

data/lib/puppet/network/format.rb

@@ -6,14 +6,12 @@ class Puppet::Network::Format
   include Puppet::Confiner
 
   attr_reader :name, :mime
-  attr_accessor :intern_method, :render_method, :intern_multiple_method, :render_multiple_method, :weight, :required_methods, :extension
+  attr_accessor :intern_method, :render_method, :intern_multiple_method, :render_multiple_method, :weight, :required_methods, :extension, :charset
 
   def init_attribute(name, default)
-    if value = @options[name]
-      @options.delete(name)
-    else
-      value = default
-    end
+    value = @options.delete(name)
+    value = default if value.nil?
+
     self.send(name.to_s + "=", value)
   end
 
@@ -36,6 +34,7 @@ class Puppet::Network::Format
     init_attribute(:weight, 5)
     init_attribute(:required_methods, method_list.keys)
     init_attribute(:extension, name.to_s)
+    init_attribute(:charset, nil)
 
     method_list.each do |method, value|
       init_attribute(method, value)
@@ -70,7 +69,8 @@ class Puppet::Network::Format
   def render_multiple(instances)
     # This method implicitly assumes that all instances are of the same type.
     return instances[0].class.send(render_multiple_method, instances) if instances[0].class.respond_to?(render_multiple_method)
-    raise NotImplementedError, "#{instances[0].class} does not respond to #{render_multiple_method}; can not intern multiple instances to #{mime}"
+    raise NotImplementedError, _("%{klass} does not respond to %{method}; can not render multiple instances to %{mime}") \
+                               % { klass: instances[0].class, method: render_multiple_method, mime: mime }
   end
 
   def required_methods_present?(klass)

data/lib/puppet/network/format_handler.rb

@@ -62,7 +62,11 @@ module Puppet::Network::FormatHandler
     else
       out = format(format)
     end
-    raise ArgumentError, "No format match the given format name or mime-type (#{format})" if out.nil?
+
+    if out.nil?
+      raise ArgumentError, _("No format matches the given format name or mime-type (%{format})") % {format: format}
+    end
+
     out.name
   end
 
@@ -74,10 +78,11 @@ module Puppet::Network::FormatHandler
   #   (most preferred is first)
   # @param supported [Array<Symbol>] the names of the supported formats (the
   #   most preferred format is first)
-  # @return [Puppet::Network::Format, nil] the most suitable format
+  # @return [Array<Puppet::Network::Format>] the most suitable formats that
+  #   are both accepted and supported
   # @api private
-  def self.most_suitable_format_for(accepted, supported)
-    format_name = accepted.collect do |format|
+  def self.most_suitable_formats_for(accepted, supported)
+    accepted.collect do |format|
       format.to_s.sub(/;q=.*$/, '')
     end.collect do |format|
       if format == ALL_MEDIA_TYPES
@@ -85,12 +90,10 @@ module Puppet::Network::FormatHandler
       else
         format_to_canonical_name_or_nil(format)
       end
-    end.find do |format|
+    end.compact.find_all do |format|
       supported.include?(format)
-    end
-
-    if format_name
-      format_for(format_name)
+    end.collect do |format|
+      format_for(format)
     end
   end
 

data/lib/puppet/network/format_support.rb

@@ -11,19 +11,22 @@ module Puppet::Network::FormatSupport
     def convert_from(format, data)
       get_format(format).intern(self, data)
     rescue => err
-      raise Puppet::Network::FormatHandler::FormatError, "Could not intern from #{format}: #{err}", err.backtrace
+      #TRANSLATORS "intern" is a function name and should not be translated
+      raise Puppet::Network::FormatHandler::FormatError, _("Could not intern from %{format}: %{err}") % { format: format, err: err }, err.backtrace
     end
 
     def convert_from_multiple(format, data)
       get_format(format).intern_multiple(self, data)
     rescue => err
-      raise Puppet::Network::FormatHandler::FormatError, "Could not intern_multiple from #{format}: #{err}", err.backtrace
+      #TRANSLATORS "intern_multiple" is a function name and should not be translated
+      raise Puppet::Network::FormatHandler::FormatError, _("Could not intern_multiple from %{format}: %{err}") % { format: format, err: err }, err.backtrace
     end
 
     def render_multiple(format, instances)
       get_format(format).render_multiple(instances)
     rescue => err
-      raise Puppet::Network::FormatHandler::FormatError, "Could not render_multiple to #{format}: #{err}", err.backtrace
+      #TRANSLATORS "render_multiple" is a function name and should not be translated
+      raise Puppet::Network::FormatHandler::FormatError, _("Could not render_multiple to %{format}: %{err}") % { format: format, err: err }, err.backtrace
     end
 
     def default_format
@@ -88,6 +91,7 @@ module Puppet::Network::FormatSupport
     to_data_hash.to_msgpack(*args)
   end
 
+  # @deprecated, use to_json
   def to_pson(*args)
     to_data_hash.to_pson(*args)
   end
@@ -101,7 +105,8 @@ module Puppet::Network::FormatSupport
 
     self.class.get_format(format).render(self)
   rescue => err
-    raise Puppet::Network::FormatHandler::FormatError, "Could not render to #{format}: #{err}", err.backtrace
+    #TRANSLATORS "render" is a function name and should not be translated
+    raise Puppet::Network::FormatHandler::FormatError, _("Could not render to %{format}: %{err}") % { format: format, err: err }, err.backtrace
   end
 
   def mime(format = nil)
@@ -109,7 +114,8 @@ module Puppet::Network::FormatSupport
 
     self.class.get_format(format).mime
   rescue => err
-    raise Puppet::Network::FormatHandler::FormatError, "Could not mime to #{format}: #{err}", err.backtrace
+    #TRANSLATORS "mime" is a function name and should not be translated
+    raise Puppet::Network::FormatHandler::FormatError, _("Could not mime to %{format}: %{err}") % { format: format, err: err }, err.backtrace
   end
 
   def support_format?(name)