cocoapods 0.16.4 → 0.17.0.rc1

data/lib/cocoapods/command/update.rb

@@ -1,25 +0,0 @@
-module Pod
-  class Command
-    class Update < Install
-      def self.banner
-%{Updating dependencies of a project:
-
-    $ pod update
-
-      Updates all dependencies.}
-      end
-
-      def initialize(argv)
-        config.skip_repo_update = argv.option('--no-update')
-        super unless argv.empty?
-      end
-
-      def run
-        verify_podfile_exists!
-        verify_lockfile_exists!
-        run_install_with_update(true)
-      end
-    end
-  end
-end
-

data/lib/cocoapods/dependency.rb

@@ -1,285 +0,0 @@
-require 'cocoapods/open_uri'
-
-module Pod
-  class Dependency < Gem::Dependency
-
-    attr_reader :head
-    alias :head? :head
-    attr_accessor :specification, :external_source
-
-    def initialize(*name_and_version_requirements, &block)
-      if name_and_version_requirements.empty? && block
-        @inline_podspec = true
-        @specification  = Specification.new(&block)
-        super(@specification.name, @specification.version)
-
-      elsif !name_and_version_requirements.empty? && block.nil?
-        version = name_and_version_requirements.last
-        if name_and_version_requirements.last.is_a?(Hash)
-          @external_source = ExternalSources.from_params(name_and_version_requirements[0].split('/').first, name_and_version_requirements.pop)
-        elsif version.is_a?(Symbol) && version == :head || version.is_a?(Version) && version.head?
-          name_and_version_requirements.pop
-          @head = true
-        end
-
-        super(*name_and_version_requirements)
-
-        if head? && !latest_version?
-          raise Informative, "A `:head' dependency may not specify version requirements."
-        end
-
-      else
-        raise Informative, "A dependency needs either a name and version requirements, " \
-                           "a source hash, or a block which defines a podspec."
-      end
-    end
-
-    def latest_version?
-      versions = @version_requirements.requirements.map(&:last)
-      versions == [Gem::Version.new('0')]
-    end
-
-    def ==(other)
-      super && (head? == other.head?) && (@specification ? @specification == other.specification : @external_source == other.external_source)
-    end
-
-    def subspec_dependency?
-      @name.include?('/')
-    end
-
-    def inline?
-      @inline_podspec
-    end
-
-    def external?
-      !@external_source.nil?
-    end
-
-    # In case this is a dependency for a subspec, e.g. 'RestKit/Networking',
-    # this returns 'RestKit', which is what the Pod::Source needs to know to
-    # retrieve the correct Set from disk.
-    def top_level_spec_name
-      subspec_dependency? ? @name.split('/').first : @name
-    end
-
-    # Returns a copy of the dependency, but with the name of the top level
-    # spec. This is used by Pod::Specification::Set to merge dependencies on
-    # the complete set, irrespective of what spec in the set wil be used.
-    def to_top_level_spec_dependency
-      dep = dup
-      dep.name = top_level_spec_name
-      dep
-    end
-
-    def to_s
-      version = ''
-      if external?
-        version << @external_source.description
-      elsif inline?
-        version << 'defined in Podfile'
-      elsif head?
-        version << 'HEAD'
-      elsif @version_requirements != Gem::Requirement.default
-        version << @version_requirements.to_s
-      end
-      result = @name.dup
-      result << " (#{version})" unless version.empty?
-      result
-    end
-
-    def specification_from_sandbox(sandbox, platform)
-      @external_source.specification_from_sandbox(sandbox, platform)
-    end
-
-    def match_version?(version)
-      match?(name, version) && (version.head? == head?)
-    end
-
-    # Taken from RubyGems 1.3.7
-    unless public_method_defined?(:match?)
-      def match?(spec_name, spec_version)
-        pattern = name
-
-        if Regexp === pattern
-          return false unless pattern =~ spec_name
-        else
-          return false unless pattern == spec_name
-        end
-
-        return true if requirement.to_s == ">= 0"
-
-        requirement.satisfied_by? Gem::Version.new(spec_version)
-      end
-    end
-
-    # Taken from a newer version of RubyGems
-    unless public_method_defined?(:merge)
-      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
-    end
-
-    module ExternalSources
-      def self.from_params(name, params)
-        return unless name && params
-        if params.key?(:git)
-          GitSource.new(name, params)
-        elsif params.key?(:hg)
-          MercurialSource.new(name, params)
-        elsif params.key?(:svn)
-          SvnSource.new(name, params)
-        elsif params.key?(:podspec)
-          PodspecSource.new(name, params)
-        elsif params.key?(:local)
-          LocalSource.new(name, params)
-        else
-          raise Informative, "Unknown external source parameters for #{name}: #{params}"
-        end
-      end
-
-      class AbstractExternalSource
-        include Config::Mixin
-
-        attr_reader :name, :params
-
-        def initialize(name, params)
-          @name, @params = name, params
-        end
-
-        def specification_from_sandbox(sandbox, platform)
-          specification_from_local(sandbox, platform) || specification_from_external(sandbox, platform)
-        end
-
-        def specification_from_local(sandbox, platform)
-          if local_pod = sandbox.installed_pod_named(name, platform)
-            local_pod.top_specification
-          end
-        end
-
-        def specification_from_external(sandbox, platform)
-          podspec = copy_external_source_into_sandbox(sandbox, platform)
-          spec = specification_from_local(sandbox, platform)
-          raise Informative, "No podspec found for `#{name}' in #{description}" unless spec
-          spec
-        end
-
-        # Can store from a pathname or a string
-        #
-        def store_podspec(sandbox, podspec)
-          output_path = sandbox.root + "Local Podspecs/#{name}.podspec"
-          output_path.dirname.mkpath
-          if podspec.is_a?(String)
-            raise Informative, "No podspec found for `#{name}' in #{description}" unless podspec.include?('Spec.new')
-            output_path.open('w') { |f| f.puts(podspec) }
-          else
-            raise Informative, "No podspec found for `#{name}' in #{description}" unless podspec.exist?
-            FileUtils.copy(podspec, output_path)
-          end
-        end
-
-        def ==(other)
-          return if other.nil?
-          name == other.name && params == other.params
-        end
-      end
-
-      class DownloaderSource < AbstractExternalSource
-        def copy_external_source_into_sandbox(sandbox, platform)
-          UI.info("->".green + " Pre-downloading: '#{name}'") do
-            target = sandbox.root + name
-            target.rmtree if target.exist?
-            downloader = Downloader.for_target(sandbox.root + name, @params)
-            downloader.download
-            store_podspec(sandbox, target + "#{name}.podspec")
-            if local_pod = sandbox.installed_pod_named(name, platform)
-              local_pod.downloaded = true
-            end
-          end
-        end
-      end
-
-      class GitSource < DownloaderSource
-        def description
-          "from `#{@params[:git]}'".tap do |description|
-            description << ", commit `#{@params[:commit]}'" if @params[:commit]
-            description << ", branch `#{@params[:branch]}'" if @params[:branch]
-            description << ", tag `#{@params[:tag]}'" if @params[:tag]
-          end
-        end
-      end
-
-      class MercurialSource < DownloaderSource
-        def description
-          "from `#{@params[:hg]}'".tap do |description|
-            description << ", revision `#{@params[:revision]}'" if @params[:revision]
-          end
-        end
-      end
-
-      class SvnSource < DownloaderSource
-        def description
-          "from `#{@params[:svn]}'".tap do |description|
-            description << ", folder `#{@params[:folder]}'" if @params[:folder]
-            description << ", tag `#{@params[:tag]}'" if @params[:tag]
-            description << ", revision `#{@params[:revision]}'" if @params[:revision]
-          end
-        end
-      end
-
-      # can be http, file, etc
-      class PodspecSource < AbstractExternalSource
-        def copy_external_source_into_sandbox(sandbox, _)
-          UI.info("->".green + " Fetching podspec for `#{name}' from: #{@params[:podspec]}") do
-            path = @params[:podspec]
-            path = Pathname.new(path).expand_path if path.start_with?("~")
-            open(path) { |io| store_podspec(sandbox, io.read) }
-          end
-        end
-
-        def description
-          "from `#{@params[:podspec]}'"
-        end
-      end
-
-      class LocalSource < AbstractExternalSource
-        def pod_spec_path
-          path = Pathname.new(@params[:local]).expand_path
-          path += "#{name}.podspec"# unless path.to_s.include?("#{name}.podspec")
-          raise Informative, "No podspec found for `#{name}' in `#{@params[:local]}'" unless path.exist?
-          path
-        end
-
-        def copy_external_source_into_sandbox(sandbox, _)
-          store_podspec(sandbox, pod_spec_path)
-        end
-
-        def specification_from_local(sandbox, platform)
-          specification_from_external(sandbox, platform)
-        end
-
-        def specification_from_external(sandbox, platform)
-          copy_external_source_into_sandbox(sandbox, platform)
-          spec = Specification.from_file(pod_spec_path)
-          spec.source = @params
-          spec
-        end
-
-        def description
-          "from `#{@params[:local]}'"
-        end
-      end
-    end
-  end
-end

data/lib/cocoapods/downloader/git.rb

@@ -1,276 +0,0 @@
-require 'open-uri'
-# require 'tempfile'
-require 'zlib'
-require 'digest/sha1'
-
-module Pod
-  class Downloader
-
-    # Concreted Downloader class that provides support for specifications with
-    # git sources.
-    #
-    class Git < Downloader
-      include Config::Mixin
-
-      executable :git
-
-      def download
-        create_cache unless cache_exist?
-        UI.section(' > Cloning git repo', '', 1) do
-          if options[:tag]
-            download_tag
-          elsif options[:branch]
-            download_branch
-          elsif options[:commit]
-            download_commit
-          else
-            download_head
-          end
-          Dir.chdir(target_path) { git! "submodule update --init"  } if options[:submodules]
-        end
-        prune_cache
-      end
-
-
-      # @!group Download implementations
-
-      # @return [Pathname] The clone URL, which resolves to the cache path.
-      #
-      def clone_url
-        cache_path
-      end
-
-      # @return [void] Convenience method to perform clones operations.
-      #
-      def clone(from, to)
-        UI.section(" > Cloning to Pods folder",'',1) do
-          git! %Q|clone "#{from}" "#{to}"|
-        end
-      end
-
-      # @return [void] Checkouts the HEAD of the git source in the destination
-      # path.
-      #
-      def download_head
-        if cache_exist?
-          update_cache
-        else
-          create_cache
-        end
-
-        clone(clone_url, target_path)
-        Dir.chdir(target_path) { git! "submodule update --init"  } if options[:submodules]
-      end
-
-      # @return [void] Checkouts a specific tag of the git source in the
-      # destination path.
-      #
-      def download_tag
-        ensure_ref_exists(options[:tag])
-        Dir.chdir(target_path) do
-          git! "init"
-          git! "remote add origin '#{clone_url}'"
-          git! "fetch origin tags/#{options[:tag]}"
-          git! "reset --hard FETCH_HEAD"
-          git! "checkout -b activated-pod-commit"
-        end
-      end
-
-      # @return [void] Checkouts a specific commit of the git source in the
-      # destination path.
-      #
-      def download_commit
-        ensure_ref_exists(options[:commit])
-        clone(clone_url, target_path)
-        Dir.chdir(target_path) do
-          git! "checkout -b activated-pod-commit #{options[:commit]}"
-        end
-      end
-
-      # @return [void] Checkouts the HEAD of a specific branch of the git
-      # source in the destination path.
-      #
-      def download_branch
-        ensure_remote_branch_exists(options[:branch])
-        clone(clone_url, target_path)
-        Dir.chdir(target_path) do
-          git! "remote add upstream '#{@url}'" # we need to add the original url, not the cache url
-          git! "fetch -q upstream" # refresh the branches
-          git! "checkout --track -b activated-pod-commit upstream/#{options[:branch]}" # create a new tracking branch
-          UI.message("Just downloaded and checked out branch: #{options[:branch]} from upstream #{clone_url}")
-        end
-      end
-
-
-
-      # @!group Checking references
-
-      # @return [Bool] Wether a reference (commit SHA or tag)
-      #
-      def ref_exists?(ref)
-        Dir.chdir(cache_path) { git "rev-list --max-count=1 #{ref}" }
-        $? == 0
-      end
-
-      # @return [void] Checks if a reference exists in the cache and updates
-      # only if necessary.
-      #
-      # @raises if after the update the reference can't be found.
-      #
-      def ensure_ref_exists(ref)
-        return if ref_exists?(ref)
-        update_cache
-        raise Informative, "[!] Cache unable to find git reference `#{ref}' for `#{url}'.".red unless ref_exists?(ref)
-      end
-
-      # @return [Bool] Wether a branch exists in the cache.
-      #
-      def branch_exists?(branch)
-        Dir.chdir(cache_path) { git "branch --all | grep #{branch}$" } # check for remote branch and do suffix matching ($ anchor)
-        $? == 0
-      end
-
-      # @return [void] Checks if a branch exists in the cache and updates
-      # only if necessary.
-      #
-      # @raises if after the update the branch can't be found.
-      #
-      def ensure_remote_branch_exists(branch)
-        return if branch_exists?(branch)
-        update_cache
-        raise Informative, "[!] Cache unable to find git reference `#{branch}' for `#{url}' (#{$?}).".red unless branch_exists?(branch)
-      end
-
-
-      # @!group Cache
-
-      # The maximum allowed size for the cache expressed in Mb.
-      #
-      MAX_CACHE_SIZE = 500
-
-      # @return [Pathname] The directory where the cache for the current git
-      # repo is stored.
-      #
-      # @note The name of the directory is the SHA1 hash value of the URL of
-      #       the git repo.
-      #
-      def cache_path
-        @cache_path ||= caches_root + "#{Digest::SHA1.hexdigest(url.to_s)}"
-      end
-
-      # @return [Pathname] The directory where the git caches are stored.
-      #
-      def caches_root
-        Pathname.new(File.expand_path("~/Library/Caches/CocoaPods/Git"))
-      end
-
-      # @return [Integer] The global size of the git cache expressed in Mb.
-      #
-      def caches_size
-        `du -cm`.split("\n").last.to_i
-      end
-
-      # @return [Bool] Wether the cache exits.
-      #
-      # @note The previous implementation of the cache didn't use a barebone
-      #       git repo. This method takes into account this fact and checks
-      #       that the cache is actually a barebone repo. If the cache was not
-      #       barebone it will be deleted and recreated.
-      #
-      def cache_exist?
-        cache_path.exist? &&
-          cache_origin_url(cache_path).to_s == url.to_s &&
-          Dir.chdir(cache_path) { git("config core.bare").chomp == "true" }
-      end
-
-      # @return [String] The origin URL of the cache with the given directory.
-      #
-      # @param [String] dir The directory of the cache.
-      #
-      def cache_origin_url(dir)
-        Dir.chdir(dir) { `git config remote.origin.url`.chomp }
-      end
-
-      # @return [void] Creates the barebone repo that will serve as the cache
-      # for the current repo.
-      #
-      def create_cache
-        UI.section(" > Creating cache git repo (#{cache_path})",'',1) do
-          cache_path.rmtree if cache_path.exist?
-          cache_path.mkpath
-          git! %Q|clone  --mirror "#{url}" "#{cache_path}"|
-        end
-      end
-
-      # @return [void] Updates the barebone repo used as a cache against its
-      # remote.
-      #
-      def update_cache
-        UI.section(" > Updating cache git repo (#{cache_path})",'',1) do
-          Dir.chdir(cache_path) { git! "remote update" }
-        end
-      end
-
-      # @return [void] Deletes the oldest caches until they the global size is
-      # below the maximum allowed.
-      #
-      def prune_cache
-        return unless caches_root.exist?
-        Dir.chdir(caches_root) do
-          repos = Pathname.new(caches_root).children.select { |c| c.directory? }.sort_by(&:ctime)
-          while caches_size >= MAX_CACHE_SIZE && !repos.empty?
-            dir = repos.shift
-            UI.message "#{'->'.yellow} Removing git cache for `#{cache_origin_url(dir)}'"
-            dir.rmtree
-          end
-        end
-      end
-    end
-
-    # This class allows to download tarballs from GitHub and is not currently
-    # being used by CocoaPods as the git cache is preferable.
-    #
-    class GitHub < Git
-      def download_head
-        download_only? ? download_and_extract_tarball('master') : super
-      end
-
-      def download_tag
-        download_only? ? download_and_extract_tarball(options[:tag]) : super
-      end
-
-      def download_commit
-        download_only? ? download_and_extract_tarball(options[:commit]) : super
-      end
-
-      def download_branch
-        download_only? ? download_and_extract_tarball(options[:branch]) : super
-      end
-
-      def tarball_url_for(id)
-        original_url, username, reponame = *(url.match(/[:\/]([\w\-]+)\/([\w\-]+)\.git/))
-        "https://github.com/#{username}/#{reponame}/tarball/#{id}"
-      end
-
-      def tmp_path
-        target_path + "tarball.tar.gz"
-      end
-
-      private
-
-      def download_only?
-        @options[:download_only]
-      end
-
-      def download_and_extract_tarball(id)
-        File.open(tmp_path, "w+") do |tmpfile|
-          open tarball_url_for(id) do |archive|
-            tmpfile.write Zlib::GzipReader.new(archive).read
-          end
-
-          system "tar xf #{tmpfile.path} -C #{target_path} --strip-components 1"
-        end
-      end
-    end
-  end
-end