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

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

@@ -8,14 +8,14 @@ module Puppet::ModuleTool::Errors
       @conditions        = options[:conditions]
       @action            = options[:action]
 
-      super "Could not #{@action} '#{@requested_name}' (#{vstring}); no version satisfies all dependencies"
+      super _("Could not %{action} '%{module_name}' (%{version}); no version satisfies all dependencies") % { action: @action, module_name: @requested_name, version: vstring }
     end
 
     def multiline
       message = []
-      message << "Could not #{@action} module '#{@requested_name}' (#{vstring})"
-      message << "  No version of '#{@requested_name}' can satisfy all dependencies"
-      message << "    Use `puppet module #{@action} --ignore-dependencies` to #{@action} only this module"
+      message << _("Could not %{action} module '%{module_name}' (%{version})") % { action: @action, module_name: @requested_name, version: vstring }
+      message << _("  No version of '%{module_name}' can satisfy all dependencies") % { module_name: @requested_name }
+      message << _("    Use `puppet module %{action} --ignore-dependencies` to %{action} only this module") % { action: @action }
 
       message.join("\n")
     end
@@ -30,21 +30,21 @@ module Puppet::ModuleTool::Errors
       @action            = options[:action]
 
       if @requested_version == :latest
-        super "Could not #{@action} '#{@module_name}'; no releases are available from #{@source}"
+        super _("Could not %{action} '%{module_name}'; no releases are available from %{source}") % { action: @action, module_name: @module_name, source: @source }
       else
-        super "Could not #{@action} '#{@module_name}'; no releases matching '#{@requested_version}' are available from #{@source}"
+        super _("Could not %{action} '%{module_name}'; no releases matching '%{version}' are available from %{source}") % { action: @action, module_name: @module_name, version: @requested_version, source: @source }
       end
     end
 
     def multiline
       message = []
-      message << "Could not #{@action} '#{@module_name}' (#{vstring})"
+      message << _("Could not %{action} '%{module_name}' (%{version})") % { action: @action, module_name: @module_name, version: vstring }
 
       if @requested_version == :latest
-        message << "  No releases are available from #{@source}"
-        message << "    Does '#{@module_name}' have at least one published release?"
+        message << _("  No releases are available from %{source}") % { source: @source }
+        message << _("    Does '%{module_name}' have at least one published release?") % { module_name: @module_name }
       else
-        message << "  No releases matching '#{@requested_version}' are available from #{@source}"
+        message << _("  No releases matching '%{version}' are available from %{source}") % { version: @requested_version, source: @source }
       end
 
       message.join("\n")
@@ -58,27 +58,27 @@ module Puppet::ModuleTool::Errors
       @dependency        = options[:dependency]
       @directory         = options[:directory]
       @metadata          = options[:metadata]
-      super "'#{@requested_module}' (#{@requested_version}) requested; installation conflict"
+      super _("'%{module_name}' (%{version}) requested; installation conflict") % { module_name: @requested_module, version: @requested_version }
     end
 
     def multiline
       message = []
-      message << "Could not install module '#{@requested_module}' (#{@requested_version})"
+      message << _("Could not install module '%{module_name}' (%{version})") % { module_name: @requested_module, version: @requested_version }
 
       if @dependency
-        message << "  Dependency '#{@dependency[:name]}' (#{v(@dependency[:version])}) would overwrite #{@directory}"
+        message << _("  Dependency '%{name}' (%{version}) would overwrite %{dir}") % { name: @dependency[:name], version: v(@dependency[:version]), dir: @directory }
       else
-        message << "  Installation would overwrite #{@directory}"
+        message << _("  Installation would overwrite %{dir}") % { dir: @directory }
       end
 
       if @metadata
-        message << "    Currently, '#{@metadata["name"]}' (#{v(@metadata["version"])}) is installed to that directory"
+        message << _("    Currently, '%{name}' (%{version}) is installed to that directory") % { name: @metadata["name"], version: v(@metadata["version"]) }
       end
 
       if @dependency
-        message << "    Use `puppet module install --ignore-dependencies` to install only this module"
+        message << _("    Use `puppet module install --ignore-dependencies` to install only this module")
       else
-        message << "    Use `puppet module install --force` to install this module anyway"
+        message << _("    Use `puppet module install --force` to install this module anyway")
       end
 
       message.join("\n")
@@ -93,19 +93,20 @@ module Puppet::ModuleTool::Errors
       @conditions        = options[:conditions]
       @source            = options[:source][1..-1]
 
-      super "'#{@requested_module}' (#{v(@requested_version)}) requested; Invalid dependency cycle"
+      super _("'%{module_name}' (%{version}) requested; Invalid dependency cycle") % { module_name: @requested_module, version: v(@requested_version) }
     end
 
     def multiline
       trace = []
-      trace << "You specified '#{@source.first[:name]}' (#{v(@requested_version)})"
-      trace += @source[1..-1].map { |m| "which depends on '#{m[:name]}' (#{v(m[:version])})" }
+      trace << _("You specified '%{name}' (%{version})") % { name: @source.first[:name], version: v(@requested_version) }
+      #TRANSLATORS Second half of "You specified a module..."
+      trace += @source[1..-1].map { |m| _("which depends on '%{name}' (%{version})") % { name: m[:name], version: v(m[:version]) } }
 
       message = []
-      message << "Could not install module '#{@requested_module}' (#{v(@requested_version)})"
-      message << "  No version of '#{@module_name}' will satisfy dependencies"
-      message << trace.map { |s| "    #{s}" }.join(",\n")
-      message << "    Use `puppet module install --force` to install this module anyway"
+      message << _("Could not install module '%{module_name}' (%{version})") % { module_name: @requested_module, version: v(@requested_version) }
+      message << _("  No version of '%{module_name}' will satisfy dependencies") % { module_name: @module_name }
+      message << trace.map { |s| "    #{s}".join(",\n") }
+      message << _("    Use `puppet module install --force` to install this module anyway")
 
       message.join("\n")
     end
@@ -116,17 +117,17 @@ module Puppet::ModuleTool::Errors
       @module_name = options[:module_name]
       @suggestions = options[:suggestions] || []
       @action      = options[:action]
-      super "Could not #{@action} '#{@module_name}'; module is not installed"
+      super _("Could not %{action} '%{module_name}'; module is not installed") % { action: @action, module_name: @module_name }
     end
 
     def multiline
       message = []
-      message << "Could not #{@action} module '#{@module_name}'"
-      message << "  Module '#{@module_name}' is not installed"
+      message << _("Could not %{action} module '%{module_name}'") % { action: @action, module_name: @module_name }
+      message << _("  Module '%{module_name}' is not installed") % { module_name: @module_name }
       message += @suggestions.map do |suggestion|
-        "    You may have meant `puppet module #{@action} #{suggestion}`"
+        _("    You may have meant `puppet module %{action} %{suggestion}`") % { action: @action, suggestion: suggestion }
       end
-      message << "    Use `puppet module install` to install this module" if @action == :upgrade
+      message << _("    Use `puppet module install` to install this module") if @action == :upgrade
       message.join("\n")
     end
   end
@@ -136,17 +137,18 @@ module Puppet::ModuleTool::Errors
       @module_name = options[:module_name]
       @modules     = options[:installed_modules]
       @action      = options[:action]
-      super "Could not #{@action} '#{@module_name}'; module appears in multiple places in the module path"
+      #TRANSLATORS "module path" refers to a set of directories where modules may be installed
+      super _("Could not %{action} '%{module_name}'; module appears in multiple places in the module path") % { action: @action, module_name: @module_name }
     end
 
     def multiline
       message = []
-      message << "Could not #{@action} module '#{@module_name}'"
-      message << "  Module '#{@module_name}' appears multiple places in the module path"
+      message << _("Could not %{action} module '%{module_name}'") % { action: @action, module_name: @module_name }
+      message << _("  Module '%{module_name}' appears multiple places in the module path") % { module_name: @module_name }
       message += @modules.map do |mod|
-        "    '#{@module_name}' (#{v(mod.version)}) was found in #{mod.modulepath}"
+        _("    '%{module_name}' (%{version}) was found in %{path}") % { module_name: @module_name, version: v(mod.version), path: mod.modulepath }
       end
-      message << "    Use the `--modulepath` option to limit the search to specific directories"
+      message << _("    Use the `--modulepath` option to limit the search to specific directories")
       message.join("\n")
     end
   end
@@ -157,14 +159,14 @@ module Puppet::ModuleTool::Errors
       @requested_version = options[:requested_version]
       @installed_version = options[:installed_version]
       @action            = options[:action]
-      super "Could not #{@action} '#{@module_name}'; module has had changes made locally"
+      super _("Could not %{action} '%{module_name}'; module has had changes made locally") % { action: @action, module_name: @module_name }
     end
 
     def multiline
       message = []
-      message << "Could not #{@action} module '#{@module_name}' (#{vstring})"
-      message << "  Installed module has had changes made locally"
-      message << "    Use `puppet module #{@action} --ignore-changes` to #{@action} this module anyway"
+      message << _("Could not %{action} module '%{module_name}' (%{version})") % { action: @action, module_name: @module_name, version: vstring }
+      message << _("  Installed module has had changes made locally")
+      message << _("    Use `puppet module %{action} --ignore-changes` to %{action} this module anyway") % { action: @action }
       message.join("\n")
     end
   end
@@ -174,14 +176,14 @@ module Puppet::ModuleTool::Errors
       @name   = name
       @action = options[:action]
       @error  = options[:error]
-      super "Could not #{@action} '#{@name}'; #{@error.message}"
+      super _("Could not %{action} '%{module_name}'; %{error}") % { action: @action, module_name: @name, error: @error.message }
     end
 
     def multiline
       message = []
-      message << "Could not #{@action} module '#{@name}'"
-      message << "  Failure trying to parse metadata"
-      message << "    Original message was: #{@error.message}"
+      message << _("Could not %{action} module '%{module_name}'") % { action: @action, module_name: @name }
+      message << _("  Failure trying to parse metadata")
+      message << _("    Original message was: %{message}") % { message: @error.message }
       message.join("\n")
     end
   end

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

@@ -7,15 +7,15 @@ module Puppet::ModuleTool::Errors
       @module_name = options[:module_name]
       @modules     = options[:installed_modules]
       @version     = options[:version_range]
-      super "Could not uninstall '#{@module_name}'; no installed version matches"
+      super _("Could not uninstall '%{module_name}'; no installed version matches") % { module_name: @module_name }
     end
 
     def multiline
       message = []
-      message << "Could not uninstall module '#{@module_name}' (#{v(@version)})"
-      message << "  No installed version of '#{@module_name}' matches (#{v(@version)})"
+      message << _("Could not uninstall module '%{module_name}' (%{version})") % { module_name: @module_name, version: v(@version) }
+      message << _("  No installed version of '%{module_name}' matches (%{version})") % { module_name: @module_name, version: v(@version) }
       message += @modules.map do |mod|
-        "    '#{mod[:name]}' (#{v(mod[:version])}) is installed in #{mod[:path]}"
+        _("    '%{module_name}' (%{version}) is installed in %{path}") % { module_name: mod[:name], version: v(mod[:version]), path: mod[:path] }
       end
       message.join("\n")
     end
@@ -28,17 +28,21 @@ module Puppet::ModuleTool::Errors
       @requested_version = options[:requested_version]
       @installed_version = options[:installed_version]
 
-      super "Could not uninstall '#{@module_name}'; installed modules still depend upon it"
+      super _("Could not uninstall '%{module_name}'; installed modules still depend upon it") % { module_name: @module_name }
     end
 
     def multiline
       message = []
-      message << ("Could not uninstall module '#{@module_name}'" << (@requested_version ? " (#{v(@requested_version)})" : ''))
-      message << "  Other installed modules have dependencies on '#{@module_name}' (#{v(@installed_version)})"
+      if @requested_version
+        message << _("Could not uninstall module '%{module_name}' (v%{requested_version})") % { module_name: @module_name, requested_version: @requested_version }
+      else
+        message << _("Could not uninstall module '%{module_name}'") % { module_name: @module_name }
+      end
+      message << _("  Other installed modules have dependencies on '%{module_name}' (%{version})") % { module_name: @module_name, version: v(@installed_version) }
       message += @required_by.map do |mod|
-        "    '#{mod['name']}' (#{v(mod['version'])}) requires '#{@module_name}' (#{v(mod['version_requirement'])})"
+        _("    '%{module_name}' (%{version}) requires '%{module_dep}' (%{dep_version})") % { module_name: mod['name'], version: v(mod['version']), module_dep: @module_name, dep_version: v(mod['version_requirement']) }
       end
-      message << "    Use `puppet module uninstall --force` to uninstall this module anyway"
+      message << _("    Use `puppet module uninstall --force` to uninstall this module anyway")
       message.join("\n")
     end
   end

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

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

data/lib/puppet/module_tool/install_directory.rb

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

data/lib/puppet/module_tool/installed_modules.rb

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

data/lib/puppet/module_tool/local_tarball.rb

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

data/lib/puppet/module_tool/metadata.rb

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

data/lib/puppet/module_tool/shared_behaviors.rb

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