puppet-retrospec 0.7.0 → 0.7.2

data/vendor/gems/puppet-3.7.3/lib/puppet/version.rb

@@ -0,0 +1,89 @@
+# The version method and constant are isolated in puppet/version.rb so that a
+# simple `require 'puppet/version'` allows a rubygems gemspec or bundler
+# Gemfile to get the Puppet version of the gem install.
+#
+# The version is programatically settable because we want to allow the
+# Raketasks and such to set the version based on the output of `git describe`
+
+
+module Puppet
+  PUPPETVERSION = '3.7.3'
+
+  ##
+  # version is a public API method intended to always provide a fast and
+  # lightweight way to determine the version of Puppet.
+  #
+  # The intent is that software external to Puppet be able to determine the
+  # Puppet version with no side-effects.  The expected use is:
+  #
+  #     require 'puppet/version'
+  #     version = Puppet.version
+  #
+  # This function has the following ordering precedence.  This precedence list
+  # is designed to facilitate automated packaging tasks by simply writing to
+  # the VERSION file in the same directory as this source file.
+  #
+  #  1. If a version has been explicitly assigned using the Puppet.version=
+  #     method, return that version.
+  #  2. If there is a VERSION file, read the contents, trim any
+  #     trailing whitespace, and return that version string.
+  #  3. Return the value of the Puppet::PUPPETVERSION constant hard-coded into
+  #     the source code.
+  #
+  # If there is no VERSION file, the method must return the version string of
+  # the nearest parent version that is an officially released version.  That is
+  # to say, if a branch named 3.1.x contains 25 patches on top of the most
+  # recent official release of 3.1.1, then the version method must return the
+  # string "3.1.1" if no "VERSION" file is present.
+  #
+  # By design the version identifier is _not_ intended to vary during the life
+  # a process.  There is no guarantee provided that writing to the VERSION file
+  # while a Puppet process is running will cause the version string to be
+  # updated.  On the contrary, the contents of the VERSION are cached to reduce
+  # filesystem accesses.
+  #
+  # The VERSION file is intended to be used by package maintainers who may be
+  # applying patches or otherwise changing the software version in a manner
+  # that warrants a different software version identifier.  The VERSION file is
+  # intended to be managed and owned by the release process and packaging
+  # related tasks, and as such should not reside in version control.  The
+  # PUPPETVERSION constant is intended to be version controlled in history.
+  #
+  # Ideally, this behavior will allow package maintainers to precisely specify
+  # the version of the software they're packaging as in the following example:
+  #
+  #     $ git describe --match "3.0.*" > lib/puppet/VERSION
+  #     $ ruby -r puppet -e 'puts Puppet.version'
+  #     3.0.1-260-g9ca4e54
+  #
+  # @api public
+  #
+  # @return [String] containing the puppet version, e.g. "3.0.1"
+  def self.version
+    version_file = File.join(File.dirname(__FILE__), 'VERSION')
+    return @puppet_version if @puppet_version
+    if version = read_version_file(version_file)
+      @puppet_version = version
+    end
+    @puppet_version ||= PUPPETVERSION
+  end
+
+  def self.version=(version)
+    @puppet_version = version
+  end
+
+  ##
+  # read_version_file reads the content of the "VERSION" file that lives in the
+  # same directory as this source code file.
+  #
+  # @api private
+  #
+  # @return [String] for example: "1.6.14-6-gea42046" or nil if the VERSION
+  #   file does not exist.
+  def self.read_version_file(path)
+    if File.exist?(path)
+      File.read(path).chomp
+    end
+  end
+  private_class_method :read_version_file
+end

data/vendor/gems/puppet-3.7.3/lib/puppetx.rb

@@ -0,0 +1,89 @@
+# The Puppet Extensions Module.
+#
+# Submodules of this module should be named after the publisher (e.g. 'user' part of a Puppet Module name).
+# The submodule {Puppetx::Puppet} contains the puppet extension points.
+#
+# This module also contains constants that are used when defining extensions.
+#
+# @api public
+#
+module Puppetx
+
+  # The lookup **key** for the multibind containing syntax checkers used to syntax check embedded string in non
+  # puppet DSL syntax.
+  # @api public
+  SYNTAX_CHECKERS       = 'puppetx::puppet::syntaxcheckers'
+
+  # The lookup **type** for the multibind containing syntax checkers used to syntax check embedded string in non
+  # puppet DSL syntax.
+  # @api public
+  SYNTAX_CHECKERS_TYPE  = 'Puppetx::Puppet::SyntaxChecker'
+
+  # The lookup **key** for the multibind containing a map from scheme name to scheme handler class for bindings schemes.
+  # @api public
+  BINDINGS_SCHEMES      = 'puppetx::puppet::bindings::schemes'
+
+  # The lookup **type** for the multibind containing a map from scheme name to scheme handler class for bindings schemes.
+  # @api public
+  BINDINGS_SCHEMES_TYPE = 'Puppetx::Puppet::BindingsSchemeHandler'
+
+  # This module is the name space for extension points
+  # @api public
+  module Puppet
+
+    if ::Puppet[:binder] || ::Puppet[:parser] == 'future'
+        # Extension-points are registered here:
+        # - If in a Ruby submodule it is best to create it here
+        # - The class does not have to be required; it will be auto required when the binder
+        #   needs it.
+        # - If the extension is a multibind, it can be registered here; either with a required
+        #   class or a class reference in string form.
+
+        # Register extension points
+        # -------------------------
+        system_bindings = ::Puppet::Pops::Binder::SystemBindings
+        extensions = system_bindings.extensions()
+        extensions.multibind(SYNTAX_CHECKERS).name(SYNTAX_CHECKERS).hash_of(SYNTAX_CHECKERS_TYPE)
+        extensions.multibind(BINDINGS_SCHEMES).name(BINDINGS_SCHEMES).hash_of(BINDINGS_SCHEMES_TYPE)
+
+        # Register injector boot bindings
+        # -------------------------------
+        boot_bindings = system_bindings.injector_boot_bindings()
+
+        # Register the default bindings scheme handlers
+        require 'puppetx/puppet/bindings_scheme_handler'
+        { 'module'        => 'ModuleScheme', 
+          'confdir'       => 'ConfdirScheme',
+        }.each do |scheme, class_name|
+          boot_bindings.bind.name(scheme).instance_of(BINDINGS_SCHEMES_TYPE).in_multibind(BINDINGS_SCHEMES).
+            to_instance("Puppet::Pops::Binder::SchemeHandler::#{class_name}")
+        end
+      end
+  end
+
+  # Module with implementations of various extensions
+  # @api public
+  module Puppetlabs
+    # Default extensions delivered in Puppet Core are included here
+
+    # @api public
+    module SyntaxCheckers
+      if ::Puppet[:binder] || ::Puppet[:parser] == 'future'
+
+        # Classes in this name-space are lazily loaded as they may be overridden and/or never used
+        # (Lazy loading is done by binding to the name of a class instead of a Class instance).
+
+        # Register extensions
+        # -------------------
+        system_bindings = ::Puppet::Pops::Binder::SystemBindings
+        bindings = system_bindings.default_bindings()
+        bindings.bind do
+          name('json')
+          instance_of(SYNTAX_CHECKERS_TYPE)
+          in_multibind(SYNTAX_CHECKERS)
+          to_instance('Puppetx::Puppetlabs::SyntaxCheckers::Json')
+        end
+      end
+    end
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppetx/puppet/bindings_scheme_handler.rb

@@ -0,0 +1,130 @@
+module Puppetx::Puppet
+  # BindingsSchemeHandler is a Puppet Extension Point for the purpose of extending Puppet with a
+  # handler of a URI scheme used in the Puppet Bindings / Injector system.
+  # The intended use is to create a class derived from this class and then register it with the
+  # Puppet Binder.
+  #
+  # Creating the Extension Class
+  # ----------------------------
+  # As an example, a class for getting LDAP data and transforming into bindings based on an LDAP URI scheme (such as RFC 2255, 4516)
+  # may be authored in say a puppet module called 'exampleorg/ldap'. The name of the class should start with `Puppetx::<user>::<module>`,
+  # e.g. 'Puppetx::Exampleorg::Ldap::LdapBindingsSchemeHandler" and
+  # be located in `lib/puppetx/exampleorg/Ldap/LdapBindingsSchemeHandler.rb`. (These rules are not enforced, but it make the class
+  # both auto-loadable, and guaranteed to not have a name that clashes with some other LdapBindingsSchemeHandler from some other
+  # author/organization.
+  #
+  # The Puppet Binder will auto-load the file when it
+  # has a binding to the class `Puppetx::Exampleorg::Ldap::LdapBindingsSchemeHandler'
+  # The Ruby Module `Puppetx` is created by Puppet, the remaining modules should be created by the loaded logic - e.g.:
+  #
+  # @example Defining an LdapBindingsSchemeHandler
+  #   module Puppetx::Exampleorg
+  #     module Ldap
+  #       class LdapBindingsSchemeHandler < Puppetx::Puppetlabs::BindingsSchemeHandler
+  #         # implement the methods
+  #       end
+  #     end
+  #   end
+  #
+  #
+  # The expand_included method
+  # --------------------------
+  # This method is given a URI (as entred by a user in a bindings configuration) and the handler's first task is to
+  # perform checking, transformation, and possible expansion into multiple URIs for loading. The result is always an array
+  # of URIs. This method allows users to enter wild-cards, or to represent something symbolic that is transformed into one or
+  # more "real URIs" to load. (It is allowed to change scheme!).
+  # If the "optional" feature is supported, the handler should not include the URI in the result unless it will be able to produce
+  # bindings for the given URI (as an option it may produce an empty set of bindings).
+  #
+  # The expand_excluded method
+  # ---------------------------
+  # This method is given an URI (as entered by the user in a bindings configuration), and it is the handler's second task
+  # to perform checking, transformation, and possible expansion into multiple URIs that should not be loaded. The result is always
+  # an array of URIs. The user may be allowed to enter wild-cards etc. The URIs produced by this method should have the same syntax
+  # as those produced by {#expand_included} since they are excluded by comparison.
+  #
+  # The contributed_bindings method
+  # -------------------------------
+  # As the last step, the handler is being called once per URI that was included, and not later excluded to produce the
+  # contributed bindings. It is given three arguments, uri (the uri to load), scope (to provide access to the rest of the
+  # environment), and an acceptor (of issues), on which issues can be recorded.
+  #
+  # Reporting Errors/Issues
+  # -----------------------
+  # Issues are reported by calling the given composer's acceptor, which takes a severity (e.g. `:error`,
+  # `:warning`, or `:ignore`), an {Puppet::Pops::Issues::Issue Issue} instance, and a {Puppet::Pops::Adapters::SourcePosAdapter
+  # SourcePosAdapter} (which describes details about linenumber, position, and length of the problem area). If the scheme is
+  # not based on file, line, pos - nil can be passed. The URI itself can be passed as file.
+  #
+  # @example Reporting an issue
+  #    # create an issue with a symbolic name (that can serve as a reference to more details about the problem),
+  #    # make the name unique
+  #    issue = Puppet::Pops::Issues::issue(:EXAMPLEORG_LDAP_ILLEGAL_URI) { "The URI is not a valid Ldap URI" }
+  #    source_pos = nil
+  #
+  #    # report it
+  #    composer.acceptor.accept(Puppet::Pops::Validation::Diagnostic.new(:error, issue, uri.to_s, source_pos, {}))
+  #
+  # Instead of reporting issues, an exception can be raised.
+  #
+  # @abstract
+  # @api public
+  #
+  class BindingsSchemeHandler
+
+    # Produces the bindings contributed to the binding system based on the given URI.
+    # @param uri [URI] the URI to load bindings from
+    # @param scope [Puppet::Pops::Parser::Scope] access to scope and the rest of the environment
+    # @param composer [Puppet::Pops::Binder::BindingsComposer] a composer giving access to modules by name, and a diagnostics acceptor
+    # @return [Puppet::Pops::Binder::Bindings::ContributedBindings] the bindings to contribute, most conveniently
+    #   created by calling {Puppet::Pops::Binder::BindingsFactory.contributed_bindings}.
+    # @api public
+    #
+    def contributed_bindings(uri, scope, composer)
+      raise NotImplementedError, "The BindingsProviderScheme for uri: '#{uri}' must implement 'contributed_bindings'"
+    end
+
+    # Expands the given URI for the purpose of including the bindings it refers to. The input may contain
+    # wild-cards (if supported by this handler), and it is this methods responsibility to transform such into
+    # real loadable URIs.
+    #
+    # A scheme handler that does not support optionality, or wildcards should simply return the given URI
+    # in an Array.
+    #
+    # @param uri [URI] the uri for which bindings are to be produced.
+    # @param composer [Puppet::Pops::Binder::BindingsComposer] a composer giving access to modules by name, and a diagnostics acceptor
+    # @return [Array<URI>] the transformed, and possibly expanded set of URIs to include.
+    # @api public
+    #
+    def expand_included(uri, composer)
+      [uri]
+    end
+
+    # Expands the given URI for the purpose of excluding the bindings it refers to. The input may contain
+    # wild-cards (if supported by this handler), and it is this methods responsibility to transform such into
+    # real loadable URIs (that match those produced by {#expand_included} that should be excluded from the result.
+    #
+    # A scheme handler that does not support optionality, or wildcards should simply return the given URI
+    # in an Array.
+    #
+    # @param uri [URI] the uri for which bindings are to be produced.
+    # @param composer [Puppet::Pops::Binder::BindingsComposer] a composer giving access to modules by name, and a diagnostics acceptor
+    # @return [Array<URI>] the transformed, and possibly expanded set of URIs to include-
+    # @api public
+    #
+    def expand_excluded(uri, composer)
+      [uri]
+    end
+
+    # Returns whether the uri is optional or not. A scheme handler does not have to use this method
+    # to determine optionality, but if it supports such a feature, and there is no technical problem in supporting
+    # it this way, it should be done the same (or at least similar) way across all scheme handlers.
+    #
+    # This method interprets a URI ending with `?` or has query that is '?optional' as optional.
+    #
+    # @return [Boolean] whether the uri is an optional reference or not.
+    def is_optional?(uri)
+      (query = uri.query) && query == '' || query == 'optional'
+    end
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppetx/puppet/syntax_checker.rb

@@ -0,0 +1,91 @@
+module Puppetx::Puppet
+  # SyntaxChecker is a Puppet Extension Point for the purpose of extending Puppet with syntax checkers.
+  # The intended use is to create a class derived from this class and then register it with the
+  # Puppet Binder.
+  #
+  # Creating the Extension Class
+  # ----------------------------
+  # As an example, a class for checking custom xml (aware of some custom schemes) may be authored in
+  # say a puppet module called 'exampleorg/xmldata'. The name of the class should start with `Puppetx::<user>::<module>`,
+  # e.g. 'Puppetx::Exampleorg::XmlData::XmlChecker" and
+  # be located in `lib/puppetx/exampleorg/xml_data/xml_checker.rb`. The Puppet Binder will auto-load this file when it
+  # has a binding to the class `Puppetx::Exampleorg::XmlData::XmlChecker'
+  # The Ruby Module `Puppetx` is created by Puppet, the remaining modules should be created by the loaded logic - e.g.:
+  #
+  # @example Defining an XmlChecker
+  #   module Puppetx::Exampleorg
+  #     module XmlData
+  #       class XmlChecker < Puppetx::Puppetlabs::SyntaxCheckers::SyntaxChecker
+  #         def check(text, syntax_identifier, acceptor, location_hash)
+  #            # do the checking
+  #         end
+  #       end
+  #     end
+  #   end
+  #
+  # Implementing the check method
+  # -----------------------------
+  # The implementation of the {#check} method should naturally perform syntax checking of the given text/string and
+  # produce found issues on the given `acceptor`. These can be warnings or errors. The method should return `false` if
+  # any warnings or errors were produced (it is up to the caller to check for error/warning conditions and report them
+  # to the user).
+  #
+  # Issues are reported by calling the given `acceptor`, which takes a severity (e.g. `:error`,
+  # or `:warning), an {Puppet::Pops::Issues::Issue} instance, and a {Puppet::Pops::Adapters::SourcePosAdapter}
+  # (which describes details about linenumber, position, and length of the problem area). Note that the
+  # `location_info` given to the check method holds information about the location of the string in its *container*
+  # (e.g. the source position of a Heredoc); this information can be used if more detailed information is not
+  # available, or combined if there are more details (relative to the start of the checked string).
+  #
+  # @example Reporting an issue
+  #    # create an issue with a symbolic name (that can serve as a reference to more details about the problem),
+  #    # make the name unique
+  #    issue = Puppet::Pops::Issues::issue(:EXAMPLEORG_XMLDATA_ILLEGAL_XML) { "syntax error found in xml text" }
+  #    source_pos = Puppet::Pops::Adapters::SourcePosAdapter.new()
+  #    source_pos.line = info[:line] # use this if there is no detail from the used parser
+  #    source_pos.pos = info[:pos]   # use this pos if there is no detail from used parser
+  #
+  #    # report it
+  #    acceptor.accept(Puppet::Pops::Validation::Diagnostic.new(:error, issue, info[:file], source_pos, {}))
+  #
+  # There is usually a cap on the number of errors/warnings that are presented to the user, this is handled by the
+  # reporting logic, but care should be taken to not generate too many as the issues are kept in memory until
+  # the checker returns. The acceptor may set a limit and simply ignore issues past a certain (high) number of reported
+  # issues (this number is typically higher than the cap on issues reported to the user).
+  #
+  # The `syntax_identifier`
+  # -----------------------
+  # The extension makes use of a syntax identifier written in mime-style. This identifier can be something simple
+  # as 'xml', or 'json', but can also consist of several segments joined with '+' where the most specific syntax variant
+  # is placed first. When searching for a syntax checker; say for JSON having some special traits, say 'userdata', the
+  # author of the text may indicate this as the text having the syntax "userdata+json" - when a checker is looked up it is
+  # first checked if there is a checker for "userdata+json", if none is found, a lookup is made for "json" (since the text
+  # must at least be valid json). The given identifier is passed to the checker (to allow the same checker to check for
+  # several dialects/specializations).
+  #
+  # Use in Puppet DSL
+  # -----------------
+  # The Puppet DSL Heredoc support and Puppet Templates makes use of the syntax checker extension. A user of a
+  # heredoc can specify the syntax in the heredoc tag, e.g.`@(END:userdata+json)`.
+  #
+  #
+  # @abstract
+  #
+  class SyntaxChecker
+    # Checks the text for syntax issues and reports them to the given acceptor.
+    # This implementation is abstract, it raises {NotImplementedError} since a subclass should have implemented the
+    # method.
+    #
+    # @param text [String] The text to check
+    # @param syntax_identifier [String] The syntax identifier in mime style (e.g. 'json', 'json-patch+json', 'xml', 'myapp+xml'
+    # @option location_info [String] :file The filename where the string originates
+    # @option location_info [Integer] :line The line number identifying the location where the string is being used/checked
+    # @option location_info [Integer] :position The position on the line identifying the location where the string is being used/checked
+    # @return [Boolean] Whether the checked string had issues (warnings and/or errors) or not.
+    # @api public
+    #
+    def check(text, syntax_identifier, acceptor, location_info)
+      raise NotImplementedError, "The class #{self.class.name} should have implemented the method check()"
+    end
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppetx/puppetlabs/syntax_checkers/json.rb

@@ -0,0 +1,37 @@
+# A syntax checker for JSON.
+# @api public
+require 'puppetx/puppet/syntax_checker'
+class Puppetx::Puppetlabs::SyntaxCheckers::Json < Puppetx::Puppet::SyntaxChecker
+
+  # Checks the text for JSON syntax issues and reports them to the given acceptor.
+  # This implementation is abstract, it raises {NotImplementedError} since a subclass should have implemented the
+  # method.
+  #
+  # Error messages from the checker are capped at 100 chars from the source text.
+  #
+  # @param text [String] The text to check
+  # @param syntax [String] The syntax identifier in mime style (e.g. 'json', 'json-patch+json', 'xml', 'myapp+xml'
+  # @param acceptor [#accept] A Diagnostic acceptor
+  # @param source_pos [Puppet::Pops::Adapters::SourcePosAdapter] A source pos adapter with location information
+  # @api public
+  #
+  def check(text, syntax, acceptor, source_pos)
+    raise ArgumentError.new("Json syntax checker: the text to check must be a String.") unless text.is_a?(String)
+    raise ArgumentError.new("Json syntax checker: the syntax identifier must be a String, e.g. json, data+json") unless syntax.is_a?(String)
+    raise ArgumentError.new("Json syntax checker: invalid Acceptor, got: '#{acceptor.class.name}'.") unless acceptor.is_a?(Puppet::Pops::Validation::Acceptor)
+    #raise ArgumentError.new("Json syntax checker: location_info must be a Hash") unless location_info.is_a?(Hash)
+
+    begin
+      JSON.parse(text)
+    rescue => e
+      # Cap the message to 100 chars and replace newlines
+      msg = "JSON syntax checker: Cannot parse invalid JSON string. \"#{e.message().slice(0,100).gsub(/\r?\n/, "\\n")}\""
+
+      # TODO: improve the pops API to allow simpler diagnostic creation while still maintaining capabilities
+      # and the issue code. (In this case especially, where there is only a single error message being issued).
+      #
+      issue = Puppet::Pops::Issues::issue(:ILLEGAL_JSON) { msg }
+      acceptor.accept(Puppet::Pops::Validation::Diagnostic.new(:error, issue, source_pos.locator.file, source_pos, {}))
+    end
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/semver.rb

@@ -0,0 +1,124 @@
+require 'puppet/util/monkey_patches'
+
+# We need to subclass Numeric to force range comparisons not to try to iterate over SemVer
+# and instead use numeric comparisons (eg >, <, >=, <=)
+# Ruby 1.8 already did this for all ranges, but Ruby 1.9 changed range include behavior
+class SemVer < Numeric
+  include Comparable
+
+  VERSION = /^v?(\d+)\.(\d+)\.(\d+)(-[0-9A-Za-z-]*|)$/
+  SIMPLE_RANGE = /^v?(\d+|[xX])(?:\.(\d+|[xX])(?:\.(\d+|[xX]))?)?$/
+
+  def self.valid?(ver)
+    VERSION =~ ver
+  end
+
+  def self.find_matching(pattern, versions)
+    versions.select { |v| v.matched_by?("#{pattern}") }.sort.last
+  end
+
+  def self.pre(vstring)
+    vstring =~ /-/ ? vstring : vstring + '-'
+  end
+
+  def self.[](range)
+    range.gsub(/([><=])\s+/, '\1').split(/\b\s+(?!-)/).map do |r|
+      case r
+      when SemVer::VERSION
+        SemVer.new(pre(r)) .. SemVer.new(r)
+      when SemVer::SIMPLE_RANGE
+        r += ".0" unless SemVer.valid?(r.gsub(/x/i, '0'))
+        SemVer.new(r.gsub(/x/i, '0'))...SemVer.new(r.gsub(/(\d+)\.x/i) { "#{$1.to_i + 1}.0" } + '-')
+      when /\s+-\s+/
+        a, b = r.split(/\s+-\s+/)
+        SemVer.new(pre(a)) .. SemVer.new(b)
+      when /^~/
+        ver = r.sub(/~/, '').split('.').map(&:to_i)
+        start = (ver + [0] * (3 - ver.length)).join('.')
+
+        ver.pop unless ver.length == 1
+        ver[-1] = ver.last + 1
+
+        finish = (ver + [0] * (3 - ver.length)).join('.')
+        SemVer.new(pre(start)) ... SemVer.new(pre(finish))
+      when /^>=/
+        ver = r.sub(/^>=/, '')
+        SemVer.new(pre(ver)) .. SemVer::MAX
+      when /^<=/
+        ver = r.sub(/^<=/, '')
+        SemVer::MIN .. SemVer.new(ver)
+      when /^>/
+        if r =~ /-/
+          ver = [r[1..-1]]
+        else
+          ver = r.sub(/^>/, '').split('.').map(&:to_i)
+          ver[2] = ver.last + 1
+        end
+        SemVer.new(ver.join('.') + '-') .. SemVer::MAX
+      when /^</
+        ver = r.sub(/^</, '')
+        SemVer::MIN ... SemVer.new(pre(ver))
+      else
+        (1..1)
+      end
+    end.inject { |a,e| a & e }
+  end
+
+  attr_reader :major, :minor, :tiny, :special
+
+  def initialize(ver)
+    unless SemVer.valid?(ver)
+      raise ArgumentError.new("Invalid version string '#{ver}'!")
+    end
+
+    @major, @minor, @tiny, @special = VERSION.match(ver).captures.map do |x|
+      # Because Kernel#Integer tries to interpret hex and octal strings, which
+      # we specifically do not want, and which cannot be overridden in 1.8.7.
+      Float(x).to_i rescue x
+    end
+  end
+
+  def <=>(other)
+    other = SemVer.new("#{other}") unless other.is_a? SemVer
+    return self.major <=> other.major unless self.major == other.major
+    return self.minor <=> other.minor unless self.minor == other.minor
+    return self.tiny  <=> other.tiny  unless self.tiny  == other.tiny
+
+    return 0  if self.special  == other.special
+    return 1  if self.special  == ''
+    return -1 if other.special == ''
+
+    return self.special <=> other.special
+  end
+
+  def matched_by?(pattern)
+    # For the time being, this is restricted to exact version matches and
+    # simple range patterns.  In the future, we should implement some or all of
+    # the comparison operators here:
+    # https://github.com/isaacs/node-semver/blob/d474801/semver.js#L340
+
+    case pattern
+    when SIMPLE_RANGE
+      pattern = SIMPLE_RANGE.match(pattern).captures
+      pattern[1] = @minor unless pattern[1] && pattern[1] !~ /x/i
+      pattern[2] = @tiny  unless pattern[2] && pattern[2] !~ /x/i
+      [@major, @minor, @tiny] == pattern.map { |x| x.to_i }
+    when VERSION
+      self == SemVer.new(pattern)
+    else
+      false
+    end
+  end
+
+  def inspect
+    @vstring || "v#{@major}.#{@minor}.#{@tiny}#{@special}"
+  end
+  alias :to_s :inspect
+
+  MIN = SemVer.new('0.0.0-')
+  MIN.instance_variable_set(:@vstring, 'vMIN')
+
+  MAX = SemVer.new('8.0.0')
+  MAX.instance_variable_set(:@major, Float::INFINITY) # => Infinity
+  MAX.instance_variable_set(:@vstring, 'vMAX')
+end