puppet 5.3.2-x64-mingw32 → 5.3.3-x64-mingw32

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a45a23d49beb5af39295df48eddd802672007923
+  data.tar.gz: d6985616a65ccc878d116917204f328b6d4cc37b
+SHA512:
+  metadata.gz: 37d04c9629bbb691d345db14051d8086d3dd361787309fe5a83bcf03c2453356a8d9645046117704b517316ce8110a6267eca4b4a5c2f3eed723a2ef543e43df
+  data.tar.gz: 30ca3b6c134a4fd8a630c60834f6fa874b71cf5db84294966e609fcec6ea5c6457f92ae7a4c85a76ae0d9ba028c2014287eeadd0fdf99adfab2331aa505d1aa1

data/Gemfile

@@ -53,7 +53,11 @@ group(:development, :test) do
   gem "multi_json", "1.7.7", :require => false, :platforms => [:ruby, :jruby]
   gem "json-schema", "2.1.1", :require => false, :platforms => [:ruby, :jruby]
 
-  gem "rubocop", "~> 0.39.0", :platforms => [:ruby]
+  if RUBY_VERSION >= '2.0'
+    # pin rubocop as 0.50 requires a higher version of the rainbow gem (see below)
+    gem 'rubocop', '~> 0.49.1', :platforms => [:ruby]
+  end
+
   # pin rainbow gem as 2.2.1 requires rubygems 2.6.9+ and (donotwant)
   gem "rainbow", "< 2.2.1", :platforms => [:ruby]
 

data/Rakefile

@@ -69,10 +69,15 @@ end
 
 desc 'run static analysis with rubocop'
 task(:rubocop) do
-  require 'rubocop'
-  cli = RuboCop::CLI.new
-  exit_code = cli.run(%w(--display-cop-names --format simple))
-  raise "RuboCop detected offenses" if exit_code != 0
+  if RUBY_VERSION < '2.0'
+    puts 'rubocop tests require Ruby 2.0 or higher'
+    puts 'skipping rubocop'
+  else
+    require 'rubocop'
+    cli = RuboCop::CLI.new
+    exit_code = cli.run(%w(--display-cop-names --format simple))
+    raise "RuboCop detected offenses" if exit_code != 0
+  end
 end
 
 desc "verify that commit messages match CONTRIBUTING.md requirements"

data/lib/puppet.rb

@@ -42,11 +42,10 @@ module Puppet
   require 'puppet/environments'
 
   class << self
-    gettext_config_file = Puppet::GettextConfig.puppet_locale_path
-    unless Puppet::GettextConfig.initialize(gettext_config_file, Puppet::GettextConfig.translation_mode(gettext_config_file))
-      # Stub out gettext's `_` and `n_()` methods, which attempt to load translations,
-      # with versions that do nothing
-      require 'puppet/gettext/stubs'
+    Puppet::GettextConfig.create_text_domain('production')
+    locale_dir = Puppet::GettextConfig.puppet_locale_path
+    if Puppet::GettextConfig.load_translations('puppet', locale_dir, Puppet::GettextConfig.translation_mode(locale_dir))
+      Puppet::GettextConfig.set_locale(Locale.current.language)
     end
 
     include Puppet::Util

data/lib/puppet/external/nagios/grammar.ry

@@ -52,7 +52,7 @@ require 'strscan'
 class ::Nagios::Parser::SyntaxError < RuntimeError; end
 
 def parse(src)
-  if src.respond_to?("force_encoding") then
+  if (RUBY_VERSION < '2.1.0') && src.respond_to?("force_encoding") then
     src.force_encoding("ASCII-8BIT")
   end
   @ss = StringScanner.new(src)

data/lib/puppet/external/nagios/parser.rb

@@ -14,7 +14,7 @@ require 'strscan'
 class ::Nagios::Parser::SyntaxError < RuntimeError; end
 
 def parse(src)
-  if src.respond_to?("force_encoding") then
+  if (RUBY_VERSION < '2.1.0') && src.respond_to?("force_encoding") then
     src.force_encoding("ASCII-8BIT")
   end
   @ss = StringScanner.new(src)

data/lib/puppet/forge.rb

@@ -65,7 +65,7 @@ class Puppet::Forge < SemanticPuppet::Dependency::Source
 
       if response.code == '200'
         result = JSON.parse(response.body)
-        uri = result['pagination']['next']
+        uri = decode_uri(result['pagination']['next'])
         matches.concat result['results']
       else
         raise ResponseError.new(:uri => URI.parse(@host).merge(uri), :response => response)
@@ -90,7 +90,7 @@ class Puppet::Forge < SemanticPuppet::Dependency::Source
   # @see SemanticPuppet::Dependency::Source#fetch
   def fetch(input)
     name = input.tr('/', '-')
-    uri = "/v3/releases?module=#{name}"
+    uri = "/v3/releases?module=#{name}&sort_by=version"
     if Puppet[:module_groups]
       uri += "&module_groups=#{Puppet[:module_groups].gsub('+', ' ')}"
     end
@@ -107,7 +107,7 @@ class Puppet::Forge < SemanticPuppet::Dependency::Source
       end
 
       releases.concat(process(response['results']))
-      uri = response['pagination']['next']
+      uri = decode_uri(response['pagination']['next'])
     end
 
     return releases
@@ -226,4 +226,10 @@ class Puppet::Forge < SemanticPuppet::Dependency::Source
 
     l.select { |r| r }
   end
+
+  def decode_uri(uri)
+    return if uri.nil?
+
+    URI.decode(uri.gsub('+', ' '))
+  end
 end

data/lib/puppet/forge/repository.rb

@@ -44,8 +44,8 @@ class Puppet::Forge
 
     # Return a Net::HTTPResponse read for this +path+.
     def make_http_request(path, io = nil)
-      Puppet.debug "HTTP GET #{@host}#{path}"
       request = get_request_object(@uri.path.chomp('/')+path)
+      Puppet.debug "HTTP GET #{@host}#{request.path}"
       return read_response(request, io)
     end
 

data/lib/puppet/gettext/config.rb

@@ -10,19 +10,58 @@ module Puppet::GettextConfig
   # Used instead of features because we initialize gettext before features is available.
   # Stubbing gettext if unavailable is handled in puppet.rb.
   begin
-    require 'gettext-setup'
+    require 'fast_gettext'
     require 'locale'
+
+    # Make translation methods (e.g. `_()` and `n_()`) available everywhere.
+    class ::Object
+      include FastGettext::Translation
+    end
+
     @gettext_loaded = true
   rescue LoadError
+    # Stub out gettext's `_` and `n_()` methods, which attempt to load translations,
+    # with versions that do nothing
+    require 'puppet/gettext/stubs'
     @gettext_loaded = false
   end
 
-  # Whether we were able to require gettext-setup and locale
-  # @return [Boolean] true if gettext-setup was successfully loaded
+  # @api private
+  # Whether we were able to require fast_gettext and locale
+  # @return [Boolean] true if translation gems were successfully loaded
   def self.gettext_loaded?
     @gettext_loaded
   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
+    else
+      return false
+    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
+    FastGettext.text_domain = domain_name
+  end
+
+  # @api private
   # Search for puppet gettext config files
   # @return [String] path to the config, or nil if not found
   def self.puppet_locale_path
@@ -37,6 +76,7 @@ module Puppet::GettextConfig
     end
   end
 
+  # @api private
   # Determine which translation file format to use
   # @param conf_path [String] the path to the gettext config file
   # @return [Symbol] :mo if in a package structure, :po otherwise
@@ -48,44 +88,62 @@ module Puppet::GettextConfig
     end
   end
 
+  # @api private
   # Prevent future gettext initializations
   def self.disable_gettext
     @gettext_disabled = true
   end
 
-  # Attempt to initialize the gettext-setup gem
-  # @param path [String] to gettext config file
+  # @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
   # @return true if initialization succeeded, false otherwise
-  def self.initialize(conf_file_dir, file_format)
+  def self.load_translations(project_name, locale_dir, file_format)
     return false if @gettext_disabled || !@gettext_loaded
 
+    return false unless locale_dir && Puppet::FileSystem.exist?(locale_dir)
+
     unless file_format == :po || file_format == :mo
       raise Puppet::Error, "Unsupported translation file format #{file_format}; please use :po or :mo"
     end
 
-    return false if conf_file_dir.nil?
-
-    conf_file = File.join(conf_file_dir, "config.yaml")
-    if Puppet::FileSystem.exist?(conf_file)
-      if GettextSetup.method(:initialize).parameters.count == 1
-        # For use with old gettext-setup gem versions, will load PO files only
-        GettextSetup.initialize(conf_file_dir)
-      else
-        GettextSetup.initialize(conf_file_dir, :file_format => file_format)
-      end
-      # Only change this once.
-      # Because negotiate_locales will only return a non-default locale if
-      # the system locale matches a translation set actually available for the
-      # given gettext project, we don't want this to get set back to default if
-      # we load a module that doesn't have translations, but Puppet does have
-      # translations for the user's locale.
-      if FastGettext.locale == GettextSetup.default_locale
-        FastGettext.locale = GettextSetup.negotiate_locale(Locale.current.language)
-      end
-      true
-    else
-      false
+    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)
+    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]
+
+    repository = FastGettext::TranslationRepository.build(project_name,
+                                                          path: locale_dir,
+                                                          type: file_format,
+                                                          ignore_fuzzy: false)
+    @loaded_repositories[project_name] = true
+    current_chain << repository
+  end
+
+  # @api private
+  # Sets the language in which to display strings.
+  # @param locale [String] the language portion of a locale string (e.g. "ja")
+  def self.set_locale(locale)
+    return if !gettext_loaded?
+    # make sure we're not using the `available_locales` machinery
+    FastGettext.default_available_locales = nil
+
+    FastGettext.default_locale = locale
   end
 end

data/lib/puppet/graph/relationship_graph.rb

@@ -247,6 +247,12 @@ class Puppet::Graph::RelationshipGraph < Puppet::Graph::SimpleGraph
     containers.each { |x|
       admissible[x] = whit_class.new(:name => "admissible_#{x.ref}", :catalog => catalog)
       completed[x]  = whit_class.new(:name => "completed_#{x.ref}",  :catalog => catalog)
+
+      # This copies the original container's tags over to the two anchor whits.
+      # Without this, tags are not propagated to the container's resources.
+      admissible[x].set_tags(x)
+      completed[x].set_tags(x)
+
       priority = @prioritizer.priority_of(x)
       add_vertex(admissible[x], priority)
       add_vertex(completed[x], priority)

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

@@ -129,10 +129,13 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
   def inlineable?(resource, sources)
     case
       when resource[:ensure] == 'absent'
+        #TRANSLATORS Inlining refers to adding additional metadata (in this case we are not inlining)
         return Puppet::Util::Profiler.profile(_("Not inlining absent resource"), [:compiler, :static_compile_inlining, :skipped_file_metadata, :absent]) { false }
       when sources.empty?
+        #TRANSLATORS Inlining refers to adding additional metadata (in this case we are not inlining)
         return Puppet::Util::Profiler.profile(_("Not inlining resource without sources"), [:compiler, :static_compile_inlining, :skipped_file_metadata, :no_sources]) { false }
       when (not (sources.all? {|source| source =~ /^puppet:/}))
+        #TRANSLATORS Inlining refers to adding additional metadata (in this case we are not inlining)
         return Puppet::Util::Profiler.profile(_("Not inlining unsupported source scheme"), [:compiler, :static_compile_inlining, :skipped_file_metadata, :unsupported_scheme]) { false }
       else
         return true
@@ -154,11 +157,13 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
   # Helper method to log file resources that could not be inlined because they
   # fall outside of an environment.
   def log_file_outside_environment
+    #TRANSLATORS Inlining refers to adding additional metadata (in this case we are not inlining)
     Puppet::Util::Profiler.profile(_("Not inlining file outside environment"), [:compiler, :static_compile_inlining, :skipped_file_metadata, :file_outside_environment]) { true }
   end
 
   # Helper method to log file resources that were successfully inlined.
   def log_metadata_inlining
+    #TRANSLATORS Inlining refers to adding additional metadata
     Puppet::Util::Profiler.profile(_("Inlining file metadata"), [:compiler, :static_compile_inlining, :inlined_file_metadata]) { true }
   end
 
@@ -270,9 +275,19 @@ 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 = _("Compiled %s for ") % (checksum_type ? _('static catalog') : _('catalog'))
-    str += node.name
-    str += _(" in environment %{env}") % { env: node.environment } if node.environment
+    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
     config = nil
 
     benchmark(:notice, str) do
@@ -288,8 +303,13 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
         end
 
         if checksum_type && config.is_a?(model)
-          str = _("Inlined resource metadata into static catalog for %{node}") % { node: node.name }
-          str += _(" in environment %{env}") % { env: node.environment } if node.environment
+          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
               inline_metadata(config, checksum_type)

data/lib/puppet/indirector/file_bucket_file/file.rb

@@ -219,7 +219,7 @@ module Puppet::FileBucketFile
     #   and content as that in the bucket_file
     # @api private
     def verify_identical_file(contents_file, bucket_file)
-      (bucket_file.size == Puppet::FileSystem.size(contents_file)) &&
+      (bucket_file.to_binary.bytesize == Puppet::FileSystem.size(contents_file)) &&
         (bucket_file.stream() {|s| Puppet::FileSystem.compare_stream(contents_file, s) })
     end
 

data/lib/puppet/module.rb

@@ -423,33 +423,24 @@ class Puppet::Module
   end
 
   def initialize_i18n
-    module_name = @forge_name.gsub("/","-") if @forge_name
-    return if module_name.nil? || i18n_initialized?(module_name)
+    # this name takes the form "namespace-module", and should match the name of
+    # the PO file containing the translations.
+    module_name = @forge_name ? @forge_name.gsub("/", "-") : name
+    return if Puppet::GettextConfig.translations_loaded?(module_name)
 
     locales_path = File.absolute_path('locales', path)
 
-    if Puppet::GettextConfig.initialize(locales_path, :po)
-      Puppet.debug "#{module_name} initialized for i18n: #{GettextSetup.translation_repositories[module_name]}"
-    else if Puppet::GettextConfig.gettext_loaded?
-        config_path = File.absolute_path('config.yaml', locales_path)
-        Puppet.debug "Could not find locales configuration file for #{module_name} at #{config_path}. Skipping i18n initialization."
+    if Puppet::GettextConfig.load_translations(module_name, locales_path, :po)
+      Puppet.debug "i18n initialized for #{module_name}"
+    elsif Puppet::GettextConfig.gettext_loaded?
+      Puppet.debug "Could not find translation files for #{module_name} at #{locales_path}. Skipping i18n initialization."
     else
-        Puppet.debug "No gettext library found, skipping i18n initialization."
-      end
+      Puppet.debug "No gettext library found, skipping i18n initialization."
     end
   end
 
   private
 
-  def i18n_initialized?(module_name)
-    if Puppet::GettextConfig.gettext_loaded?
-      GettextSetup.translation_repositories.has_key? module_name
-    else
-      # GettextSetup not yet initialized or not found
-      false
-    end
-  end
-
   def wanted_manifests_from(pattern)
     begin
       extended = File.extname(pattern).empty? ? "#{pattern}.pp" : pattern

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

@@ -2,8 +2,15 @@ require 'base64'
 module Puppet::Pops
 module Types
 
-# A Puppet Language Type that exposes the {{SemanticPuppet::Version}} and {{SemanticPuppet::VersionRange}}.
-# The version type is parameterized with version ranges.
+# A Puppet Language Type that represents binary data content (a sequence of 8-bit bytes).
+# Instances of this data type can be created from `String` and `Array[Integer[0,255]]`
+# values. Also see the `binary_file` function for reading binary content from a file.
+#
+# A `Binary` can be converted to `String` and `Array` form - see function `new` for
+# the respective target data type for more information.
+#
+# Instances of this data type serialize as base 64 encoded strings when the serialization
+# format is textual, and as binary content when a serialization format supports this.
 #
 # @api public
 class PBinaryType < PAnyType

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

@@ -228,10 +228,10 @@ class PObjectType < PMetaType
       # TODO: Assumes Ruby implementation for now
       if(callable_type.is_a?(PVariantType))
         callable_type.types.map do |ct|
-          Functions::Dispatch.new(ct, name, [], false, ct.block_type.nil? ? nil : 'block')
+          Functions::Dispatch.new(ct, RubyGenerator.protect_reserved_name(name), [], false, ct.block_type.nil? ? nil : 'block')
         end
       else
-        [Functions::Dispatch.new(callable_type, name, [], false, callable_type.block_type.nil? ? nil : 'block')]
+        [Functions::Dispatch.new(callable_type, RubyGenerator.protect_reserved_name(name), [], false, callable_type.block_type.nil? ? nil : 'block')]
       end
     end
 
@@ -544,7 +544,13 @@ class PObjectType < PMetaType
     init_non_opt_count = 0
     init_param_names = init.parameters.map do |p|
       init_non_opt_count += 1 if :req == p[0]
-      p[1].to_s
+      n = p[1].to_s
+      r = RubyGenerator.unprotect_reserved_name(n)
+      unless r.equal?(n)
+        # assert that the protected name wasn't a real name (names can start with underscore)
+        n = r unless param_names.index(r).nil?
+      end
+      n
     end
 
     if init_param_names != param_names