puppet 4.10.12-x86-mingw32 → 5.0.0-x86-mingw32

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/tar.rb

@@ -11,7 +11,8 @@ module Puppet::ModuleTool::Tar
     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/tar/mini.rb

@@ -3,77 +3,24 @@ class Puppet::ModuleTool::Tar::Mini
     Zlib::GzipReader.open(sourcefile) do |reader|
       Archive::Tar::Minitar.unpack(reader, destdir, find_valid_files(reader)) do |action, name, stats|
         case action
-        when :dir
+        when :file_done
+          File.chmod(0644, "#{destdir}/#{name}")
+        when :dir, :file_start
           validate_entry(destdir, name)
-          set_dir_mode!(stats)
-          Puppet.debug("Extracting: #{destdir}/#{name}")
-        when :file_start
-          # Octal string of the old file mode.
-          validate_entry(destdir, name)
-          set_file_mode!(stats)
           Puppet.debug("Extracting: #{destdir}/#{name}")
         end
-        set_default_user_and_group!(stats)
-        stats
       end
     end
   end
 
   def pack(sourcedir, destfile)
     Zlib::GzipWriter.open(destfile) do |writer|
-      Archive::Tar::Minitar.pack(sourcedir, writer) do |step, name, stats|
-        # TODO smcclellan 2017-10-31 Set permissions here when this yield block
-        # executes before the header is written. As it stands, the `stats`
-        # argument isn't mutable in a way that will effect the desired mode for
-        # the file.
-      end
+      Archive::Tar::Minitar.pack(sourcedir, writer)
     end
   end
 
   private
 
-  EXECUTABLE = 0755
-  NOT_EXECUTABLE = 0644
-  USER_EXECUTE = 0100
-
-  def set_dir_mode!(stats)
-    if stats.key?(:mode)
-      # This is only the case for `pack`, so this code will not run.
-      stats[:mode] = EXECUTABLE
-    elsif stats.key?(:entry)
-      old_mode = stats[:entry].instance_variable_get(:@mode)
-      if old_mode.is_a?(Fixnum)
-        stats[:entry].instance_variable_set(:@mode, EXECUTABLE)
-      end
-    end
-  end
-
-  # Sets a file mode to 0755 if the file is executable by the user.
-  # Sets a file mode to 0644 if the file mode is set (non-Windows).
-  def sanitized_mode(old_mode)
-    old_mode & USER_EXECUTE != 0 ? EXECUTABLE : NOT_EXECUTABLE
-  end
-
-  def set_file_mode!(stats)
-    if stats.key?(:mode)
-      # This is only the case for `pack`, so this code will not run.
-      stats[:mode] = sanitized_mode(stats[:mode])
-    elsif stats.key?(:entry)
-      old_mode = stats[:entry].instance_variable_get(:@mode)
-      # If the user can execute the file, set 0755, otherwise 0644.
-      if old_mode.is_a?(Fixnum)
-        new_mode = sanitized_mode(old_mode)
-        stats[:entry].instance_variable_set(:@mode, new_mode)
-      end
-    end
-  end
-
-  # Sets UID and GID to 0 for standardization.
-  def set_default_user_and_group!(stats)
-    stats[:uid] = 0
-    stats[:gid] = 0
-  end
-
   # Find all the valid files in tarfile.
   #
   # This check was mainly added to ignore 'x' and 'g' flags from the PAX

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)

data/lib/puppet/network/formats.rb

@@ -1,4 +1,5 @@
 require 'puppet/network/format_handler'
+require 'json'
 
 Puppet::Network::FormatHandler.create_serialized_formats(:msgpack, :weight => 20, :mime => "application/x-msgpack", :required_methods => [:render_method, :intern_method], :intern_method => :from_data_hash) do
 
@@ -30,7 +31,7 @@ Puppet::Network::FormatHandler.create_serialized_formats(:yaml) do
   def intern_multiple(klass, text)
     data = YAML.load(text)
     unless data.respond_to?(:collect)
-      raise Puppet::Network::FormatHandler::FormatError, "Serialized YAML did not contain a collection of instances when calling intern_multiple"
+      raise Puppet::Network::FormatHandler::FormatError, _("Serialized YAML did not contain a collection of instances when calling intern_multiple")
     end
 
     data.collect do |datum|
@@ -42,7 +43,7 @@ Puppet::Network::FormatHandler.create_serialized_formats(:yaml) do
     return data if data.is_a?(klass)
 
     unless data.is_a? Hash
-      raise Puppet::Network::FormatHandler::FormatError, "Serialized YAML did not contain a valid instance of #{klass}"
+      raise Puppet::Network::FormatHandler::FormatError, _("Serialized YAML did not contain a valid instance of %{klass}") % { klass: klass }
     end
 
     klass.from_data_hash(data)
@@ -62,28 +63,15 @@ Puppet::Network::FormatHandler.create_serialized_formats(:yaml) do
   end
 end
 
-Puppet::Network::FormatHandler.create(:s, :mime => "text/plain", :extension => "txt")
+Puppet::Network::FormatHandler.create(:s, :mime => "text/plain", :charset => Encoding::UTF_8, :extension => "txt")
 
-Puppet::Network::FormatHandler.create(:binary, :mime => "application/octet-stream", :weight => 1) do
-  def intern_multiple(klass, text)
-    raise NotImplementedError
-  end
-
-  def render_multiple(instances)
-    raise NotImplementedError
-  end
-
-  # LAK:NOTE The format system isn't currently flexible enough to handle
-  # what I need to support raw formats just for individual instances (rather
-  # than both individual and collections), but we don't yet have enough data
-  # to make a "correct" design.
-  #   So, we hack it so it works for singular but fail if someone tries it
-  # on plurals.
-  def supported?(klass)
-    true
-  end
+# By default, to_binary is called to render and from_binary called to intern. Note unlike
+# text-based formats (json, yaml, etc), we don't use to_data_hash for binary.
+Puppet::Network::FormatHandler.create(:binary, :mime => "application/octet-stream", :weight => 1,
+                                      :required_methods => [:render_method, :intern_method]) do
 end
 
+# PSON is deprecated
 Puppet::Network::FormatHandler.create_serialized_formats(:pson, :weight => 10, :required_methods => [:render_method, :intern_method], :intern_method => :from_data_hash) do
   def intern(klass, text)
     data_to_instance(klass, PSON.parse(text))
@@ -111,6 +99,31 @@ Puppet::Network::FormatHandler.create_serialized_formats(:pson, :weight => 10, :
   end
 end
 
+Puppet::Network::FormatHandler.create_serialized_formats(:json, :mime => 'application/json', :charset => Encoding::UTF_8, :weight => 15, :required_methods => [:render_method, :intern_method], :intern_method => :from_data_hash) do
+  def intern(klass, text)
+    data_to_instance(klass, JSON.parse(text))
+  end
+
+  def intern_multiple(klass, text)
+    JSON.parse(text).collect do |data|
+      data_to_instance(klass, data)
+    end
+  end
+
+  # JSON monkey-patches Array, so this works.
+  # https://github.com/ruby/ruby/blob/ruby_1_9_3/ext/json/generator/generator.c#L1416
+  def render_multiple(instances)
+    instances.to_json
+  end
+
+  # Unlike PSON, we do not need to unwrap the data envelope, because legacy 3.x agents
+  # have never supported JSON
+  def data_to_instance(klass, data)
+    return data if data.is_a?(klass)
+    klass.from_data_hash(data)
+  end
+end
+
 # This is really only ever going to be used for Catalogs.
 Puppet::Network::FormatHandler.create_serialized_formats(:dot, :required_methods => [:render_method])
 
@@ -119,16 +132,14 @@ Puppet::Network::FormatHandler.create(:console,
                                       :mime   => 'text/x-console-text',
                                       :weight => 0) do
   def json
-    @json ||= Puppet::Network::FormatHandler.format(:pson)
+    @json ||= Puppet::Network::FormatHandler.format(:json)
   end
 
   def render(datum)
-    # String to String
-    return datum if datum.is_a? String
-    return datum if datum.is_a? Numeric
+    return datum if datum.is_a?(String) || datum.is_a?(Numeric)
 
     # Simple hash to table
-    if datum.is_a? Hash and datum.keys.all? { |x| x.is_a? String or x.is_a? Numeric }
+    if datum.is_a?(Hash) && datum.keys.all? { |x| x.is_a?(String) || x.is_a?(Numeric) }
       output = ''
       column_a = datum.empty? ? 2 : datum.map{ |k,v| k.to_s.length }.max + 2
       datum.sort_by { |k,v| k.to_s } .each do |key, value|
@@ -151,7 +162,7 @@ Puppet::Network::FormatHandler.create(:console,
     end
 
     # ...or pretty-print the inspect outcome.
-    return PSON.pretty_generate(datum)
+    JSON.pretty_generate(datum, :quirks_mode => true)
   end
 
   def render_multiple(data)