cocoapods-core 0.17.0.rc1

data/lib/cocoapods-core/standard_error.rb

@@ -0,0 +1,84 @@
+module Pod
+
+  # Namespaces all the errors raised by CocoaPods.
+  #
+  class StandardError < ::StandardError; end
+
+  #-------------------------------------------------------------------------#
+
+  # Wraps an exception raised by a DSL file in order to show to the user the
+  # contents of the line that raised the exception.
+  #
+  class DSLError < StandardError
+
+    # @return [String] the description that should be presented to the user.
+    #
+    attr_reader :description
+
+    # @return [String] the path of the dsl file that raised the exception.
+    #
+    attr_reader :dsl_path
+
+    # @return [Exception] the backtrace of the exception raised by the
+    #         evaluation of the dsl file.
+    #
+    attr_reader :backtrace
+
+    # @param [Exception] backtrace @see backtrace
+    # @param [String]    dsl_path  @see dsl_path
+    #
+    def initialize(description, dsl_path, backtrace)
+      @description = description
+      @dsl_path    = dsl_path
+      @backtrace   = backtrace
+    end
+
+    # The message of the exception reports the content of podspec for the
+    # line that generated the original exception.
+    #
+    # @example Output
+    #
+    #   Invalid podspec at `RestKit.podspec` - undefined method
+    #   `exclude_header_search_paths=' for #<Pod::Specification for
+    #   `RestKit/Network (0.9.3)`>
+    #
+    #       from spec-repos/master/RestKit/0.9.3/RestKit.podspec:36
+    #       -------------------------------------------
+    #           # because it would break: #import <CoreData/CoreData.h>
+    #    >      ns.exclude_header_search_paths = 'Code/RestKit.h'
+    #         end
+    #       -------------------------------------------
+    #
+    # @return [String] the message of the exception.
+    #
+    def message
+      unless @message
+        m = description.dup
+
+        return m unless backtrace && dsl_path && File.exist?(dsl_path)
+
+        trace_line = backtrace.find { |l| l =~ /#{dsl_path}/ }
+        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("#", ">")
+        first_line = ( line_numer.zero? )
+        last_line  = ( line_numer == (lines.count - 1) )
+
+        m << "\n #\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 << "\n" unless m.end_with?("\n")
+        m << "#{indent}-------------------------------------------\n"
+        m << " #"
+        @message = m
+      end
+      @message
+    end
+  end
+end

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

@@ -0,0 +1,264 @@
+module Pod::Vendor
+
+  # require "rubygems/requirement"
+
+  ##
+  # The Dependency class holds a Gem name and a Gem::Requirement.
+
+  class Gem::Dependency
+
+    ##
+    # Valid dependency types.
+    #--
+    # When this list is updated, be sure to change
+    # Gem::Specification::CURRENT_SPECIFICATION_VERSION as well.
+
+    TYPES = [
+      :development,
+      :runtime,
+    ]
+
+    ##
+    # Dependency name or regular expression.
+
+    attr_accessor :name
+
+    ##
+    # Allows you to force this dependency to be a prerelease.
+
+    attr_writer :prerelease
+
+    ##
+    # Constructs a dependency with +name+ and +requirements+. The last
+    # argument can optionally be the dependency type, which defaults to
+    # <tt>:runtime</tt>.
+
+    def initialize name, *requirements
+      if Regexp === name then
+        msg = ["NOTE: Dependency.new w/ a regexp is deprecated.",
+               "Dependency.new called from #{Gem.location_of_caller.join(":")}"]
+        warn msg.join("\n") unless Gem::Deprecate.skip
+      end
+
+      type         = Symbol === requirements.last ? requirements.pop : :runtime
+      requirements = requirements.first if 1 == requirements.length # unpack
+
+      unless TYPES.include? type
+        raise ArgumentError, "Valid types are #{TYPES.inspect}, "
+        + "not #{type.inspect}"
+      end
+
+      @name        = name
+      @requirement = Gem::Requirement.create requirements
+      @type        = type
+      @prerelease  = false
+
+      # This is for Marshal backwards compatibility. See the comments in
+      # +requirement+ for the dirty details.
+
+      @version_requirements = @requirement
+    end
+
+    ##
+    # A dependency's hash is the XOR of the hashes of +name+, +type+,
+    # and +requirement+.
+
+    def hash # :nodoc:
+      name.hash ^ type.hash ^ requirement.hash
+    end
+
+    def inspect # :nodoc:
+      "<%s type=%p name=%p requirements=%p>" %
+      [self.class, self.type, self.name, requirement.to_s]
+    end
+
+    ##
+    # Does this dependency require a prerelease?
+
+    def prerelease?
+      @prerelease || requirement.prerelease?
+    end
+
+    def pretty_print q # :nodoc:
+      q.group 1, 'Gem::Dependency.new(', ')' do
+      q.pp name
+      q.text ','
+      q.breakable
+
+      q.pp requirement
+
+      q.text ','
+      q.breakable
+
+      q.pp type
+    end
+    end
+
+    ##
+    # What does this dependency require?
+
+    def requirement
+      return @requirement if defined?(@requirement) and @requirement
+
+      # @version_requirements and @version_requirement are legacy ivar
+      # names, and supported here because older gems need to keep
+      # working and Dependency doesn't implement marshal_dump and
+      # marshal_load. In a happier world, this would be an
+      # attr_accessor. The horrifying instance_variable_get you see
+      # below is also the legacy of some old restructurings.
+      #
+      # Note also that because of backwards compatibility (loading new
+      # gems in an old RubyGems installation), we can't add explicit
+      # marshaling to this class until we want to make a big
+      # break. Maybe 2.0.
+      #
+      # Children, define explicit marshal and unmarshal behavior for
+      # public classes. Marshal formats are part of your public API.
+
+      if defined?(@version_requirement) && @version_requirement
+        version = @version_requirement.instance_variable_get :@version
+        @version_requirement  = nil
+        @version_requirements = Gem::Requirement.new version
+      end
+
+      @requirement = @version_requirements if defined?(@version_requirements)
+    end
+
+    def requirements_list
+      requirement.as_list
+    end
+
+    def to_s # :nodoc:
+      if type != :runtime then
+        "#{name} (#{requirement}, #{type})"
+      else
+        "#{name} (#{requirement})"
+      end
+    end
+
+    ##
+    # Dependency type.
+
+    def type
+      @type ||= :runtime
+    end
+
+    def == other # :nodoc:
+      Gem::Dependency === other &&
+      self.name        == other.name &&
+      self.type        == other.type &&
+      self.requirement == other.requirement
+    end
+
+    ##
+    # Dependencies are ordered by name.
+
+    def <=> other
+      self.name <=> other.name
+    end
+
+    ##
+    # Uses this dependency as a pattern to compare to +other+. This
+    # dependency will match if the name matches the other's name, and
+    # other has only an equal version requirement that satisfies this
+    # dependency.
+
+    def =~ other
+      unless Gem::Dependency === other
+        return unless other.respond_to?(:name) && other.respond_to?(:version)
+        other = Gem::Dependency.new other.name, other.version
+      end
+
+      return false unless name === other.name
+
+      reqs = other.requirement.requirements
+
+      return false unless reqs.length == 1
+      return false unless reqs.first.first == '='
+
+      version = reqs.first.last
+
+      requirement.satisfied_by? version
+    end
+
+    def match? name, version
+      return false unless self.name === name
+      return true if requirement.none?
+
+      requirement.satisfied_by? Gem::Version.new(version)
+    end
+
+    def matches_spec? spec
+      return false unless name === spec.name
+      return true  if requirement.none?
+
+      requirement.satisfied_by?(spec.version)
+    end
+
+    ##
+    # Merges the requirements of +other+ into this dependency
+
+    def merge other
+      unless name == other.name then
+        raise ArgumentError,
+          "#{self} and #{other} have different names"
+      end
+
+      default = Gem::Requirement.default
+      self_req  = self.requirement
+      other_req = other.requirement
+
+      return self.class.new name, self_req  if other_req == default
+      return self.class.new name, other_req if self_req  == default
+
+      self.class.new name, self_req.as_list.concat(other_req.as_list)
+    end
+
+    def matching_specs platform_only = false
+      matches = Gem::Specification.find_all { |spec|
+        self.name === spec.name and # TODO: == instead of ===
+          requirement.satisfied_by? spec.version
+      }
+
+      if platform_only
+        matches.reject! { |spec|
+          not Gem::Platform.match spec.platform
+        }
+      end
+
+      matches = matches.sort_by { |s| s.sort_obj } # HACK: shouldn't be needed
+    end
+
+    ##
+    # True if the dependency will not always match the latest version.
+
+    def specific?
+      @requirement.specific?
+    end
+
+    def to_specs
+      matches = matching_specs true
+
+      # TODO: check Gem.activated_spec[self.name] in case matches falls outside
+
+      if matches.empty? then
+        specs = Gem::Specification.all_names.join ", "
+        error = Gem::LoadError.new "Could not find #{name} (#{requirement}) amongst [#{specs}]"
+        error.name        = self.name
+        error.requirement = self.requirement
+        raise error
+      end
+
+      # TODO: any other resolver validations should go here
+
+      matches
+    end
+
+    def to_spec
+      matches = self.to_specs
+
+      matches.find { |spec| spec.activated? } or matches.last
+    end
+  end
+
+end

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

@@ -0,0 +1,208 @@
+module Pod::Vendor
+
+  # require "rubygems/version"
+
+  ##
+  # 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"
+
+  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 && v.release < r.bump }
+    }
+
+    quoted  = OPS.keys.map { |k| Regexp.quote k }.join "|"
+    PATTERN = /\A\s*(#{quoted})?\s*(#{Gem::Version::VERSION_PATTERN})\s*\z/
+
+    ##
+    # Factory method to create a Gem::Requirement object.  Input may be
+    # a Version, a String, or nil.  Intended to simplify client code.
+    #
+    # If the input is "weird", the default version requirement is
+    # returned.
+
+    def self.create input
+      case input
+      when Gem::Requirement then
+        input
+      when Gem::Version, Array then
+        new input
+      else
+        if input.respond_to? :to_str then
+          new [input.to_str]
+        else
+          default
+        end
+      end
+    end
+
+    ##
+    # 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
+
+    ##
+    # Parse +obj+, returning an <tt>[op, version]</tt> pair. +obj+ can
+    # be a String or a Gem::Version.
+    #
+    # If +obj+ is a String, it can be either a full requirement
+    # 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"]
+
+    def self.parse obj
+      return ["=", obj] if Gem::Version === obj
+
+      unless PATTERN =~ obj.to_s
+        raise ArgumentError, "Illformed requirement [#{obj.inspect}]"
+      end
+
+      [$1 || "=", Gem::Version.new($2)]
+    end
+
+    ##
+    # An array of requirement pairs. The first element of the pair is
+    # the op, and the second is the Gem::Version.
+
+    attr_reader :requirements #:nodoc:
+
+    ##
+    # Constructs a requirement from +requirements+. Requirements can be
+    # Strings, Gem::Versions, or Arrays of those. +nil+ and duplicate
+    # requirements are ignored. An empty set of +requirements+ is the
+    # same as <tt>">= 0"</tt>.
+
+    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 }
+    end
+
+    def none?
+      @none ||= (to_s == ">= 0")
+    end
+
+    def as_list # :nodoc:
+      requirements.map { |op, version| "#{op} #{version}" }.sort
+    end
+
+    def hash # :nodoc:
+      requirements.hash
+    end
+
+    def marshal_dump # :nodoc:
+      fix_syck_default_key_in_requirements
+
+      [@requirements]
+    end
+
+    def marshal_load array # :nodoc:
+      @requirements = array[0]
+
+      fix_syck_default_key_in_requirements
+    end
+
+    def yaml_initialize(tag, vals) # :nodoc:
+      vals.each do |ivar, val|
+      instance_variable_set "@#{ivar}", val
+    end
+
+    fix_syck_default_key_in_requirements
+    end
+
+    def init_with coder # :nodoc:
+      yaml_initialize coder.tag, coder.map
+    end
+
+    def prerelease?
+      requirements.any? { |r| r.last.prerelease? }
+    end
+
+    def pretty_print q # :nodoc:
+      q.group 1, 'Gem::Requirement.new(', ')' do
+      q.pp as_list
+    end
+    end
+
+    ##
+    # True if +version+ satisfies this Requirement.
+
+    def satisfied_by? 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 :=== :satisfied_by?
+    alias :=~ :satisfied_by?
+
+    ##
+    # True if the requirement will not always match the latest version.
+
+    def specific?
+      return true if @requirements.length > 1 # GIGO, > 1, > 2 is silly
+
+      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
+    end
+
+    private
+
+    def fix_syck_default_key_in_requirements
+      Gem.load_yaml
+
+      # Fixup the Syck DefaultKey bug
+      @requirements.each do |r|
+        if r[0].kind_of? Gem::SyckDefaultKey
+          r[0] = "="
+        end
+      end
+    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:
+
+end