puppet 4.10.0 → 5.0.0

data/lib/puppet/util.rb

@@ -62,7 +62,7 @@ module Util
       when :windows
         Puppet::Util::Windows::Process.get_environment_strings
       else
-        raise "Unable to retrieve the environment for mode #{mode}"
+        raise _("Unable to retrieve the environment for mode %{mode}") % { mode: mode }
     end
   end
   module_function :get_environment
@@ -79,7 +79,7 @@ module Util
           Puppet::Util::Windows::Process.set_environment_variable(key, nil)
         end
       else
-        raise "Unable to clear the environment for mode #{mode}"
+        raise _("Unable to clear the environment for mode %{mode}") % { mode: mode }
     end
   end
   module_function :clear_environment
@@ -95,7 +95,7 @@ module Util
       when :windows
         Puppet::Util::Windows::Process.set_environment_variable(name,value)
       else
-        raise "Unable to set the environment variable #{name} for mode #{mode}"
+        raise _("Unable to set the environment variable %{name} for mode %{mode}") % { name: name, mode: mode }
     end
   end
   module_function :set_env
@@ -112,7 +112,7 @@ module Util
           Puppet::Util::Windows::Process.set_environment_variable(name.to_s, val)
         end
       else
-        raise "Unable to merge given values into the current environment for mode #{mode}"
+        raise _("Unable to merge given values into the current environment for mode %{mode}") % { mode: mode }
     end
   end
   module_function :merge_environment
@@ -153,8 +153,8 @@ module Util
       begin
         Puppet::Util::SUIDManager.change_group(group, true)
       rescue => detail
-        Puppet.warning "could not change to group #{group.inspect}: #{detail}"
-        $stderr.puts "could not change to group #{group.inspect}"
+        Puppet.warning _("could not change to group %{group}: %{detail}") % { group: group.inspect, detail: detail }
+        $stderr.puts _("could not change to group %{group}") % { group: group.inspect }
 
         # Don't exit on failed group changes, since it's
         # not fatal
@@ -166,7 +166,7 @@ module Util
       begin
         Puppet::Util::SUIDManager.change_user(user, true)
       rescue => detail
-        $stderr.puts "Could not change to user #{user}: #{detail}"
+        $stderr.puts _("Could not change to user %{user}: %{detail}") % { user: user, detail: detail }
         exit(74)
       end
     end
@@ -223,7 +223,9 @@ module Util
       seconds = Benchmark.realtime {
         yield
       }
-      object.send(level, msg + (" in %0.2f seconds" % seconds))
+      #TRANSLATORS forms the end of a string indicating how long a
+      # given operation took
+      object.send(level, msg + (_(" in %0.2f seconds") % seconds))
       return seconds
     else
       yield
@@ -254,10 +256,12 @@ module Util
           if e.to_s =~ /HOME/ and (Puppet::Util.get_env('HOME').nil? || Puppet::Util.get_env('HOME') == "")
             # if we get here they have a tilde in their PATH.  We'll issue a single warning about this and then
             # ignore this path element and carry on with our lives.
-            Puppet::Util::Warnings.warnonce("PATH contains a ~ character, and HOME is not set; ignoring PATH element '#{dir}'.")
+            #TRANSLATORS PATH and HOME are environment variables and should not be translated
+            Puppet::Util::Warnings.warnonce(_("PATH contains a ~ character, and HOME is not set; ignoring PATH element '%{dir}'.") % { dir: dir })
           elsif e.to_s =~ /doesn't exist|can't find user/
             # ...otherwise, we just skip the non-existent entry, and do nothing.
-            Puppet::Util::Warnings.warnonce("Couldn't expand PATH containing a ~ character; ignoring PATH element '#{dir}'.")
+            #TRANSLATORS PATH is an environment variable and should not be translated
+            Puppet::Util::Warnings.warnonce(_("Couldn't expand PATH containing a ~ character; ignoring PATH element '%{dir}'.") % { dir: dir })
           else
             raise
           end
@@ -321,12 +325,17 @@ module Util
       end
     end
 
-    params[:path] = URI.escape(path)
+    # have to split *after* any relevant escaping
+    params[:path], params[:query] = uri_encode(path).split('?')
+    search_for_fragment = params[:query] ? :query : :path
+    if params[search_for_fragment].include?('#')
+      params[search_for_fragment], _, params[:fragment] = params[search_for_fragment].rpartition('#')
+    end
 
     begin
       URI::Generic.build(params)
     rescue => detail
-      raise Puppet::Error, "Failed to convert '#{path}' to URI: #{detail}", detail.backtrace
+      raise Puppet::Error, _("Failed to convert '%{path}' to URI: %{detail}") % { path: path, detail: detail }, detail.backtrace
     end
   end
   module_function :path_to_uri
@@ -335,7 +344,9 @@ module Util
   def uri_to_path(uri)
     return unless uri.is_a?(URI)
 
-    path = URI.unescape(uri.path)
+    # CGI.unescape doesn't handle space rules properly in uri paths
+    # URI.unescape does, but returns strings in their original encoding
+    path = URI.unescape(uri.path.encode(Encoding::UTF_8))
 
     if Puppet.features.microsoft_windows? and uri.scheme == 'file'
       if uri.host
@@ -349,6 +360,119 @@ module Util
   end
   module_function :uri_to_path
 
+  private
+
+  RFC_3986_URI_REGEX = /^(?<scheme>([^:\/?#]+):)?(?<authority>\/\/([^\/?#]*))?(?<path>[^?#]*)(\?(?<query>[^#]*))?(#(?<fragment>.*))?$/
+
+  public
+
+  # Percent-encodes a URI query parameter per RFC3986 - https://tools.ietf.org/html/rfc3986
+  #
+  # The output will correctly round-trip through URI.unescape
+  #
+  # @param [String query_string] A URI query parameter that may contain reserved
+  #   characters that must be percent encoded for the key or value to be
+  #   properly decoded as part of a larger query string:
+  #
+  #   query
+  #   encodes as : query
+  #
+  #   query_with_special=chars like&and * and# plus+this
+  #   encodes as:
+  #   query_with_special%3Dchars%20like%26and%20%2A%20and%23%20plus%2Bthis
+  #
+  #   Note: Also usable by fragments, but not suitable for paths
+  #
+  # @return [String] a new string containing an encoded query string per the
+  #   rules of RFC3986.
+  #
+  #   In particular,
+  #   query will encode + as %2B and space as %20
+  def uri_query_encode(query_string)
+    return nil if query_string.nil?
+
+    # query can encode space to %20 OR +
+    # + MUST be encoded as %2B
+    # in RFC3968 both query and fragment are defined as:
+    # = *( pchar / "/" / "?" )
+    # CGI.escape turns space into + which is the most backward compatible
+    # however it doesn't roundtrip through URI.unescape which prefers %20
+    CGI.escape(query_string).gsub('+', '%20')
+  end
+  module_function :uri_query_encode
+
+  # Percent-encodes a URI string per RFC3986 - https://tools.ietf.org/html/rfc3986
+  #
+  # Properly handles escaping rules for paths, query strings and fragments
+  # independently
+  #
+  # The output is safe to pass to URI.parse or URI::Generic.build and will
+  # correctly round-trip through URI.unescape
+  #
+  # @param [String path] A URI string that may be in the form of:
+  #
+  #   http://foo.com/bar?query
+  #   file://tmp/foo bar
+  #   //foo.com/bar?query
+  #   /bar?query
+  #   bar?query
+  #   bar
+  #   .
+  #   C:\Windows\Temp
+  #
+  #   Note that with no specified scheme, authority or query parameter delimiter
+  #   ? that a naked string will be treated as a path.
+  #
+  #   Note that if query parameters need to contain data such as & or =
+  #   that this method should not be used, as there is no way to differentiate
+  #   query parameter data from query delimiters when multiple parameters
+  #   are specified
+  #
+  # @param [Hash{Symbol=>String} opts] Options to alter encoding
+  # @option opts [Array<Symbol>] :allow_fragment defaults to false. When false
+  #   will treat # as part of a path or query and not a fragment delimiter
+  #
+  # @return [String] a new string containing appropriate portions of the URI
+  #   encoded per the rules of RFC3986.
+  #   In particular,
+  #   path will not encode +, but will encode space as %20
+  #   query will encode + as %2B and space as %20
+  #   fragment behaves like query
+  def uri_encode(path, opts = { :allow_fragment => false })
+    raise ArgumentError.new('path may not be nil') if path.nil?
+
+    # ensure string starts as UTF-8 for the sake of Ruby 1.9.3
+    encoded = ''.encode!(Encoding::UTF_8)
+
+    # parse uri into named matches, then reassemble properly encoded
+    parts = path.match(RFC_3986_URI_REGEX)
+
+    encoded += parts[:scheme] unless parts[:scheme].nil?
+    encoded += parts[:authority] unless parts[:authority].nil?
+
+    # path requires space to be encoded as %20 (NEVER +)
+    # + should be left unencoded
+    # URI::parse and URI::Generic.build don't like paths encoded with CGI.escape
+    # URI.escape does not change / to %2F and : to %3A like CGI.escape
+    encoded += URI.escape(parts[:path]) unless parts[:path].nil?
+
+    # each query parameter
+    if !parts[:query].nil?
+      query_string = parts[:query].split('&').map do |pair|
+        # can optionally be separated by an =
+        pair.split('=').map do |v|
+          uri_query_encode(v)
+        end.join('=')
+      end.join('&')
+      encoded += '?' + query_string
+    end
+
+    encoded += ((opts[:allow_fragment] ? '#' : '%23') + uri_query_encode(parts[:fragment])) unless parts[:fragment].nil?
+
+    encoded
+  end
+  module_function :uri_encode
+
   def safe_posix_fork(stdin=$stdin, stdout=$stdout, stderr=$stderr, &block)
     child_pid = Kernel.fork do
       $stdin.reopen(stdin)
@@ -551,7 +675,7 @@ module Util
     ## NOTE: when debugging spec failures, these two lines can be very useful
     #puts err.inspect
     #puts Puppet::Util.pretty_backtrace(err.backtrace)
-    Puppet.log_exception(err, "Could not #{message}: #{err}")
+    Puppet.log_exception(err, _("Could not %{message}: %{err}") % { message: message, err: err })
     Puppet::Util::Log.force_flushqueue()
     exit(code)
   end

data/lib/puppet/vendor/semantic_puppet/lib/semantic_puppet/gem_version.rb

@@ -1,3 +1,3 @@
 module SemanticPuppet
-  VERSION = '0.1.4'
+  VERSION = '1.0.0'
 end

data/lib/puppet/vendor/semantic_puppet/lib/semantic_puppet/version.rb

@@ -1,7 +1,6 @@
 require 'semantic_puppet'
 
 module SemanticPuppet
-
   # @note SemanticPuppet::Version subclasses Numeric so that it has sane Range
   #       semantics in Ruby 1.9+.
   class Version < Numeric
@@ -9,69 +8,46 @@ module SemanticPuppet
 
     class ValidationFailure < ArgumentError; end
 
-    class << self
-      # Parse a Semantic Version string.
-      #
-      # @param ver [String] the version string to parse
-      # @return [Version] a comparable {Version} object
-      def parse(ver)
-        match, major, minor, patch, prerelease, build = *ver.match(/\A#{REGEX_FULL}\Z/)
-
-        if match.nil?
-          raise _("Unable to parse '%{version}' as a semantic version identifier") % {version: ver}
-        end
-
-        prerelease = parse_prerelease(prerelease) if prerelease
-        # Build metadata is not yet supported in semantic_puppet, but we hope to.
-        # The following code prevents build metadata for now.
-        #build = parse_build_metadata(build) if build
-        if !build.nil?
-          raise _("'%{version}' MUST NOT include build identifiers") % {version: ver}
-        end
-
-        self.new(major.to_i, minor.to_i, patch.to_i, prerelease, build)
-      end
+    # Parse a Semantic Version string.
+    #
+    # @param ver [String] the version string to parse
+    # @return [Version] a comparable {Version} object
+    def self.parse(ver)
+      match, major, minor, patch, prerelease, build = *ver.match(REGEX_FULL_RX)
 
-      # Validate a Semantic Version string.
-      #
-      # @param ver [String] the version string to validate
-      # @return [bool] whether or not the string represents a valid Semantic Version
-      def valid?(ver)
-        !!(ver =~ /\A#{REGEX_FULL}\Z/)
-      end
+      raise ValidationFailure, _("Unable to parse '%{version}' as a semantic version identifier") % {version: ver} unless match
 
-      private
-      def parse_prerelease(prerelease)
-        subject = 'Prerelease identifiers'
-        prerelease = prerelease.split('.', -1)
-
-        if prerelease.empty? or prerelease.any? { |x| x.empty? }
-          raise _("%{subject} MUST NOT be empty") % {subject: subject}
-        elsif prerelease.any? { |x| x =~ /[^0-9a-zA-Z-]/ }
-          raise _("%{subject} MUST use only ASCII alphanumerics and hyphens") % {subject: subject}
-        elsif prerelease.any? { |x| x =~ /^0\d+$/ }
-          raise _("%{subject} MUST NOT contain leading zeroes") % {subject: subject}
-        end
+      new(major.to_i, minor.to_i, patch.to_i, parse_prerelease(prerelease), parse_build(build)).freeze
+    end
 
-        return prerelease.map { |x| x =~ /^\d+$/ ? x.to_i : x }
+    # Validate a Semantic Version string.
+    #
+    # @param ver [String] the version string to validate
+    # @return [bool] whether or not the string represents a valid Semantic Version
+    def self.valid?(ver)
+      match = ver.match(REGEX_FULL_RX)
+      if match.nil?
+        false
+      else
+        prerelease = match[4]
+        prerelease.nil? || prerelease.split('.').all? { |x| !(x =~ /^0\d+/) }
       end
+    end
 
-      def parse_build_metadata(build)
-        subject = 'Build identifiers'
-        build = build.split('.', -1)
+    def self.parse_build(build)
+      build.nil? ? nil : build.split('.').freeze
+    end
 
-        if build.empty? or build.any? { |x| x.empty? }
-          raise _("%{subject} MUST NOT be empty") % {subject: subject}
-        elsif build.any? { |x| x =~ /[^0-9a-zA-Z-]/ }
-          raise _("%{subject} MUST use only ASCII alphanumerics and hyphens") % {subject: subject}
+    def self.parse_prerelease(prerelease)
+      return nil unless prerelease
+      prerelease.split('.').map do |x|
+        if x =~ /^\d+$/
+          raise ValidationFailure, _('Numeric pre-release identifiers MUST NOT contain leading zeroes') if x.length > 1 && x.start_with?('0')
+          x.to_i
+        else
+          x
         end
-
-        return build
-      end
-
-      def raise(msg)
-        super ValidationFailure, msg, caller.drop_while { |x| x !~ /\bparse\b/ }
-      end
+      end.freeze
     end
 
     attr_reader :major, :minor, :patch
@@ -95,24 +71,39 @@ module SemanticPuppet
       end
     end
 
+    # @return [String] the `prerelease` identifier as a string without the leading '-'
     def prerelease
-      @prerelease && @prerelease.join('.')
+      (@prerelease.nil? || @prerelease.empty?) ? nil : @prerelease.join('.')
     end
 
     # @return [Boolean] true if this is a stable release
     def stable?
-      @prerelease.nil?
+      @prerelease.nil? || @prerelease.empty?
+    end
+
+    # @return [Version] this version stripped from any prerelease identifier.
+    def to_stable
+      @prerelease.nil? ? self : Version.new(@major, @minor, @patch, nil, @build)
     end
 
+    # @return [String] the `build` identifier as a string without the leading '+'
     def build
-      @build && @build.join('.')
+      (@build.nil? || @build.empty?) ? nil : @build.join('.')
     end
 
     def <=>(other)
-      return self.major <=> other.major unless self.major == other.major
-      return self.minor <=> other.minor unless self.minor == other.minor
-      return self.patch <=> other.patch unless self.patch == other.patch
-      return compare_prerelease(other)
+      return nil unless other.is_a?(Version)
+      cmp = @major <=> other.major
+      if cmp == 0
+        cmp = @minor <=> other.minor
+        if cmp == 0
+          cmp = @patch <=> other.patch
+          if cmp == 0
+            cmp = compare_prerelease(other)
+          end
+        end
+      end
+      cmp
     end
 
     def eql?(other)
@@ -126,70 +117,87 @@ module SemanticPuppet
     alias == eql?
 
     def to_s
-      "#{major}.#{minor}.#{patch}" +
-      (@prerelease.nil? || prerelease.empty? ? '' : "-" + prerelease) +
-      (@build.nil?      || build.empty?      ? '' : "+" + build     )
+      s = "#{@major}.#{@minor}.#{@patch}"
+
+      # Appending the @prerelease and @build in a thoroughly tested and optimized
+      # way. Using interpolations and/or array joins may look simpler but will slows
+      # things down. Don't change this code without measuring performance of new
+      # solution.
+      unless @prerelease.nil?
+        s << '-' << @prerelease[0].to_s
+        i = 0
+        l = @prerelease.length
+        while (i += 1) < l
+          s << '.' << @prerelease[i].to_s
+        end
+      end
+      unless @build.nil?
+        s << '+' << @build[0].to_s
+        i = 0
+        l = @build.length
+        while (i += 1) < l
+          s << '.' << @build[i].to_s
+        end
+      end
+      s
     end
+    alias inspect to_s
 
     def hash
-      self.to_s.hash
+      (((((@major * 0x100) ^ @minor) * 0x100) ^ @patch) * 0x100) ^ @prerelease.hash
     end
 
-    private
-    # This is a hack; tildes sort later than any valid identifier. The
-    # advantage is that we don't need to handle stable vs. prerelease
-    # comparisons separately.
-    @@STABLE_RELEASE = [ '~' ].freeze
-
     def compare_prerelease(other)
-      all_mine  = @prerelease                               || @@STABLE_RELEASE
-      all_yours = other.instance_variable_get(:@prerelease) || @@STABLE_RELEASE
-
-      # Precedence is determined by comparing each dot separated identifier from
-      # left to right...
-      size = [ all_mine.size, all_yours.size ].max
-      Array.new(size).zip(all_mine, all_yours) do |_, mine, yours|
-
-        # ...until a difference is found.
-        next if mine == yours
-
-        # Numbers are compared numerically, strings are compared ASCIIbetically.
-        if mine.class == yours.class
-          return mine <=> yours
-
-        # A larger set of pre-release fields has a higher precedence.
-        elsif mine.nil?
-          return -1
-        elsif yours.nil?
-          return 1
-
-        # Numeric identifiers always have lower precedence than non-numeric.
-        elsif mine.is_a? Numeric
-          return -1
-        elsif yours.is_a? Numeric
-          return 1
+      mine = @prerelease
+
+      # Need to use the instance variable here to avoid getting a string
+      yours = other.instance_variable_get(:@prerelease)
+
+      # A version that has a prerelease is always less than a version that doesn't
+      if mine.nil?
+        yours.nil? ? 0 : 1
+      elsif yours.nil?
+        -1
+      else
+        # Compare all prerelease identifier segments that can be compared. Should
+        # all segments compare equal up to the point where one of the prereleases
+        # have no more segments, then the one with more segements is greater.
+        your_max = yours.size
+        mine.each_with_index do |x, idx|
+          # 'mine' win if 'your' list of segments is exhausted
+          return 1 if idx >= your_max
+          y = yours[idx]
+
+          # Integer always wins over String
+          cmp = if x.is_a?(Integer)
+            y.is_a?(Integer) ? x <=> y : -1
+          elsif y.is_a?(Integer)
+            1
+          else
+            x <=> y
+          end
+
+          # No need to continue if a diff is found
+          return cmp unless cmp == 0
         end
-      end
 
-      return 0
-    end
-
-    def first_prerelease
-      self.class.new(@major, @minor, @patch, [])
+        # All segments, up to the point where at least one list of segement is exhausted,
+        # compared equal. The one with the highest segment count wins.
+        mine.size <=> your_max
+      end
     end
 
-    public
-
     # Version string matching regexes
-    REGEX_NUMERIC = "(0|[1-9]\\d*)[.](0|[1-9]\\d*)[.](0|[1-9]\\d*)" # Major . Minor . Patch
-    REGEX_PRE     = "(?:[-](.*?))?"            # Prerelease
-    REGEX_BUILD   = "(?:[+](.*?))?"            # Build
-    REGEX_FULL    = REGEX_NUMERIC + REGEX_PRE + REGEX_BUILD
+    REGEX_NUMERIC = '(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)'.freeze # Major . Minor . Patch
+    REGEX_PRE     = '(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?'.freeze    # Prerelease
+    REGEX_BUILD   = '(?:\+([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?'.freeze  # Build
+    REGEX_FULL    = REGEX_NUMERIC + REGEX_PRE + REGEX_BUILD.freeze
+    REGEX_FULL_RX = /\A#{REGEX_FULL}\Z/.freeze
 
     # The lowest precedence Version possible
-    MIN = self.new(0, 0, 0, []).freeze
+    MIN = self.new(0, 0, 0, [].freeze).freeze
 
     # The highest precedence Version possible
-    MAX = self.new((1.0/0.0), 0, 0).freeze
+    MAX = self.new(Float::INFINITY, 0, 0).freeze
   end
 end