cocoapods-core 0.30.0 → 1.15.2

data/lib/cocoapods-core/vendor/version.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Pod::Vendor
 
   ##
@@ -24,6 +25,11 @@ module Pod::Vendor
   # 3. 1.0.a.2
   # 4. 0.9
   #
+  # If you want to specify a version restriction that includes both prereleases
+  # and regular releases of the 1.x series this is the best way:
+  #
+  #   s.add_dependency 'example', '>= 1.0.0.a', '< 2.0.0'
+  #
   # == How Software Changes
   #
   # Users expect to be able to specify a version constraint that gives them
@@ -83,8 +89,8 @@ module Pod::Vendor
   #
   # * Any "public" release of a gem should have a different version.  Normally
   #   that means incrementing the build number.  This means a developer can
-  #   generate builds all day long for himself, but as soon as he/she makes a
-  #   public release, the version must be updated.
+  #   generate builds all day long, but as soon as they make a public release,
+  #   the version must be updated.
   #
   # === Examples
   #
@@ -101,26 +107,25 @@ module Pod::Vendor
   # Version 1.1.1:: Fixed a bug in the linked list implementation.
   # Version 1.1.2:: Fixed a bug introduced in the last fix.
   #
-  # Client A needs a stack with basic push/pop capability.  He writes to the
-  # original interface (no <tt>top</tt>), so his version constraint looks
-  # like:
+  # Client A needs a stack with basic push/pop capability.  They write to the
+  # original interface (no <tt>top</tt>), so their version constraint looks like:
   #
-  #   gem 'stack', '~> 0.0'
+  #   gem 'stack', '>= 0.0'
   #
   # Essentially, any version is OK with Client A.  An incompatible change to
-  # the library will cause him grief, but he is willing to take the chance (we
-  # call Client A optimistic).
+  # the library will cause them grief, but they are willing to take the chance
+  # (we call Client A optimistic).
   #
-  # Client B is just like Client A except for two things: (1) He uses the
-  # <tt>depth</tt> method and (2) he is worried about future
-  # incompatibilities, so he writes his version constraint like this:
+  # Client B is just like Client A except for two things: (1) They use the
+  # <tt>depth</tt> method and (2) they are worried about future
+  # incompatibilities, so they write their version constraint like this:
   #
   #   gem 'stack', '~> 0.1'
   #
   # The <tt>depth</tt> method was introduced in version 0.1.0, so that version
   # or anything later is fine, as long as the version stays below version 1.0
   # where incompatibilities are introduced.  We call Client B pessimistic
-  # because he is worried about incompatible future changes (it is OK to be
+  # because they are worried about incompatible future changes (it is OK to be
   # pessimistic!).
   #
   # == Preventing Version Catastrophe:
@@ -131,8 +136,8 @@ module Pod::Vendor
   # specify your dependency as ">= 2.0.0" then, you're good, right? What
   # happens if fnord 3.0 comes out and it isn't backwards compatible
   # with 2.y.z? Your stuff will break as a result of using ">=". The
-  # better route is to specify your dependency with a "spermy" version
-  # specifier. They're a tad confusing, so here is how the dependency
+  # better route is to specify your dependency with an "approximate" version
+  # specifier ("~>"). They're a tad confusing, so here is how the dependency
   # specifiers work:
   #
   #   Specification From  ... To (exclusive)
@@ -141,196 +146,232 @@ module Pod::Vendor
   #   "~> 3.0.0"    3.0.0 ... 3.1
   #   "~> 3.5"      3.5   ... 4.0
   #   "~> 3.5.0"    3.5.0 ... 3.6
+  #   "~> 3"        3.0   ... 4.0
+  #
+  # For the last example, single-digit versions are automatically extended with
+  # a zero to give a sensible result.
 
-  module Gem
-    class Version
-      autoload :Requirement, 'rubygems/requirement'
+  class Gem::Version
+    autoload :Requirement, 'rubygems/requirement'
 
-      include Comparable
+    include Comparable
 
-      VERSION_PATTERN = '[0-9]+(\.[0-9a-zA-Z]+)*' # :nodoc:
-      ANCHORED_VERSION_PATTERN = /\A\s*(#{VERSION_PATTERN})*\s*\z/ # :nodoc:
+    VERSION_PATTERN = '[0-9]+(?>\.[0-9a-zA-Z]+)*(-[0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*)?' # :nodoc:
+    ANCHORED_VERSION_PATTERN = /\A\s*(#{VERSION_PATTERN})?\s*\z/ # :nodoc:
 
-      ##
-      # A string representation of this Version.
+    ##
+    # A string representation of this Version.
 
-      attr_reader :version
-      alias_method :to_s, :version
+    def version
+      @version.dup
+    end
 
-      ##
-      # True if the +version+ string matches RubyGems' requirements.
+    alias to_s version
 
-      def self.correct?(version)
-        version.to_s =~ ANCHORED_VERSION_PATTERN
-      end
+    ##
+    # True if the +version+ string matches RubyGems' requirements.
 
-      ##
-      # Factory method to create a Version object. Input may be a Version
-      # or a String. Intended to simplify client code.
-      #
-      #   ver1 = Version.create('1.3.17')   # -> (Version object)
-      #   ver2 = Version.create(ver1)       # -> (ver1)
-      #   ver3 = Version.create(nil)        # -> nil
-
-      def self.create(input)
-        if input.respond_to? :version then
-          input
-        elsif input.nil? then
-          nil
-        else
-          new input
-        end
-      end
+    def self.correct? version
+      version.to_s =~ ANCHORED_VERSION_PATTERN
+    end
 
-      ##
-      # Constructs a Version from the +version+ string.  A version string is a
-      # series of digits or ASCII letters separated by dots.
+    ##
+    # Factory method to create a Version object. Input may be a Version
+    # or a String. Intended to simplify client code.
+    #
+    #   ver1 = Version.create('1.3.17')   # -> (Version object)
+    #   ver2 = Version.create(ver1)       # -> (ver1)
+    #   ver3 = Version.create(nil)        # -> nil
+
+    def self.create input
+      if self === input then # check yourself before you wreck yourself
+        input
+      elsif input.nil? then
+        nil
+      else
+        new input
+      end
+    end
 
-      def initialize(version)
-        unless self.class.correct?(version)
-          raise ArgumentError, "Malformed version number string #{version}"
-        end
+    @@all = {}
 
-        @version = version.to_s
-        @version.strip!
-      end
+    def self.new version # :nodoc:
+      return super unless Gem::Version == self
 
-      ##
-      # Return a new version object where the next to the last revision
-      # number is one greater (e.g., 5.3.1 => 5.4).
-      #
-      # Pre-release (alpha) parts, e.g, 5.3.1.b.2 => 5.4, are ignored.
+      @@all[version] ||= super
+    end
 
-      def bump
-        segments = self.segments.dup
-        segments.pop while segments.any? { |s| String === s }
-        segments.pop if segments.size > 1
+    ##
+    # Constructs a Version from the +version+ string.  A version string is a
+    # series of digits or ASCII letters separated by dots.
 
-        segments[-1] = segments[-1].succ
-        self.class.new segments.join(".")
-      end
+    def initialize version
+      raise ArgumentError, "Malformed version number string #{version}" unless
+        self.class.correct?(version)
 
-      ##
-      # A Version is only eql? to another version if it's specified to the
-      # same precision. Version "1.0" is not the same as version "1".
+      @version = version.to_s.strip.gsub("-",".pre.")
+      @segments = nil
+    end
 
-      def eql?(other)
-        self.class === other and @version == other.version
-      end
+    ##
+    # Return a new version object where the next to the last revision
+    # number is one greater (e.g., 5.3.1 => 5.4).
+    #
+    # Pre-release (alpha) parts, e.g, 5.3.1.b.2 => 5.4, are ignored.
+
+    def bump
+      @bump ||= begin
+                  segments = self.segments
+                  segments.pop while segments.any? { |s| String === s }
+                  segments.pop if segments.size > 1
+
+                  segments[-1] = segments[-1].succ
+                  self.class.new segments.join(".")
+                end
+    end
 
-      def hash # :nodoc:
-        @hash ||= segments.hash
-      end
+    ##
+    # A Version is only eql? to another version if it's specified to the
+    # same precision. Version "1.0" is not the same as version "1".
 
-      def init_with(coder) # :nodoc:
-        yaml_initialize coder.tag, coder.map
-      end
+    def eql? other
+      self.class === other and @version == other._version
+    end
 
-      def inspect # :nodoc:
-        "#<#{self.class} #{version.inspect}>"
-      end
+    def hash # :nodoc:
+      @version.hash
+    end
 
-      ##
-      # Dump only the raw version string, not the complete object. It's a
-      # string for backwards (RubyGems 1.3.5 and earlier) compatibility.
+    def init_with coder # :nodoc:
+      yaml_initialize coder.tag, coder.map
+    end
 
-      def marshal_dump
-        [version]
-      end
+    def inspect # :nodoc:
+      "#<#{self.class} #{version.inspect}>"
+    end
 
-      ##
-      # Load custom marshal format. It's a string for backwards (RubyGems
-      # 1.3.5 and earlier) compatibility.
+    ##
+    # Dump only the raw version string, not the complete object. It's a
+    # string for backwards (RubyGems 1.3.5 and earlier) compatibility.
 
-      def marshal_load(array)
-        initialize array[0]
-      end
+    def marshal_dump
+      [version]
+    end
 
-      def yaml_initialize(tag, map)
-        @version = map['version']
-        @segments = nil
-        @hash = nil
-      end
+    ##
+    # Load custom marshal format. It's a string for backwards (RubyGems
+    # 1.3.5 and earlier) compatibility.
 
-      ##
-      # A version is considered a prerelease if it contains a letter.
+    def marshal_load array
+      initialize array[0]
+    end
 
-      def prerelease?
-        @prerelease ||= @version =~ /[a-zA-Z]/
-      end
+    def yaml_initialize(tag, map) # :nodoc:
+      @version = map['version']
+      @segments = nil
+      @hash = nil
+    end
 
-      def pretty_print(q) # :nodoc:
-        q.text "Gem::Version.new(#{version.inspect})"
-      end
+    def to_yaml_properties # :nodoc:
+      ["@version"]
+    end
 
-      ##
-      # The release for this version (e.g. 1.2.0.a -> 1.2.0).
-      # Non-prerelease versions return themselves.
+    def encode_with coder # :nodoc:
+      coder.add 'version', @version
+    end
 
-      def release
-        return self unless prerelease?
+    ##
+    # A version is considered a prerelease if it contains a letter.
 
-        segments = self.segments.dup
-        segments.pop while segments.any? { |s| String === s }
-        self.class.new segments.join('.')
+    def prerelease?
+      unless instance_variable_defined? :@prerelease
+        @prerelease = !!(@version =~ /[a-zA-Z]/)
       end
+      @prerelease
+    end
 
-      def segments # :nodoc:
-
-        # segments is lazy so it can pick up version values that come from
-        # old marshaled versions, which don't go through marshal_load.
+    def pretty_print q # :nodoc:
+      q.text "Gem::Version.new(#{version.inspect})"
+    end
 
-        @segments ||= @version.scan(/[0-9]+|[a-z]+/i).map do |s|
-          /^\d+$/ =~ s ? s.to_i : s
-        end
-      end
+    ##
+    # The release for this version (e.g. 1.2.0.a -> 1.2.0).
+    # Non-prerelease versions return themselves.
+
+    def release
+      @release ||= if prerelease?
+                     segments = self.segments
+                     segments.pop while segments.any? { |s| String === s }
+                     self.class.new segments.join('.')
+                   else
+                     self
+                   end
+    end
 
-      ##
-      # A recommended version for use with a ~> Requirement.
+    def segments # :nodoc:
+      _segments.dup
+    end
 
-      def spermy_recommendation
-        segments = self.segments.dup
+    ##
+    # A recommended version for use with a ~> Requirement.
 
-        segments.pop    while segments.any? { |s| String === s }
-        segments.pop    while segments.size > 2
-        segments.push 0 while segments.size < 2
+    def approximate_recommendation
+      segments = self.segments
 
-        "~> #{segments.join(".")}"
-      end
+      segments.pop    while segments.any? { |s| String === s }
+      segments.pop    while segments.size > 2
+      segments.push 0 while segments.size < 2
 
-      ##
-      # Compares this version with +other+ returning -1, 0, or 1 if the
-      # other version is larger, the same, or smaller than this
-      # one. Attempts to compare to something that's not a
-      # <tt>Gem::Version</tt> return +nil+.
+      "~> #{segments.join(".")}"
+    end
 
-      def <=>(other)
-        return unless Gem::Version === other
-        return 0 if @version == other.version
+    ##
+    # Compares this version with +other+ returning -1, 0, or 1 if the
+    # other version is larger, the same, or smaller than this
+    # one. Attempts to compare to something that's not a
+    # <tt>Gem::Version</tt> return +nil+.
 
-        lhsegments = segments
-        rhsegments = other.segments
+    def <=> other
+      return unless Gem::Version === other
+      return 0 if @version == other._version
 
-        lhsize = lhsegments.size
-        rhsize = rhsegments.size
-        limit  = (lhsize > rhsize ? lhsize : rhsize) - 1
+      lhsegments = _segments
+      rhsegments = other._segments
 
-        i = 0
+      lhsize = lhsegments.size
+      rhsize = rhsegments.size
+      limit  = (lhsize > rhsize ? lhsize : rhsize) - 1
 
-        while i <= limit
-          lhs, rhs = lhsegments[i] || 0, rhsegments[i] || 0
-          i += 1
+      i = 0
 
-          next      if lhs == rhs
-          return -1 if String  === lhs && Numeric === rhs
-          return  1 if Numeric === lhs && String  === rhs
+      while i <= limit
+        lhs, rhs = lhsegments[i] || 0, rhsegments[i] || 0
+        i += 1
 
-          return lhs <=> rhs
-        end
+        next      if lhs == rhs
+        return -1 if String  === lhs && Numeric === rhs
+        return  1 if Numeric === lhs && String  === rhs
 
-        0
+        return lhs <=> rhs
       end
+
+      return 0
     end
 
+    protected
+
+    def _version
+      @version
+    end
+
+    def _segments
+      # segments is lazy so it can pick up version values that come from
+      # old marshaled versions, which don't go through marshal_load.
+      # since this version object is cached in @@all, its @segments should be frozen
+
+      @segments ||= @version.scan(/[0-9]+|[a-z]+/i).map do |s|
+        /^\d+$/ =~ s ? s.to_i : s
+      end.freeze
+    end
   end
 end

data/lib/cocoapods-core/vendor.rb

@@ -1,9 +1,7 @@
 module Pod
-
   # Namespaces the vendored modules.
   #
   module Vendor
-
     # Namespaces the classes of RubyGems used by CocoaPods.
     #
     # CocoaPods needs to vendor RubyGems because OS X ships with `v1.3.6` which
@@ -11,7 +9,7 @@ module Pod
     #
     # E.g. https://github.com/CocoaPods/CocoaPods/issues/398
     #
-    # The following classes are copied from RubyGems `v1.8.24`. The changes
+    # The following classes are copied from RubyGems `v2.6.3`. The changes
     # performed to the source files are the following:
     #
     # - Namespaced in `Pod::Vendor`
@@ -19,7 +17,6 @@ module Pod
     # - replaced `::Gem` with `Pod::Vendor::Gem`
     #
     module Gem
-
       require 'cocoapods-core/vendor/version'
       require 'cocoapods-core/vendor/requirement'
 
@@ -48,7 +45,6 @@ module Pod
       # CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
       # TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
       # SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
     end
   end
 end