cocoapods-core 0.30.0 → 1.15.2

data/lib/cocoapods-core/standard_error.rb

@@ -1,5 +1,4 @@
 module Pod
-
   # Namespaces all the errors raised by CocoaPods.
   #
   class StandardError < ::StandardError; end
@@ -10,7 +9,6 @@ module Pod
   # contents of the line that raised the exception.
   #
   class DSLError < Informative
-
     # @return [String] the description that should be presented to the user.
     #
     attr_reader :description
@@ -19,18 +17,28 @@ module Pod
     #
     attr_reader :dsl_path
 
-    # @return [Exception] the backtrace of the exception raised by the
+    # @return [Exception] the exception raised by the
     #         evaluation of the dsl file.
     #
-    attr_reader :backtrace
+    attr_reader :underlying_exception
 
-    # @param [Exception] backtrace @see backtrace
+    # @param [Exception] underlying_exception @see underlying_exception
     # @param [String]    dsl_path  @see dsl_path
     #
-    def initialize(description, dsl_path, backtrace)
-      @description = description
-      @dsl_path    = dsl_path
-      @backtrace   = backtrace
+    def initialize(description, dsl_path, underlying_exception, contents = nil)
+      @description          = description
+      @dsl_path             = dsl_path
+      @underlying_exception = underlying_exception
+      @contents             = contents
+    end
+
+    # @return [String] the contents of the DSL that cause the exception to
+    #         be raised.
+    #
+    def contents
+      @contents ||= begin
+        dsl_path && File.exist?(dsl_path) && File.read(dsl_path)
+      end
     end
 
     # The message of the exception reports the content of podspec for the
@@ -52,36 +60,49 @@ module Pod
     # @return [String] the message of the exception.
     #
     def message
-      unless @message
-        m = "\n[!] "
-        m << description
-        m << ". Updating CocoaPods might fix the issue.\n"
+      @message ||= begin
+        trace_line, description = parse_line_number_from_description
+
+        m = "\n[!] #{description}.\n"
         m = m.red if m.respond_to?(:red)
 
-        return m unless backtrace && dsl_path && File.exist?(dsl_path)
+        backtrace = underlying_exception.backtrace
+        return m unless backtrace && dsl_path && contents
 
-        trace_line = backtrace.find { |l| l.include?(dsl_path.to_s) }
+        trace_line = backtrace.find { |l| l.include?(dsl_path.to_s) } || trace_line
         return m unless trace_line
         line_numer = trace_line.split(':')[1].to_i - 1
         return m unless line_numer
-        lines      = File.readlines(dsl_path.to_s)
-        indent     = " #  "
-        indicator  = indent.dup.gsub("#", ">")
+
+        lines      = contents.lines
+        indent     = ' #  '
+        indicator  = indent.tr('#', '>')
         first_line = (line_numer.zero?)
         last_line  = (line_numer == (lines.count - 1))
 
         m << "\n"
         m << "#{indent}from #{trace_line.gsub(/:in.*$/, '')}\n"
         m << "#{indent}-------------------------------------------\n"
-        m << "#{indent}#{    lines[line_numer - 1] }" unless first_line
-        m << "#{indicator}#{ lines[line_numer] }"
-        m << "#{indent}#{    lines[line_numer + 1] }" unless last_line
+        m << "#{indent}#{lines[line_numer - 1]}" unless first_line
+        m << "#{indicator}#{lines[line_numer]}"
+        m << "#{indent}#{lines[line_numer + 1]}" unless last_line
         m << "\n" unless m.end_with?("\n")
         m << "#{indent}-------------------------------------------\n"
-        m << ""
-        @message = m
       end
-      @message
+    end
+
+    private
+
+    def parse_line_number_from_description
+      description = self.description
+      if dsl_path && description =~ /((#{Regexp.quote File.expand_path(dsl_path)}|#{Regexp.quote dsl_path.to_s}):\d+)/
+        trace_line = Regexp.last_match[1]
+        description = description.sub(/#{Regexp.quote trace_line}:\s*/, '')
+        if description =~ /^\s*\^\z/
+          description = description.lines[0..-3].join.chomp
+        end
+      end
+      [trace_line, description]
     end
   end
 end

data/lib/cocoapods-core/trunk_source.rb

@@ -0,0 +1,14 @@
+module Pod
+  class TrunkSource < CDNSource
+    # On-disk master repo name
+    TRUNK_REPO_NAME = 'trunk'.freeze
+
+    # Remote CDN repo URL
+    TRUNK_REPO_URL = 'https://cdn.cocoapods.org/'.freeze
+
+    def url
+      @url ||= TRUNK_REPO_URL
+      super
+    end
+  end
+end

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

@@ -1,35 +1,50 @@
+# frozen_string_literal: true
 module Pod::Vendor
 
   # require "rubygems/version"
+  # require "rubygems/deprecate"
+
+  # If we're being loaded after yaml was already required, then
+  # load our yaml + workarounds now.
+  # Gem.load_yaml if defined? ::YAML
 
   ##
   # A Requirement is a set of one or more version restrictions. It supports a
   # few (<tt>=, !=, >, <, >=, <=, ~></tt>) different restriction operators.
-
-  # REFACTOR: The fact that a requirement is singular or plural is kind of
-  # awkward. Is Requirement the right name for this? Or should it be one
-  # [op, number] pair, and we call the list of requirements something else?
-  # Since a Requirement is held by a Dependency, maybe this should be made
-  # singular and the list aspect should be pulled up into Dependency?
-
-  # require "rubygems/version"
-  # require "rubygems/deprecate"
+  #
+  # See Gem::Version for a description on how versions and requirements work
+  # together in RubyGems.
 
   class Gem::Requirement
-    include Comparable
-
     OPS = { #:nodoc:
       "="  =>  lambda { |v, r| v == r },
       "!=" =>  lambda { |v, r| v != r },
-      ">"  =>  lambda { |v, r| v > r  },
-      "<"  =>  lambda { |v, r| v < r  },
+      ">"  =>  lambda { |v, r| v >  r },
+      "<"  =>  lambda { |v, r| v <  r },
       ">=" =>  lambda { |v, r| v >= r },
       "<=" =>  lambda { |v, r| v <= r },
       "~>" =>  lambda { |v, r| v >= r && v.release < r.bump }
     }
 
+    SOURCE_SET_REQUIREMENT = Struct.new(:for_lockfile).new "!" # :nodoc:
+
     quoted  = OPS.keys.map { |k| Regexp.quote k }.join "|"
-    PATTERN = /\A\s*(#{quoted})?\s*(#{Gem::Version::VERSION_PATTERN})\s*\z/
+    PATTERN_RAW = "\\s*(#{quoted})?\\s*(#{Gem::Version::VERSION_PATTERN})\\s*" # :nodoc:
+
+    ##
+    # A regular expression that matches a requirement
+
+    PATTERN = /\A#{PATTERN_RAW}\z/
+
+    ##
+    # The default requirement matches any version
+
+    DefaultRequirement = [">=", Gem::Version.new(0)]
+
+    ##
+    # Raised when a bad requirement is encountered
+
+    class BadRequirementError < ArgumentError; end
 
     ##
     # Factory method to create a Gem::Requirement object.  Input may be
@@ -38,12 +53,14 @@ module Pod::Vendor
     # If the input is "weird", the default version requirement is
     # returned.
 
-    def self.create(input)
+    def self.create input
       case input
       when Gem::Requirement then
         input
       when Gem::Version, Array then
         new input
+      when '!' then
+        source_set
       else
         if input.respond_to? :to_str then
           new [input.to_str]
@@ -55,15 +72,18 @@ module Pod::Vendor
 
     ##
     # A default "version requirement" can surely _only_ be '>= 0'.
-    #--
-    # This comment once said:
-    #
-    # "A default "version requirement" can surely _only_ be '> 0'."
 
     def self.default
       new '>= 0'
     end
 
+    ###
+    # A source set requirement, used for Gemfiles and lockfiles
+
+    def self.source_set # :nodoc:
+      SOURCE_SET_REQUIREMENT
+    end
+
     ##
     # Parse +obj+, returning an <tt>[op, version]</tt> pair. +obj+ can
     # be a String or a Gem::Version.
@@ -72,18 +92,22 @@ module Pod::Vendor
     # specification, like <tt>">= 1.2"</tt>, or a simple version number,
     # like <tt>"1.2"</tt>.
     #
-    #     parse("> 1.0")                 # => [">", "1.0"]
-    #     parse("1.0")                   # => ["=", "1.0"]
-    #     parse(Gem::Version.new("1.0")) # => ["=,  "1.0"]
+    #     parse("> 1.0")                 # => [">", Gem::Version.new("1.0")]
+    #     parse("1.0")                   # => ["=", Gem::Version.new("1.0")]
+    #     parse(Gem::Version.new("1.0")) # => ["=,  Gem::Version.new("1.0")]
 
-    def self.parse(obj)
+    def self.parse obj
       return ["=", obj] if Gem::Version === obj
 
       unless PATTERN =~ obj.to_s
-        raise ArgumentError, "Illformed requirement [#{obj.inspect}]"
+        raise BadRequirementError, "Illformed requirement [#{obj.inspect}]"
       end
 
-      [Regexp.last_match[1] || "=", Gem::Version.new(Regexp.last_match[2])]
+      if $1 == ">=" && $2 == "0"
+        DefaultRequirement
+      else
+        [$1 || "=", Gem::Version.new($2)]
+      end
     end
 
     ##
@@ -98,18 +122,62 @@ module Pod::Vendor
     # requirements are ignored. An empty set of +requirements+ is the
     # same as <tt>">= 0"</tt>.
 
-    def initialize(*requirements)
+    def initialize *requirements
       requirements = requirements.flatten
       requirements.compact!
       requirements.uniq!
 
-      requirements << ">= 0" if requirements.empty?
-      @none = (requirements == ">= 0")
-      @requirements = requirements.map! { |r| self.class.parse r }
+      if requirements.empty?
+        @requirements = [DefaultRequirement]
+      else
+        @requirements = requirements.map! { |r| self.class.parse r }
+      end
     end
 
+    ##
+    # Concatenates the +new+ requirements onto this requirement.
+
+    def concat new
+      new = new.flatten
+      new.compact!
+      new.uniq!
+      new = new.map { |r| self.class.parse r }
+
+      @requirements.concat new
+    end
+
+    ##
+    # Formats this requirement for use in a Gem::RequestSet::Lockfile.
+
+    def for_lockfile # :nodoc:
+      return if [DefaultRequirement] == @requirements
+
+      list = requirements.sort_by { |_, version|
+        version
+      }.map { |op, version|
+        "#{op} #{version}"
+      }.uniq
+
+      " (#{list.join ', '})"
+    end
+
+    ##
+    # true if this gem has no requirements.
+
     def none?
-      @none ||= (to_s == ">= 0")
+      if @requirements.size == 1
+        @requirements[0] == DefaultRequirement
+      else
+        false
+      end
+    end
+
+    ##
+    # true if the requirement is for only an exact version
+
+    def exact?
+      return false unless @requirements.size == 1
+      @requirements[0][0] == "="
     end
 
     def as_list # :nodoc:
@@ -117,7 +185,7 @@ module Pod::Vendor
     end
 
     def hash # :nodoc:
-      requirements.hash
+      requirements.sort.hash
     end
 
     def marshal_dump # :nodoc:
@@ -126,7 +194,7 @@ module Pod::Vendor
       [@requirements]
     end
 
-    def marshal_load(array) # :nodoc:
+    def marshal_load array # :nodoc:
       @requirements = array[0]
 
       fix_syck_default_key_in_requirements
@@ -134,36 +202,51 @@ module Pod::Vendor
 
     def yaml_initialize(tag, vals) # :nodoc:
       vals.each do |ivar, val|
-      instance_variable_set "@#{ivar}", val
-    end
+        instance_variable_set "@#{ivar}", val
+      end
 
+      Gem.load_yaml
       fix_syck_default_key_in_requirements
     end
 
-    def init_with(coder) # :nodoc:
+    def init_with coder # :nodoc:
       yaml_initialize coder.tag, coder.map
     end
 
+    def to_yaml_properties # :nodoc:
+      ["@requirements"]
+    end
+
+    def encode_with coder # :nodoc:
+      coder.add 'requirements', @requirements
+    end
+
+    ##
+    # A requirement is a prerelease if any of the versions inside of it
+    # are prereleases
+
     def prerelease?
       requirements.any? { |r| r.last.prerelease? }
     end
 
-    def pretty_print(q) # :nodoc:
+    def pretty_print q # :nodoc:
       q.group 1, 'Gem::Requirement.new(', ')' do
-      q.pp as_list
-    end
+        q.pp as_list
+      end
     end
 
     ##
     # True if +version+ satisfies this Requirement.
 
-    def satisfied_by?(version)
+    def satisfied_by? version
+      raise ArgumentError, "Need a Gem::Version: #{version.inspect}" unless
+        Gem::Version === version
       # #28965: syck has a bug with unquoted '=' YAML.loading as YAML::DefaultKey
       requirements.all? { |op, rv| (OPS[op] || OPS["="]).call version, rv }
     end
 
-    alias_method :===, :satisfied_by?
-    alias_method :=~, :satisfied_by?
+    alias :=== :satisfied_by?
+    alias :=~ :satisfied_by?
 
     ##
     # True if the requirement will not always match the latest version.
@@ -171,20 +254,20 @@ module Pod::Vendor
     def specific?
       return true if @requirements.length > 1 # GIGO, > 1, > 2 is silly
 
-      not %w(> >=).include? @requirements.first.first # grab the operator
+      not %w[> >=].include? @requirements.first.first # grab the operator
     end
 
     def to_s # :nodoc:
       as_list.join ", "
     end
 
-    def <=>(other) # :nodoc:
-      to_s <=> other.to_s
+    def == other # :nodoc:
+      Gem::Requirement === other and to_s == other.to_s
     end
 
     private
 
-    def fix_syck_default_key_in_requirements
+    def fix_syck_default_key_in_requirements # :nodoc:
       Gem.load_yaml
 
       # Fixup the Syck DefaultKey bug
@@ -196,13 +279,10 @@ module Pod::Vendor
     end
   end
 
-  # :stopdoc:
-  # Gem::Version::Requirement is used in a lot of old YAML specs. It's aliased
-  # here for backwards compatibility. I'd like to remove this, maybe in RubyGems
-  # 2.0.
-
-  # ::Gem::Version::Requirement = ::Gem::Requirement
-  Gem::Version::Requirement = Gem::Requirement
-  # :startdoc:
+  class Gem::Version
+    # This is needed for compatibility with older yaml
+    # gemspecs.
 
+    Requirement = Gem::Requirement # :nodoc:
+  end
 end