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

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
 

data/lib/puppet/gettext/module_translations.rb

@@ -0,0 +1,42 @@
+require 'puppet/gettext/config'
+
+module Puppet::ModuleTranslations
+
+  # @api private
+  # Loads translation files for each of the specified modules,
+  # if present. Requires the modules to have `forge_name` specified.
+  # @param [[Module]] modules a list of modules for which to
+  #        load translations
+  def self.load_from_modulepath(modules)
+    modules.each do |mod|
+      next unless mod.forge_name && mod.has_translations?(Puppet::GettextConfig.current_locale)
+
+      module_name = mod.forge_name.gsub('/', '-')
+      if Puppet::GettextConfig.load_translations(module_name, mod.locale_directory, :po)
+        Puppet.debug "Loaded translations for #{module_name}."
+      elsif Puppet::GettextConfig.gettext_loaded?
+        Puppet.debug "Could not find translation files for #{module_name} at #{mod.locale_directory}. Skipping translation initialization."
+      else
+        Puppet.warn_once("gettext_unavailable", "gettext_unavailable", "No gettext library found, skipping translation initialization.")
+      end
+    end
+  end
+
+  # @api private
+  # Loads translation files that have been pluginsync'd for modules
+  # from the $vardir.
+  # @param [String] vardir the path to Puppet's vardir
+  def self.load_from_vardir(vardir)
+    locale = Puppet::GettextConfig.current_locale
+    Dir.glob("#{vardir}/locales/#{locale}/*.po") do |f|
+      module_name = File.basename(f, ".po")
+      if Puppet::GettextConfig.load_translations(module_name, File.join(vardir, "locales"), :po)
+        Puppet.debug "Loaded translations for #{module_name}."
+      elsif Puppet::GettextConfig.gettext_loaded?
+        Puppet.debug "Could not load translations for #{module_name}."
+      else
+        Puppet.warn_once("gettext_unavailable", "gettext_unavailable", "No gettext library found, skipping translation initialization.")
+      end
+    end
+  end
+end

data/lib/puppet/graph/relationship_graph.rb

@@ -70,7 +70,7 @@ class Puppet::Graph::RelationshipGraph < Puppet::Graph::SimpleGraph
     if @blockers[resource] > 0
       @blockers[resource] -= 1
     else
-      resource.warning "appears to have a negative number of dependencies"
+      resource.warning _("appears to have a negative number of dependencies")
     end
     @blockers[resource] <= 0
   end

data/lib/puppet/graph/simple_graph.rb

@@ -229,17 +229,17 @@ class Puppet::Graph::SimpleGraph
     return if number_of_cycles == 0
 
     message = n_("Found %{num} dependency cycle:\n", "Found %{num} dependency cycles:\n", number_of_cycles) % { num: number_of_cycles }
+
     cycles.each do |cycle|
       paths = paths_in_cycle(cycle)
-      message += paths.map{ |path| '(' + path.join(" => ") + ')'}.join("\n") + "\n"
+      message += paths.map{ |path| '(' + path.join(' => ') + ')'}.join('\n') + '\n'
     end
 
     if Puppet[:graph] then
       filename = write_cycles_to_graph(cycles)
       message += _("Cycle graph written to %{filename}.") % { filename: filename }
     else
-      #TRANSLATORS "graph" refers to a command line option and should not be translated
-      #TRANSLATORS OmniGraffle and GraphViz and program names and should not be translated
+      #TRANSLATORS '--graph' refers to a command line option and OmniGraffle and GraphViz are program names and should not be translated
       message += _("Try the '--graph' option and opening the resulting '.dot' file in OmniGraffle or GraphViz")
     end
     Puppet.err(message)

data/lib/puppet/indirector/catalog/compiler.rb

@@ -49,6 +49,8 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
     node = node_from_request(facts, request)
     node.trusted_data = Puppet.lookup(:trusted_information) { Puppet::Context::TrustedInformation.local(node) }.to_h
 
+    node.environment.use_text_domain if node.environment
+
     if catalog = compile(node, request.options)
       return catalog
     else
@@ -89,7 +91,7 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
     elsif format == 'application/json'
       return Puppet::Node::Facts.convert_from('json', CGI.unescape(facts))
     else
-      raise ArgumentError, "Unsupported facts format"
+      raise ArgumentError, _("Unsupported facts format")
     end
   end
 
@@ -275,24 +277,31 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
       raise Puppet::Error, _("Unable to find a common checksum type between agent '%{agent_type}' and master '%{master_type}'.") % { agent_type: options[:checksum_type], master_type: known_checksum_types } unless checksum_type
     end
 
-    str = if checksum_type
-            if node.environment
-              _("Compiled static catalog for %{node} in environment %{environment}") % { node: node.name, environment: node.environment }
-            else
-              _("Compiled static catalog for %{node}") % { node: node.name }
-            end
-          else
-            if node.environment
-              _("Compiled catalog for %{node} in environment %{environment}") % { node: node.name, environment: node.environment }
-            else
-              _("Compiled catalog for %{node}") % { node: node.name }
-            end
-          end
+    escaped_node_name = node.name.gsub(/%/, '%%')
+    if checksum_type
+      if node.environment
+        escaped_node_environment = node.environment.to_s.gsub(/%/, '%%')
+        benchmark_str = _("Compiled static catalog for %{node} in environment %{environment} in %%{seconds} seconds") % { node: escaped_node_name, environment: escaped_node_environment }
+        profile_str   = _("Compiled static catalog for %{node} in environment %{environment}") % { node: node.name, environment: node.environment }
+      else
+        benchmark_str = _("Compiled static catalog for %{node} in %%{seconds} seconds") % { node: escaped_node_name }
+        profile_str   = _("Compiled static catalog for %{node}") % { node: node.name }
+      end
+    else
+      if node.environment
+        escaped_node_environment = node.environment.to_s.gsub(/%/, '%%')
+        benchmark_str = _("Compiled catalog for %{node} in environment %{environment} in %%{seconds} seconds") % { node: escaped_node_name, environment: escaped_node_environment }
+        profile_str   = _("Compiled catalog for %{node} in environment %{environment}") % { node: node.name, environment: node.environment }
+      else
+        benchmark_str = _("Compiled catalog for %{node} in %%{seconds} seconds") % { node: escaped_node_name }
+        profile_str   = _("Compiled catalog for %{node}") % { node: node.name }
+      end
+    end
     config = nil
 
-    benchmark(:notice, str) do
+    benchmark(:notice, benchmark_str) do
       compile_type = checksum_type ? :static_compile : :compile
-      Puppet::Util::Profiler.profile(str, [:compiler, compile_type, node.environment, node.name]) do
+      Puppet::Util::Profiler.profile(profile_str, [:compiler, compile_type, node.environment, node.name]) do
         begin
           config = Puppet::Parser::Compiler.compile(node, options[:code_id])
         rescue Puppet::Error => detail
@@ -303,15 +312,21 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
         end
 
         if checksum_type && config.is_a?(model)
-          str = if node.environment
-                  #TRANSLATORS Inlined refers to adding additional metadata
-                  _("Inlined resource metadata into static catalog for %{node} in environment %{environment}") % { node: node.name, environment: node.environment }
-                else
-                  #TRANSLATORS Inlined refers to adding additional metadata
-                  _("Inlined resource metadata into static catalog for %{node}") % { node: node.name }
-                end
-          benchmark(:notice, str) do
-            Puppet::Util::Profiler.profile(str, [:compiler, :static_compile_postprocessing, node.environment, node.name]) do
+          escaped_node_name = node.name.gsub(/%/, '%%')
+          if node.environment
+            escaped_node_environment = node.environment.to_s.gsub(/%/, '%%')
+            #TRANSLATORS Inlined refers to adding additional metadata
+            benchmark_str = _("Inlined resource metadata into static catalog for %{node} in environment %{environment} in %%{seconds} seconds") % { node: escaped_node_name, environment: escaped_node_environment }
+            #TRANSLATORS Inlined refers to adding additional metadata
+            profile_str   = _("Inlined resource metadata into static catalog for %{node} in environment %{environment}") % { node: node.name, environment: node.environment }
+          else
+            #TRANSLATORS Inlined refers to adding additional metadata
+            benchmark_str = _("Inlined resource metadata into static catalog for %{node} in %%{seconds} seconds") % { node: escaped_node_name }
+            #TRANSLATORS Inlined refers to adding additional metadata
+            profile_str   = _("Inlined resource metadata into static catalog for %{node}") % { node: node.name }
+          end
+          benchmark(:notice, benchmark_str) do
+            Puppet::Util::Profiler.profile(profile_str, [:compiler, :static_compile_postprocessing, node.environment, node.name]) do
               inline_metadata(config, checksum_type)
             end
           end

data/lib/puppet/indirector/exec.rb

@@ -8,7 +8,7 @@ class Puppet::Indirector::Exec < Puppet::Indirector::Terminus
     external_command = command
 
     # Make sure it's an array
-    raise Puppet::DevError, "Exec commands must be an array" unless external_command.is_a?(Array)
+    raise Puppet::DevError, _("Exec commands must be an array") unless external_command.is_a?(Array)
 
     # Make sure it's fully qualified.
     raise ArgumentError, _("You must set the exec parameter to a fully qualified command") unless Puppet::Util.absolute_path?(external_command[0])

data/lib/puppet/indirector/facts/facter.rb

@@ -11,11 +11,11 @@ class Puppet::Node::Facts::Facter < Puppet::Indirector::Code
   end
 
   def destroy(facts)
-    raise Puppet::DevError, 'You cannot destroy facts in the code store; it is only used for getting facts from Facter'
+    raise Puppet::DevError, _('You cannot destroy facts in the code store; it is only used for getting facts from Facter')
   end
 
   def save(facts)
-    raise Puppet::DevError, 'You cannot save facts to the code store; it is only used for getting facts from Facter'
+    raise Puppet::DevError, _('You cannot save facts to the code store; it is only used for getting facts from Facter')
   end
 
   # Lookup a host's facts up in Facter.
@@ -55,7 +55,7 @@ class Puppet::Node::Facts::Facter < Puppet::Indirector::Code
       # print out each .rb in the facts directory as module
       # developers may find that information useful for debugging purposes
       if Puppet::Util::Log.sendlevel?(:info)
-        Puppet.info "Loading facts"
+        Puppet.info _("Loading facts")
         Dir.glob("#{dir}/*.rb").each do |file|
           Puppet.debug "Loading facts from #{file}"
         end