cocoapods-core 0.30.0 → 1.15.2

data/lib/cocoapods-core/version.rb

@@ -1,5 +1,4 @@
 module Pod
-
   # The Version class stores information about the version of a
   # {Specification}.
   #
@@ -31,54 +30,30 @@ module Pod
   # 4. 0.9
   #
   class Version < Pod::Vendor::Gem::Version
-
-    # Override the constants defined by the superclass to add Semantic
-    # Versioning prerelease support (with a dash). E.g.: 1.0.0-alpha1
+    # Override the constants defined by the superclass to add:
+    # - Semantic Versioning prerelease support (with a dash). E.g.: 1.0.0-alpha1
+    # - Semantic Versioning metadata support (with a +) E.g: 1.0.0+96ef7ed
     #
     # For more info, see: http://semver.org
     #
-    VERSION_PATTERN = '[0-9]+(\.[0-9a-zA-Z\-]+)*'
+    METADATA_PATTERN = '(\+[0-9a-zA-Z\-\.]+)'
+    VERSION_PATTERN = "[0-9]+(\\.[0-9a-zA-Z\\-]+)*#{METADATA_PATTERN}?"
     ANCHORED_VERSION_PATTERN = /\A\s*(#{VERSION_PATTERN})*\s*\z/
 
-    # @return [Bool] whether the version represents the `head` of repository.
-    #
-    attr_accessor :head
-    alias_method  :head?, :head
-
     # @param  [String,Version] version
     #         A string representing a version, or another version.
     #
-    # @todo   The `from` part of the regular expression should be remove in
-    #         CocoaPods 1.0.0.
-    #
     def initialize(version)
-      if version.is_a?(Version) && version.head?
-        version = version.version
-        @head = true
-      elsif version.is_a?(String) && version =~ /HEAD (based on|from) (.*)/
-        version = Regexp.last_match[2]
-        @head = true
-      end
-      super(version)
+      raise ArgumentError, "Malformed version number string #{version}" unless
+        self.class.correct?(version)
+
+      @version = version.to_s.strip
     end
 
     # An instance that represents version 0.
     #
     ZERO = new('0')
 
-    # @return [String] a string representation that indicates if the version is
-    #         head.
-    #
-    # @note   The raw version string is still accessible with the {#version}
-    #         method.
-    #
-    # @todo   Adding the head information to the string representation creates
-    #         issues (see Dependency#requirement).
-    #
-    def to_s
-      head? ? "HEAD based on #{super}" : super
-    end
-
     # @return [String] a string representation suitable for debugging.
     #
     def inspect
@@ -93,10 +68,12 @@ module Pod
     #         For more info, see: http://semver.org
     #
     def prerelease?
-      @prerelease ||= @version =~ /[a-zA-Z\-]/
+      return @prerelease if defined?(@prerelease)
+      comparable_version = @version.sub(/#{METADATA_PATTERN}$/, '')
+      @prerelease = comparable_version =~ /[a-zA-Z\-]/
     end
 
-    # @return [Bool] Whether a string representation is correct.
+    # @return [Boolean] Whether a string representation is correct.
     #
     def self.correct?(version)
       version.to_s =~ ANCHORED_VERSION_PATTERN
@@ -106,10 +83,10 @@ module Pod
 
     # @!group Semantic Versioning
 
-    SEMVER_PATTERN = '[0-9]+(\.[0-9]+(\.[0-9]+(-[0-9A-Za-z\-\.]+)?)?)?'
+    SEMVER_PATTERN = "[0-9]+(\\.[0-9]+(\\.[0-9]+(-[0-9A-Za-z\\-\\.]+)?#{METADATA_PATTERN}?)?)?"
     ANCHORED_SEMANTIC_VERSION_PATTERN = /\A\s*(#{SEMVER_PATTERN})*\s*\z/
 
-    # @return [Bool] Whether the version conforms to the Semantic Versioning
+    # @return [Boolean] Whether the version conforms to the Semantic Versioning
     #         specification (2.0.0-rc.1).
     #
     # @note   This comparison is lenient.
@@ -123,22 +100,140 @@ module Pod
     # @return [Fixnum] The semver major identifier.
     #
     def major
-      segments[0]
+      numeric_segments[0].to_i
     end
 
     # @return [Fixnum] The semver minor identifier.
     #
     def minor
-      segments[1] || 0
+      numeric_segments[1].to_i
     end
 
     # @return [Fixnum] The semver patch identifier.
     #
     def patch
-      segments[2] || 0
+      numeric_segments[2].to_i
     end
 
-    #-------------------------------------------------------------------------#
+    # Compares the versions for sorting.
+    #
+    # @param  [Version] other
+    #         The other version to compare.
+    #
+    # @return [Fixnum] -1, 0, or +1 depending on whether the receiver is less
+    #         than, equal to, or greater than other.
+    #
+    # @note   Attempts to compare something that's not a {Version} return nil
+    #
+    def <=>(other)
+      comparison = compare_segments(other)
+      comparison == 0 ? version <=> other.version : comparison
+    end
 
+    # @private
+    #
+    # Compares the versions for equality.
+    #
+    # @param  [Version] other
+    #         The other version to compare.
+    #
+    # @return [Boolean] whether the receiver is equal to other.
+    #
+    # @note   Attempts to compare something that's not a {Version} return nil
+    #
+    def ==(other)
+      compare_segments(other) == 0
+    end
+
+    # @private
+    #
+    # Compares the versions for equality.
+    #
+    # @param  [Version] other
+    #         The other version to compare.
+    #
+    # @return [Boolean] whether the receiver is greater than or equal to other.
+    #
+    # @note   Attempts to compare something that's not a {Version} return nil
+    #
+    def >=(other)
+      comparison = compare_segments(other)
+      comparison >= 0
+    end
+
+    # @private
+    #
+    # Compares the versions for equality.
+    #
+    # @param  [Version] other
+    #         The other version to compare.
+    #
+    # @return [Boolean] whether the receiver is less than or equal to other.
+    #
+    # @note   Attempts to compare something that's not a {Version} return nil
+    #
+    def <=(other)
+      comparison = compare_segments(other)
+      comparison <= 0
+    end
+
+    protected
+
+    # This overrides the Gem::Version implementation of `_segments` to drop the
+    # metadata from comparisons as per http://semver.org/#spec-item-10
+    #
+    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.sub(/#{METADATA_PATTERN}$/, '').scan(/[0-9]+|[a-z]+/i).map do |s|
+        /^\d+$/ =~ s ? s.to_i : s
+      end.freeze
+    end
+
+    def numeric_segments
+      @numeric_segments ||= segments.take_while { |s| s.is_a?(Numeric) }.reverse_each.drop_while { |s| s == 0 }.reverse
+    end
+
+    def prerelease_segments
+      @prerelease_segments ||= segments.drop_while { |s| s.is_a?(Numeric) }
+    end
+
+    def compare_segments(other)
+      return unless other.is_a?(Pod::Version)
+      return 0 if @version == other.version
+
+      compare = proc do |segments, other_segments, is_pre_release|
+        limit = [segments.size, other_segments.size].max
+
+        0.upto(limit) do |i|
+          lhs = segments[i]
+          rhs = other_segments[i]
+
+          next if lhs == rhs
+          # If it's pre-release and the first segment, then
+          # this is a special case because a segment missing
+          # means that one is not a pre-release version
+          if is_pre_release && i == 0
+            return 1 if lhs.nil?
+            return -1 if rhs.nil?
+          else
+            return -1 if lhs.nil?
+            return  1 if rhs.nil?
+          end
+
+          if comparison = lhs <=> rhs
+            return comparison
+          end
+        end
+      end
+
+      compare[numeric_segments, other.numeric_segments, false]
+      compare[prerelease_segments, other.prerelease_segments, true]
+      0
+    end
+
+    #-------------------------------------------------------------------------#
   end
 end

data/lib/cocoapods-core/yaml_helper.rb

@@ -0,0 +1,334 @@
+require 'yaml'
+
+module Pod
+  # Converts objects to their YAML representation.
+  #
+  # This class was created for the need having control on how the YAML is
+  # representation is generated. In details it provides:
+  #
+  # - sorting for hashes in ruby 1.8.x
+  # - ability to hint the sorting of the keys of a dictionary when converting
+  #   it. In this case the keys are also separated by an additional new line
+  #   feed for readability.
+  #
+  # @note This class misses important features necessary for a correct YAML
+  #       serialization and thus it is safe to use only for the Lockfile.
+  #       The missing features include:
+  #       - Strings are never quoted even when ambiguous.
+  #
+  # @todo Remove any code required solely for Ruby 1.8.x.
+  #
+  class YAMLHelper
+    class << self
+      # Returns the YAML representation of the given object. If the given object
+      # is a Hash, it accepts an optional hint for sorting the keys.
+      #
+      # @param  [String, Symbol, Array, Hash] object
+      #         the object to convert
+      #
+      # @param  [Array] hash_keys_hint
+      #         an array to use as a hint for sorting the keys of the object to
+      #         convert if it is a hash.
+      #
+      # @return [String] the YAML representation of the given object.
+      #
+      def convert(value)
+        result = process_according_to_class(value)
+        result << "\n"
+      end
+
+      def convert_hash(value, hash_keys_hint, line_separator = "\n")
+        result = process_hash(value, hash_keys_hint, line_separator)
+        result << "\n"
+      end
+
+      # Loads a YAML string and provide more informative
+      # error messages in special cases like merge conflict.
+      #
+      # @param [String] yaml_string
+      #        The YAML String to be loaded
+      #
+      # @param [Pathname] file_path
+      #        The (optional) file path to be used for read for the YAML file
+      #
+      # @return [Hash, Array] the Ruby YAML representaton
+      #
+      def load_string(yaml_string, file_path = nil)
+        YAML.safe_load(yaml_string, :permitted_classes => [Date, Time, Symbol])
+      rescue
+        if yaml_has_merge_error?(yaml_string)
+          raise Informative, yaml_merge_conflict_msg(yaml_string, file_path)
+        else
+          raise Informative, yaml_parsing_error_msg(yaml_string, file_path)
+        end
+      end
+
+      # Loads a YAML file and leans on the #load_string imp
+      # to do error detection
+      #
+      # @param [Pathname] file_path
+      #        The file path to be used for read for the YAML file
+      #
+      # @return [Hash, Array] the Ruby YAML representaton
+      #
+      def load_file(file_path)
+        load_string(File.read(file_path), file_path)
+      end
+
+      #-----------------------------------------------------------------------#
+
+      private
+
+      # Implementation notes:
+      #
+      # - each of the methods returns a YAML partial without an ending new
+      #   line.
+      # - if a partial needs to be indented is responsibility of the method
+      #   using it.
+      #
+      # ---
+
+      # @!group Private Helpers
+
+      # @return [String] the YAML representation of the given object.
+      #
+      def process_according_to_class(value, hash_keys_hint = nil)
+        case value
+        when Array      then process_array(value)
+        when Hash       then process_hash(value, hash_keys_hint)
+        when String     then process_string(value)
+        else                 YAML.dump(value, :line_width => 2**31 - 1).sub(/\A---/, '').sub(/[.]{3}\s*\Z/, '')
+        end.strip
+      end
+
+      # Converts an array to YAML after sorting it.
+      #
+      # @param  [Array] array
+      #         the array to convert.
+      #
+      # @return [String] the YAML representation of the given object.
+      #
+      def process_array(array)
+        return '[]' if array.empty?
+
+        result = sorted_array(array).map do |array_value|
+          processed = process_according_to_class(array_value)
+          case array_value
+          when Array, Hash
+            if array_value.size > 1
+              processed = processed.gsub(/^.*/).to_a
+              head = processed.shift
+              processed.map { |s| "  #{s}" }.prepend(head).join("\n")
+            else
+              processed
+            end
+          else
+            processed
+          end
+        end
+        "- #{result.join("\n- ").strip}"
+      end
+
+      # Converts a hash to YAML after sorting its keys. Optionally accepts a
+      # hint for sorting the keys.
+      #
+      # @note   If a hint for sorting the keys is provided the array is assumed
+      #         to be the root object and the keys are separated by an
+      #         additional new line feed for readability.
+      #
+      # @note   If the value of a given key is a String it displayed inline,
+      #         otherwise it is displayed below and indented.
+      #
+      # @param  [Hash] hash
+      #         the hash to convert.
+      #
+      # @return [String] the YAML representation of the given object.
+      #
+      def process_hash(hash, hash_keys_hint = nil, line_separator = "\n")
+        return '{}' if hash.empty?
+
+        keys = sorted_array_with_hint(hash.keys, hash_keys_hint)
+        key_lines = keys.map do |key|
+          key_value = hash[key]
+          processed = process_according_to_class(key_value)
+          processed_key = process_according_to_class(key)
+          case key_value
+          when Hash, Array
+            key_partial_yaml = processed.lines.map { |line| "  #{line}" } * ''
+            "#{processed_key}:\n#{key_partial_yaml}"
+          else
+            "#{processed_key}: #{processed}"
+          end
+        end
+        key_lines * line_separator
+      end
+
+      # Check for merge errors in a YAML string.
+      #
+      # @param [String] yaml_string
+      #        A YAML string to evaluate
+      #
+      # @return If a merge error was detected or not.
+      #
+      def yaml_has_merge_error?(yaml_string)
+        yaml_string.include?('<<<<<<< HEAD')
+      end
+
+      # Error message describing that a merge conflict was found
+      # while parsing the YAML.
+      #
+      # @param [String] yaml
+      #        Offending YAML
+      #
+      # @param [Pathname] path
+      #        The (optional) offending path
+      #
+      # @return [String] The Error Message
+      #
+      def yaml_merge_conflict_msg(yaml, path = nil)
+        err = 'ERROR: Parsing unable to continue due '
+        err += "to merge conflicts present in:\n"
+        err += "the file located at #{path}\n" if path
+        err + "#{yaml}"
+      end
+
+      # Error message describing a general error took happened
+      # while parsing the YAML.
+      #
+      # @param [String] yaml
+      #        Offending YAML
+      #
+      # @param [Pathname] path
+      #        The (optional) offending path
+      #
+      # @return [String] The Error Message
+      #
+      def yaml_parsing_error_msg(yaml, path = nil)
+        err = 'ERROR: Parsing unable to continue due '
+        err += "to parsing error:\n"
+        err += "contained in the file located at #{path}\n" if path
+        err + "#{yaml}"
+      end
+
+      #-----------------------------------------------------------------------#
+
+      # @!group Array Sorting
+
+      # Sorts an array using another one as a sort hint. All the values of the
+      # hint which appear in the array will be returned respecting the order in
+      # the hint. If any other key is present in the original array they are
+      # sorted using the {#sorted_array} method.
+      #
+      # @param  [Array] array
+      #         The array which needs to be sorted.
+      #
+      # @param  [Array] sort_hint
+      #         The array which should be used to sort the keys.
+      #
+      # @return [Array] The sorted Array.
+      #
+      def sorted_array_with_hint(array, sort_hint)
+        if sort_hint
+          hinted = sort_hint & array
+          remaining = array - sort_hint
+          hinted + sorted_array(remaining)
+        else
+          sorted_array(array)
+        end
+      end
+
+      public
+
+      # Sorts an array according to the string representation of it values.
+      # This method allows to sort arrays which contains strings or hashes.
+      #
+      # @note   If the value contained in the array is another Array or a Hash
+      #         the first value of the collection is used for sorting, as this
+      #         method is more useful, for arrays which contains a collection
+      #         composed by one object.
+      #
+      # @todo   This stuff is here only because the Lockfile intermixes strings
+      #         and hashes for the `PODS` key. The Lockfile should be more
+      #         consistent.
+      #
+      # @return [Array] The sorted array.
+      #
+      def sorted_array(array)
+        array.each_with_index.sort_by do |element, index|
+          [sorting_string(element), index]
+        end.map(&:first)
+      end
+
+      private
+
+      # Returns the string representation of a value useful for sorting.
+      #
+      # @param  [String, Symbol, Array, Hash] value
+      #         The value which needs to be sorted
+      #
+      # @return [String] A string useful to compare the value with other ones.
+      #
+      def sorting_string(value)
+        return '' unless value
+        case value
+        when String then value.downcase
+        when Symbol then sorting_string(value.to_s)
+        when Array  then sorting_string(value.first)
+        when Hash   then value.keys.map { |key| key.to_s.downcase }.sort.first
+        else             raise ArgumentError, "Cannot sort #{value.inspect}"
+        end
+      end
+
+      RESOLVED_TAGS = Regexp.union(
+        'null', 'Null', 'NULL', '~', '', # resolve to null
+        'true', 'True', 'TRUE', 'false', 'False', 'FALSE', # bool
+        'yes', 'Yes', 'YES', 'no', 'No', 'NO', # yes/no
+        'on', 'On', 'ON', 'off', 'Off', 'OFF', # no/off
+        Regexp.new(%{
+          [0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9] # (ymd)
+         |[0-9][0-9][0-9][0-9] # (year)
+          -[0-9][0-9]? # (month)
+          -[0-9][0-9]? # (day)
+          ([Tt]|[ \t]+)[0-9][0-9]? # (hour)
+          :[0-9][0-9] # (minute)
+          :[0-9][0-9] # (second)
+          (\.[0-9]*)? # (fraction)
+          (([ \t]*)(Z|[-+][0-9][0-9]?(:[0-9][0-9])?))? # (time zone)
+        }, Regexp::EXTENDED), # https://yaml.org/type/timestamp.html
+        /[-+]?[0-9]+/, # base 10 int
+        /00[0-7]+/, # base 8 int
+        /0x[0-9a-fA-F]+/, # base 16 int
+        /[-+]?(\.[0-9]+|[0-9]+(\.[0-9]*)?)([eE][-+]?[0-9]+)?/, # float
+        /[-+]?\.(inf|Inf|INF)/, # infinity
+        /\.(nan|NaN|NAN)/ # NaN
+      )
+      private_constant :RESOLVED_TAGS
+
+      INDICATOR_START_CHARS = %w(- ? : , [ ] { } # & * ! | > ' " % @ `).freeze
+      INDICATOR_START = /\A#{Regexp.union(INDICATOR_START_CHARS)}/.freeze
+      private_constant :INDICATOR_START_CHARS, :INDICATOR_START
+
+      RESOLVED_TAGS_PATTERN = /\A#{Regexp.union(RESOLVED_TAGS)}\z/.freeze
+      private_constant :RESOLVED_TAGS_PATTERN
+
+      VALID_PLAIN_SCALAR_STRING = %r{\A
+        [\w&&[^#{INDICATOR_START_CHARS}]] # valid first character
+        [\w/\ \(\)~<>=\.:`,-]* # all characters allowed after the first one
+      \z}ox.freeze
+      private_constant :VALID_PLAIN_SCALAR_STRING
+
+      def process_string(string)
+        case string
+        when RESOLVED_TAGS_PATTERN
+          "'#{string}'"
+        when /\A\s*\z/, INDICATOR_START, /:\z/
+          string.inspect
+        when VALID_PLAIN_SCALAR_STRING
+          string
+        else
+          string.inspect
+        end
+      end
+    end
+  end
+end

data/lib/cocoapods-core.rb

@@ -1,20 +1,22 @@
 # The Pod modules name-spaces all the classes of CocoaPods.
 #
 module Pod
-
   require 'cocoapods-core/gem_version'
 
   # Indicates a runtime error **not** caused by a bug.
   #
   class PlainInformative < StandardError; end
 
-  # Indicates an user error.
+  # Indicates a user error.
   #
   class Informative < PlainInformative; end
 
   require 'pathname'
   require 'cocoapods-core/vendor'
 
+  require 'active_support'
+  require 'active_support/core_ext'
+
   autoload :Version,        'cocoapods-core/version'
   autoload :Requirement,    'cocoapods-core/requirement'
   autoload :Dependency,     'cocoapods-core/dependency'
@@ -22,16 +24,20 @@ module Pod
   autoload :CoreUI,         'cocoapods-core/core_ui'
   autoload :DSLError,       'cocoapods-core/standard_error'
   autoload :GitHub,         'cocoapods-core/github'
+  autoload :HTTP,           'cocoapods-core/http'
   autoload :Lockfile,       'cocoapods-core/lockfile'
+  autoload :Metrics,        'cocoapods-core/metrics'
   autoload :Platform,       'cocoapods-core/platform'
   autoload :Podfile,        'cocoapods-core/podfile'
   autoload :Source,         'cocoapods-core/source'
+  autoload :CDNSource,      'cocoapods-core/cdn_source'
+  autoload :TrunkSource,    'cocoapods-core/trunk_source'
   autoload :Specification,  'cocoapods-core/specification'
   autoload :StandardError,  'cocoapods-core/standard_error'
-  autoload :YAMLConverter,  'cocoapods-core/yaml_converter'
+  autoload :YAMLHelper,     'cocoapods-core/yaml_helper'
+  autoload :BuildType,      'cocoapods-core/build_type'
 
   # TODO: Fix
   #
   Spec = Specification
-
 end