puppet 5.3.3-x64-mingw32 → 5.3.4-x64-mingw32

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

@@ -63,7 +63,13 @@ Puppet::Face.define(:module, '1.0.0') do
       name = name.gsub('/', '-')
 
       Puppet::ModuleTool.set_option_defaults options
-      Puppet.notice _("Preparing to uninstall '%{name}'") % { name: name } << (options[:version] ? " (#{colorize(:cyan, options[:version].sub(/^(?=\d)/, 'v'))})" : '') << " ..."
+      message = if options[:version]
+                  module_version = colorize(:cyan, options[:version].sub(/^(?=\d)/, 'v'))
+                  _("Preparing to uninstall '%{name}' (%{module_version}) ...") % { name: name, module_version: module_version }
+                else
+                  _("Preparing to uninstall '%{name}' ...") % { name: name }
+                end
+      Puppet.notice message
       Puppet::ModuleTool::Applications::Uninstaller.run(name, options)
     end
 
@@ -73,8 +79,13 @@ Puppet::Face.define(:module, '1.0.0') do
         exit 1
       else
         mod = return_value[:affected_modules].first
-        module_version = mod.version ? " (#{colorize(:cyan, mod.version.to_s.sub(/^(?=\d)/, 'v'))})" : ''
-        _("Removed '%{name}'%{module_version} from %{path}") % { name: return_value[:module_name], module_version: module_version, path: mod.modulepath }
+        message = if mod.version
+                    module_version = colorize(:cyan, mod.version.to_s.sub(/^(?=\d)/, 'v'))
+                    _("Removed '%{name}' (%{module_version}) from %{path}") % { name: return_value[:module_name], module_version: module_version, path: mod.modulepath }
+                  else
+                    _("Removed '%{name}' from %{path}") % { name: return_value[:module_name], path: mod.modulepath }
+                  end
+        message
       end
     end
   end

data/lib/puppet/face/node.rb

@@ -17,6 +17,7 @@ Puppet::Indirector::Face.define(:node, '0.0.1') do
   find = get_action(:find)
   find.summary _("Retrieve a node object.")
   find.arguments _("<host>")
+  #TRANSLATORS the following are specific names and should not be translated `classes`, `environment`, `expiration`, `name`, `parameters`, Puppet::Node
   find.returns _(<<-'EOT')
     A hash containing the node's `classes`, `environment`, `expiration`, `name`,
     `parameters` (its facts, combined with any ENC-set parameters), and `time`.

data/lib/puppet/face/status.rb

@@ -13,6 +13,7 @@ Puppet::Indirector::Face.define(:status, '0.0.1') do
   find = get_action(:find)
   find.default = true
   find.summary _("Check status of puppet master server.")
+  #TRANSLATORS the string 'Puppet::Status' is a Puppet language object and should not be translated
   find.returns _(<<-'EOT')
     A "true" response or a low-level connection error. When used from the Ruby
     API: returns a Puppet::Status object.

data/lib/puppet/file_serving/base.rb

@@ -46,7 +46,8 @@ class Puppet::FileServing::Base
   def links=(value)
     value = value.to_sym
     value = :manage if value == :ignore
-    raise(ArgumentError, ":links can only be set to :manage or :follow") unless [:manage, :follow].include?(value)
+    #TRANSLATORS ':link', ':manage', ':follow' should not be translated
+    raise(ArgumentError, _(":links can only be set to :manage or :follow")) unless [:manage, :follow].include?(value)
     @links = value
   end
 

data/lib/puppet/file_serving/configuration.rb

@@ -4,6 +4,7 @@ require 'puppet/file_serving/mount'
 require 'puppet/file_serving/mount/file'
 require 'puppet/file_serving/mount/modules'
 require 'puppet/file_serving/mount/plugins'
+require 'puppet/file_serving/mount/locales'
 require 'puppet/file_serving/mount/pluginfacts'
 require 'puppet/file_serving/mount/tasks'
 
@@ -81,6 +82,8 @@ class Puppet::FileServing::Configuration
     @mounts["modules"].allow('*') if @mounts["modules"].empty?
     @mounts["plugins"] ||= Mount::Plugins.new("plugins")
     @mounts["plugins"].allow('*') if @mounts["plugins"].empty?
+    @mounts["locales"] ||= Mount::Locales.new("locales")
+    @mounts["locales"].allow('*') if @mounts["locales"].empty?
     @mounts["pluginfacts"] ||= Mount::PluginFacts.new("pluginfacts")
     @mounts["pluginfacts"].allow('*') if @mounts["pluginfacts"].empty?
     @mounts["tasks"] ||= Mount::Tasks.new("tasks")

data/lib/puppet/file_serving/configuration/parser.rb

@@ -13,9 +13,9 @@ class Puppet::FileServing::Configuration::Parser
     @mounts = {}
     @count = 0
 
-    File.open(@file) { |f|
+    File.open(@file) do |f|
       mount = nil
-      f.each_line { |line|
+      f.each_line do |line|
         # Have the count increment at the top, in case we throw exceptions.
         @count += 1
 
@@ -37,13 +37,17 @@ class Puppet::FileServing::Configuration::Parser
           when "deny"
             deny(mount, value)
           else
-            raise ArgumentError.new(_("Invalid argument '%{var}' in %{file}, line %{line_num}") % { var: var, file: @file.filename, line_num: @count })
+            error_location_str = Puppet::Util::Errors.error_location(@file.filename, @count)
+            raise ArgumentError.new(_("Invalid argument '%{var}' at %{error_location}") %
+                                        { var: var, error_location: error_location_str })
           end
         else
-          raise ArgumentError.new(_("Invalid line '%{line}' at %{file}, line %{line_num}") % { line: line.chomp, file: @file.filename, line_num: @count })
+          error_location_str = Puppet::Util::Errors.error_location(@file.filename, @count)
+          raise ArgumentError.new(_("Invalid entry at %{error_location}: '%{file_text}'") %
+                                      { file_text: line.chomp, error_location: error_location_str })
         end
-      }
-    }
+      end
+    end
 
     validate
 
@@ -67,7 +71,9 @@ class Puppet::FileServing::Configuration::Parser
         mount.info _("allowing %{val} access") % { val: val }
         mount.allow(val)
       rescue Puppet::AuthStoreError => detail
-        raise ArgumentError.new(_("%{detail} in %{file}, line %{line_num}") % { detail: detail.to_s, file: @file, line_num: @count })
+        error_location_str = Puppet::Util::Errors.error_location(@file, @count)
+        raise ArgumentError.new("%{detail} %{error_location}" %
+                                    { detail: detail.to_s, error_location: error_location_str })
       end
     }
   end
@@ -79,14 +85,20 @@ class Puppet::FileServing::Configuration::Parser
         mount.info _("denying %{val} access") % { val: val }
         mount.deny(val)
       rescue Puppet::AuthStoreError => detail
-        raise ArgumentError.new(_("%{detail} in %{file}, line %{line_num}") % { detail: detail.to_s, file: @file, line_num: @count })
+        error_location_str = Puppet::Util::Errors.error_location(@file, @count)
+        raise ArgumentError.new("%{detail} %{error_location}" %
+                                    { detail: detail.to_s, error_location: error_location_str  })
       end
     }
   end
 
   # Create a new mount.
   def newmount(name)
-    raise ArgumentError.new(_("%{mount} is already mounted at %{name} in %{file}, line %{line_num}") % { mount: @mounts[name], name: name, file: @file, line_num: @count }) if @mounts.include?(name)
+    if @mounts.include?(name)
+      error_location_str = Puppet::Util::Errors.error_location(@file, @count)
+      raise ArgumentError.new(_("%{mount} is already mounted at %{name} at %{error_location}") %
+                                  { mount: @mounts[name], name: name, error_location: error_location_str })
+    end
     case name
     when "modules"
       mount = Mount::Modules.new(name)
@@ -94,6 +106,8 @@ class Puppet::FileServing::Configuration::Parser
       mount = Mount::Plugins.new(name)
     when "tasks"
       mount = Mount::Tasks.new(name)
+    when "locales"
+      mount = Mount::Locales.new(name)
     else
       mount = Mount::File.new(name)
     end

data/lib/puppet/file_serving/mount/locales.rb

@@ -0,0 +1,35 @@
+require 'puppet/file_serving/mount'
+
+# Find files in the modules' locales directories.
+# This is a very strange mount because it merges
+# many directories into one.
+class Puppet::FileServing::Mount::Locales < Puppet::FileServing::Mount
+  # Return an instance of the appropriate class.
+  def find(relative_path, request)
+    return nil unless mod = request.environment.modules.find { |m|  m.locale(relative_path) }
+
+    path = mod.locale(relative_path)
+
+    path
+  end
+
+  def search(relative_path, request)
+    # We currently only support one kind of search on locales - return
+    # them all.
+    Puppet.debug("Warning: calling Locales.search with empty module path.") if request.environment.modules.empty?
+    paths = request.environment.modules.find_all { |mod| mod.locales? }.collect { |mod| mod.locale_directory }
+    if paths.empty?
+      # If the modulepath is valid then we still need to return a valid root
+      # directory for the search, but make sure nothing inside it is
+      # returned.
+      request.options[:recurse] = false
+      request.environment.modulepath.empty? ? nil : request.environment.modulepath
+    else
+      paths
+    end
+  end
+
+  def valid?
+    true
+  end
+end

data/lib/puppet/forge.rb

@@ -134,7 +134,8 @@ class Puppet::Forge < SemanticPuppet::Dependency::Source
             Puppet::ModuleTool::Metadata.new.add_dependency(dep['name'], dep['version_requirement'], dep['repository'])
             Puppet::ModuleTool.parse_module_dependency(release, dep, strict_semver)[0..1]
           rescue ArgumentError => e
-            raise ArgumentError, "Malformed dependency: #{dep['name']}. Exception was: #{e}"
+            raise ArgumentError, _("Malformed dependency: %{name}.") % { name: dep['name'] } +
+                ' ' + _("Exception was: %{detail}") % { detail: e }
           end
         end
       else

data/lib/puppet/forge/errors.rb

@@ -32,12 +32,12 @@ module Puppet::Forge::Errors
     #
     # @return [String] the multiline version of the error message
     def multiline
-      _(<<-EOS).chomp % { uri: @uri }
-Could not connect via HTTPS to %{uri}
-  Unable to verify the SSL certificate
-    The certificate may not be signed by a valid CA
-    The CA bundle included with OpenSSL may not be valid or up to date
-      EOS
+      message = []
+      message << _('Could not connect via HTTPS to %{uri}') % { uri: @uri }
+      message << _('  Unable to verify the SSL certificate')
+      message << _('    The certificate may not be signed by a valid CA')
+      message << _('    The CA bundle included with OpenSSL may not be valid or up to date')
+      message.join("\n")
     end
   end
 
@@ -59,12 +59,12 @@ Could not connect via HTTPS to %{uri}
     #
     # @return [String] the multiline version of the error message
     def multiline
-      _(<<-EOS).chomp % { uri: @uri, detail: @detail }
-Could not connect to %{uri}
-  There was a network communications problem
-    The error we caught said '%{detail}'
-    Check your network connection and try again
-      EOS
+      message = []
+      message << _('Could not connect to %{uri}') % { uri: @uri }
+      message << _('  There was a network communications problem')
+      message << _("    The error we caught said '%{detail}'") % { detail: @detail }
+      message << _('    Check your network connection and try again')
+      message.join("\n")
     end
   end
 
@@ -89,9 +89,11 @@ Could not connect to %{uri}
       rescue JSON::ParserError
       end
 
-      message = _("Request to Puppet Forge failed. Detail: ")
-      message << @message << " / " if @message
-      message << @response << "."
+      message = if @message
+                  _("Request to Puppet Forge failed.") + ' ' + _("Detail: %{detail}.") % { detail: "#{@message} / #{@response}" }
+                else
+                  _("Request to Puppet Forge failed.") + ' ' + _("Detail: %{detail}.") % { detail: @response }
+                end
       super(message, original)
     end
 
@@ -99,13 +101,13 @@ Could not connect to %{uri}
     #
     # @return [String] the multiline version of the error message
     def multiline
-      message = _(<<-EOS).chomp % { uri: @uri, response: @response }
-Request to Puppet Forge failed.
-  The server being queried was %{uri}
-  The HTTP response we received was '%{response}'
-      EOS
-      message << _("\n  The message we received said '%{message}'") % { message: @message } if @message
-      message
+
+      message = []
+      message << _('Request to Puppet Forge failed.')
+      message << _('  The server being queried was %{uri}') % { uri: @uri }
+      message << _("  The HTTP response we received was '%{response}'") % { response: @response }
+      message << _("  The message we received said '%{message}'") % { message: @message } if @message
+      message.join("\n")
     end
   end
 

data/lib/puppet/functions/binary_file.rb

@@ -12,6 +12,7 @@ Puppet::Functions.create_function(:binary_file, Puppet::Functions::InternalFunct
   def binary_file(scope, unresolved_path)
     path = Puppet::Parser::Files.find_file(unresolved_path, scope.compiler.environment)
     unless path && Puppet::FileSystem.exist?(path)
+      #TRANSLATORS the string "binary_file()" should not be translated
       raise Puppet::ParseError, _("binary_file(): The given file '%{unresolved_path}' does not exist") % { unresolved_path: unresolved_path }
     end
     Puppet::Pops::Types::PBinaryType::Binary.from_binary_string(Puppet::FileSystem.binread(path))

data/lib/puppet/functions/each.rb

@@ -117,8 +117,11 @@ Puppet::Functions.create_function(:each) do
 
   def foreach_Hash_1(hash)
     enumerator = hash.each_pair
-    hash.size.times do
-      yield(enumerator.next)
+    begin
+      hash.size.times do
+        yield(enumerator.next)
+      end
+    rescue StopIteration
     end
     # produces the receiver
     hash
@@ -126,8 +129,11 @@ Puppet::Functions.create_function(:each) do
 
   def foreach_Hash_2(hash)
     enumerator = hash.each_pair
-    hash.size.times do
-      yield(*enumerator.next)
+    begin
+      hash.size.times do
+        yield(*enumerator.next)
+      end
+    rescue StopIteration
     end
     # produces the receiver
     hash

data/lib/puppet/functions/eyaml_lookup_key.rb

@@ -26,8 +26,10 @@ Puppet::Functions.create_function(:eyaml_lookup_key) do
     # Can't do this with an argument_mismatch dispatcher since there is no way to declare a struct that at least
     # contains some keys but may contain other arbitrary keys.
     unless options.include?('path')
+      #TRANSLATORS 'eyaml_lookup_key':, 'path', 'paths' 'glob', 'globs', 'mapped_paths', and lookup_key should not be translated
       raise ArgumentError,
-        "'eyaml_lookup_key': one of 'path', 'paths' 'glob', 'globs' or 'mapped_paths' must be declared in hiera.yaml when using this lookup_key function"
+        _("'eyaml_lookup_key': one of 'path', 'paths' 'glob', 'globs' or 'mapped_paths' must be declared in hiera.yaml"\
+              " when using this lookup_key function")
     end
 
     # nil key is used to indicate that the cache contains the raw content of the eyaml file
@@ -48,7 +50,7 @@ Puppet::Functions.create_function(:eyaml_lookup_key) do
         if data.is_a?(Hash)
           Puppet::Pops::Lookup::HieraConfig.symkeys_to_string(data)
         else
-          Puppet.warning("#{path}: file does not contain a valid yaml hash")
+          Puppet.warning(_("%{path}: file does not contain a valid yaml hash") % { path: path })
           {}
         end
       rescue YAML::SyntaxError => ex

data/lib/puppet/functions/lookup.rb

@@ -91,8 +91,8 @@
 # merged hash. If the same key exists in multiple source hashes, Puppet will
 # recursively merge hash or array values (with duplicate values removed from
 # arrays). For conflicting scalar values, the highest-priority value will win.
-# * `{'strategy' => 'first|unique|hash'}` --- Same as the string versions of these
-# merge behaviors.
+# * `{'strategy' => 'first'}`, `{'strategy' => 'unique'}`,
+# or `{'strategy' => 'hash'}` --- Same as the string versions of these merge behaviors.
 # * `{'strategy' => 'deep', <DEEP OPTION> => <VALUE>, ...}` --- Same as `'deep'`,
 # but can adjust the merge with additional options. The available options are:
 #     * `'knockout_prefix'` (string or undef) --- A string prefix to indicate a

data/lib/puppet/functions/map.rb

@@ -88,11 +88,21 @@ Puppet::Functions.create_function(:map) do
   end
 
   def map_Hash_1(hash)
-    hash.map {|x, y| yield([x, y]) }
+    result = []
+    begin
+      hash.map {|x, y| result << yield([x, y]) }
+    rescue StopIteration
+    end
+    result
   end
 
   def map_Hash_2(hash)
-    hash.map {|x, y| yield(x, y) }
+    result = []
+    begin
+      hash.map {|x, y| result << yield(x, y) }
+    rescue StopIteration
+    end
+    result
   end
 
   def map_Enumerable_1(enumerable)

data/lib/puppet/functions/slice.rb

@@ -102,9 +102,8 @@ Puppet::Functions.create_function(:slice) do
       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}; ") % { slice_size: slice_size, serving_size: serving_size }+
-      pblock.parameter_names.join(', ')
+      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}; %{parameter_names}") %
+          { slice_size: slice_size, serving_size: serving_size, parameter_names: pblock.parameter_names.join(', ') }
     end
     serving_size
   end

data/lib/puppet/functions/unique.rb

@@ -70,7 +70,7 @@
 #
 # @example turning a string or array into a hash with index keys
 #
-# ~~puppet
+# ~~~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]})

data/lib/puppet/functions/yaml_data.rb

@@ -25,7 +25,7 @@ Puppet::Functions.create_function(:yaml_data) do
         if data.is_a?(Hash)
           Puppet::Pops::Lookup::HieraConfig.symkeys_to_string(data)
         else
-          Puppet.warning("#{path}: file does not contain a valid yaml hash")
+          Puppet.warning(_("%{path}: file does not contain a valid yaml hash" % { path: path }))
           {}
         end
       rescue YAML::SyntaxError => ex

data/lib/puppet/gettext/config.rb

@@ -6,9 +6,10 @@ module Puppet::GettextConfig
   POSIX_PATH = File.absolute_path('../../../../../share/locale', File.dirname(__FILE__))
   WINDOWS_PATH = File.absolute_path('../../../../../../../puppet/share/locale', File.dirname(__FILE__))
 
+  DEFAULT_TEXT_DOMAIN = 'default-text-domain'
+
   # Load gettext helpers and track whether they're available.
   # Used instead of features because we initialize gettext before features is available.
-  # Stubbing gettext if unavailable is handled in puppet.rb.
   begin
     require 'fast_gettext'
     require 'locale'
@@ -34,33 +35,128 @@ module Puppet::GettextConfig
   end
 
   # @api private
-  # Whether translations have been loaded for a given project
-  # @param project_name [String] the project whose translations we are querying
-  # @return [Boolean] true if translations have been loaded for the project
-  def self.translations_loaded?(project_name)
-    return false unless gettext_loaded?
-    if @loaded_repositories[project_name]
-      return true
+  # Returns the currently selected locale from FastGettext,
+  # or 'en' of gettext has not been loaded
+  # @return [String] the active locale
+  def self.current_locale
+    if gettext_loaded?
+      return FastGettext.default_locale
     else
-      return false
+      return 'en'
     end
   end
 
   # @api private
-  # Creates a new empty text domain with the given name, replacing
-  # any existing domain with that name, then switches to using
-  # that domain. Also clears the cache of loaded translations.
-  # @param domain_name [String] the name of the domain to create
-  def self.create_text_domain(domain_name)
-    return unless gettext_loaded?
-    # Clear the cache of loaded translation repositories
-    @loaded_repositories = {}
-    FastGettext.add_text_domain(domain_name, type: :chain, chain: [])
-    #TODO remove this when we start managing domains per environment
-    FastGettext.default_text_domain = domain_name
+  # Returns a list of the names of the loaded text domains
+  # @return [[String]] the names of the loaded text domains
+  def self.loaded_text_domains
+    return [] if @gettext_disabled || !gettext_loaded?
+
+    return FastGettext.translation_repositories.keys
+  end
+
+  # @api private
+  # Clears the translation repository for the given text domain,
+  # creating it if it doesn't exist, then adds default translations
+  # and switches to using this domain.
+  # @param [String] domain_name the name of the domain to create
+  def self.reset_text_domain(domain_name)
+    return if @gettext_disabled || !gettext_loaded?
+
+    FastGettext.add_text_domain(domain_name,
+                                type: :chain,
+                                chain: [],
+                                report_warning: false)
+    copy_default_translations(domain_name)
     FastGettext.text_domain = domain_name
   end
 
+  # @api private
+  # Creates a default text domain containing the translations for
+  # Puppet as the start of chain. When semantic_puppet gets initialized,
+  # its translations are added to this chain. This is used as a cache
+  # so that all non-module translations only need to be loaded once as
+  # we create and reset environment-specific text domains.
+  #
+  # @return true if Puppet translations were successfully loaded, false
+  # otherwise
+  def self.create_default_text_domain
+    return if @gettext_disabled || !gettext_loaded?
+
+    FastGettext.add_text_domain(DEFAULT_TEXT_DOMAIN,
+                                type: :chain,
+                                chain: [],
+                                report_warning: false)
+    FastGettext.default_text_domain = DEFAULT_TEXT_DOMAIN
+
+    load_translations('puppet', puppet_locale_path, translation_mode(puppet_locale_path), DEFAULT_TEXT_DOMAIN)
+  end
+
+  # @api private
+  # Switches the active text domain, if the requested domain exists.
+  # @param [String] domain_name the name of the domain to switch to
+  def self.use_text_domain(domain_name)
+    return if @gettext_disabled || !gettext_loaded?
+
+    if FastGettext.translation_repositories.include?(domain_name)
+      FastGettext.text_domain = domain_name
+    end
+  end
+
+  # @api private
+  # Delete all text domains.
+  def self.delete_all_text_domains
+    FastGettext.translation_repositories.clear
+    FastGettext.default_text_domain = nil
+    FastGettext.text_domain = nil
+  end
+
+  # @api private
+  # Deletes the text domain with the given name
+  # @param [String] domain_name the name of the domain to delete
+  def self.delete_text_domain(domain_name)
+    return if @gettext_disabled || !gettext_loaded?
+
+    FastGettext.translation_repositories.delete(domain_name)
+    if FastGettext.text_domain == domain_name
+      FastGettext.text_domain = nil
+    end
+  end
+
+  # @api private
+  # Deletes all text domains except the default one
+  def self.delete_environment_text_domains
+    return if @gettext_disabled || !gettext_loaded?
+
+    FastGettext.translation_repositories.keys.each do |key|
+      # do not clear default translations
+      next if key == DEFAULT_TEXT_DOMAIN
+
+      FastGettext.translation_repositories.delete(key)
+    end
+    FastGettext.text_domain = nil
+  end
+
+  # @api private
+  # Adds translations from the default text domain to the specified
+  # text domain. Creates the default text domain if one does not exist
+  # (this will load Puppet's translations).
+  #
+  # Since we are currently (Nov 2017) vendoring semantic_puppet, in normal
+  # flows these translations will be copied along with Puppet's.
+  #
+  # @param [String] domain_name the name of the domain to add translations to
+  def self.copy_default_translations(domain_name)
+    return if @gettext_disabled || !gettext_loaded?
+
+    if FastGettext.default_text_domain.nil?
+      create_default_text_domain
+    end
+
+    puppet_translations = FastGettext.translation_repositories[FastGettext.default_text_domain].chain
+    FastGettext.translation_repositories[domain_name].chain.push(*puppet_translations)
+  end
+
   # @api private
   # Search for puppet gettext config files
   # @return [String] path to the config, or nil if not found
@@ -78,7 +174,7 @@ module Puppet::GettextConfig
 
   # @api private
   # Determine which translation file format to use
-  # @param conf_path [String] the path to the gettext config file
+  # @param [String] conf_path the path to the gettext config file
   # @return [Symbol] :mo if in a package structure, :po otherwise
   def self.translation_mode(conf_path)
     if WINDOWS_PATH == conf_path || POSIX_PATH == conf_path
@@ -96,11 +192,15 @@ module Puppet::GettextConfig
 
   # @api private
   # Attempt to load tranlstions for the given project.
-  # @param project_name [String] the project whose translations we want to load
-  # @param locale_dir [String] the path to the directory containing translations
-  # @param file_format [Symbol] translation file format to use, either :po or :mo
+  # @param [String] project_name the project whose translations we want to load
+  # @param [String] locale_dir the path to the directory containing translations
+  # @param [Symbol] file_format translation file format to use, either :po or :mo
   # @return true if initialization succeeded, false otherwise
-  def self.load_translations(project_name, locale_dir, file_format)
+  def self.load_translations(project_name, locale_dir, file_format, text_domain = FastGettext.text_domain)
+    if project_name.nil? || project_name.empty?
+      raise Puppet::Error, "A project name must be specified in order to initialize translations."
+    end
+
     return false if @gettext_disabled || !@gettext_loaded
 
     return false unless locale_dir && Puppet::FileSystem.exist?(locale_dir)
@@ -109,38 +209,41 @@ module Puppet::GettextConfig
       raise Puppet::Error, "Unsupported translation file format #{file_format}; please use :po or :mo"
     end
 
-    if project_name.nil? || project_name.empty?
-      raise Puppet::Error, "A project name must be specified in order to initialize translations."
-    end
-
-    add_repository_to_domain(project_name, locale_dir, file_format)
+    add_repository_to_domain(project_name, locale_dir, file_format, text_domain)
     return true
   end
 
   # @api private
   # Add the translations for this project to the domain's repository chain
   # chain for the currently selected text domain, if needed.
-  # @param project_name [String] the name of the project for which to load translations
-  # @param locale_dir [String] the path to the directory containing translations
-  # @param file_format [Symbol] the fomat of the translations files, :po or :mo
-  def self.add_repository_to_domain(project_name, locale_dir, file_format)
-    # check if we've already loaded these transltaions
-    current_chain = FastGettext.translation_repositories[FastGettext.text_domain].chain
-    return current_chain if @loaded_repositories[project_name]
+  # @param [String] project_name the name of the project for which to load translations
+  # @param [String] locale_dir the path to the directory containing translations
+  # @param [Symbol] file_format the fomat of the translations files, :po or :mo
+  def self.add_repository_to_domain(project_name, locale_dir, file_format, text_domain = FastGettext.text_domain)
+    return if @gettext_disabled || !gettext_loaded?
+
+    current_chain = FastGettext.translation_repositories[text_domain].chain
 
     repository = FastGettext::TranslationRepository.build(project_name,
                                                           path: locale_dir,
                                                           type: file_format,
-                                                          ignore_fuzzy: false)
-    @loaded_repositories[project_name] = true
+                                                          report_warning: false)
     current_chain << repository
   end
 
+  # @api private
+  # Sets FastGettext's locale to the current system locale
+  def self.setup_locale
+    return if @gettext_disabled || !gettext_loaded?
+
+    set_locale(Locale.current.language)
+  end
+
   # @api private
   # Sets the language in which to display strings.
-  # @param locale [String] the language portion of a locale string (e.g. "ja")
+  # @param [String] locale the language portion of a locale string (e.g. "ja")
   def self.set_locale(locale)
-    return if !gettext_loaded?
+    return if @gettext_disabled || !gettext_loaded?
     # make sure we're not using the `available_locales` machinery
     FastGettext.default_available_locales = nil