xcocoapods 1.5.3

data/lib/cocoapods/core_overrides.rb

@@ -0,0 +1 @@
+require 'cocoapods/sources_manager'

data/lib/cocoapods/downloader.rb

@@ -0,0 +1,190 @@
+require 'cocoapods-downloader'
+require 'claide/informative_error'
+require 'fileutils'
+require 'tmpdir'
+
+module Pod
+  module Downloader
+    require 'cocoapods/downloader/cache'
+    require 'cocoapods/downloader/request'
+    require 'cocoapods/downloader/response'
+
+    # Downloads a pod from the given `request` to the given `target` location.
+    #
+    # @return [Response] The download response for this download.
+    #
+    # @param  [Request] request
+    #         the request that describes this pod download.
+    #
+    # @param  [Pathname,Nil] target
+    #         the location to which this pod should be downloaded. If `nil`,
+    #         then the pod will only be cached.
+    #
+    # @param  [Boolean] can_cache
+    #         whether caching is allowed.
+    #
+    # @param  [Pathname,Nil] cache_path
+    #         the path used to cache pod downloads.
+    #
+    def self.download(
+      request,
+      target,
+      can_cache: true,
+      cache_path: Config.instance.cache_root + 'Pods'
+    )
+      can_cache &&= !Config.instance.skip_download_cache
+
+      request = preprocess_request(request)
+
+      if can_cache
+        raise ArgumentError, 'Must provide a `cache_path` when caching.' unless cache_path
+        cache = Cache.new(cache_path)
+        result = cache.download_pod(request)
+      else
+        raise ArgumentError, 'Must provide a `target` when caching is disabled.' unless target
+
+        require 'cocoapods/installer/pod_source_preparer'
+        result, = download_request(request, target)
+        Installer::PodSourcePreparer.new(result.spec, result.location).prepare!
+      end
+
+      if target && result.location && target != result.location
+        UI.message "Copying #{request.name} from `#{result.location}` to #{UI.path target}", '> ' do
+          FileUtils.rm_rf target
+          FileUtils.cp_r(result.location, target)
+        end
+      end
+      result
+    end
+
+    # Performs the download from the given `request` to the given `target` location.
+    #
+    # @return [Response, Hash<String,Specification>]
+    #         The download response for this download, and the specifications
+    #         for this download grouped by name.
+    #
+    # @param  [Request] request
+    #         the request that describes this pod download.
+    #
+    # @param  [Pathname,Nil] target
+    #         the location to which this pod should be downloaded. If `nil`,
+    #         then the pod will only be cached.
+    #
+    def self.download_request(request, target)
+      result = Response.new
+      result.checkout_options = download_source(target, request.params)
+      result.location = target
+
+      if request.released_pod?
+        result.spec = request.spec
+        podspecs = { request.name => request.spec }
+      else
+        podspecs = Sandbox::PodspecFinder.new(target).podspecs
+        podspecs[request.name] = request.spec if request.spec
+        podspecs.each do |name, spec|
+          if request.name == name
+            result.spec = spec
+          end
+        end
+      end
+
+      [result, podspecs]
+    end
+
+    private
+
+    # Downloads a pod with the given `params` to `target`.
+    #
+    # @param  [Pathname] target
+    #
+    # @param  [Hash<Symbol,String>] params
+    #
+    # @return [Hash] The checkout options required to re-download this exact
+    #         same source.
+    #
+    def self.download_source(target, params)
+      FileUtils.rm_rf(target)
+      downloader = Downloader.for_target(target, params)
+      downloader.download
+      target.mkpath
+
+      if downloader.options_specific?
+        params
+      else
+        downloader.checkout_options
+      end
+    end
+
+    # Return a new request after preprocessing by the downloader
+    #
+    # @param  [Request] request
+    #         the request that needs preprocessing
+    #
+    # @return [Request] the preprocessed request
+    #
+    def self.preprocess_request(request)
+      Request.new(
+        :spec => request.spec,
+        :released => request.released_pod?,
+        :name => request.name,
+        :params => Downloader.preprocess_options(request.params))
+    end
+
+    public
+
+    class DownloaderError; include CLAide::InformativeError; end
+
+    class Base
+      override_api do
+        def execute_command(executable, command, raise_on_failure = false)
+          Executable.execute_command(executable, command, raise_on_failure)
+        rescue CLAide::InformativeError => e
+          raise DownloaderError, e.message
+        end
+
+        # Indicates that an action will be performed. The action is passed as a
+        # block.
+        #
+        # @param  [String] message
+        #         The message associated with the action.
+        #
+        # @yield  The action, this block is always executed.
+        #
+        # @return [void]
+        #
+        def ui_action(message)
+          UI.section(" > #{message}", '', 1) do
+            yield
+          end
+        end
+
+        # Indicates that a minor action will be performed. The action is passed
+        # as a block.
+        #
+        # @param  [String] message
+        #         The message associated with the action.
+        #
+        # @yield  The action, this block is always executed.
+        #
+        # @return [void]
+        #
+        def ui_sub_action(message)
+          UI.section(" > #{message}", '', 2) do
+            yield
+          end
+        end
+
+        # Prints an UI message.
+        #
+        # @param  [String] message
+        #         The message associated with the action.
+        #
+        # @return [void]
+        #
+        def ui_message(message)
+          UI.puts message
+        end
+      end
+    end
+  end
+end

data/lib/cocoapods/downloader/cache.rb

@@ -0,0 +1,233 @@
+require 'fileutils'
+require 'tmpdir'
+
+module Pod
+  module Downloader
+    # The class responsible for managing Pod downloads, transparently caching
+    # them in a cache directory.
+    #
+    class Cache
+      # @return [Pathname] The root directory where this cache store its
+      #         downloads.
+      #
+      attr_reader :root
+
+      # Initialize a new instance
+      #
+      # @param  [Pathname,String] root
+      #         see {#root}
+      #
+      def initialize(root)
+        @root = Pathname(root)
+        ensure_matching_version
+      end
+
+      # Downloads the Pod from the given `request`
+      #
+      # @param  [Request] request
+      #         the request to be downloaded.
+      #
+      # @return [Response] the response from downloading `request`
+      #
+      def download_pod(request)
+        cached_pod(request) || uncached_pod(request)
+      rescue Informative
+        raise
+      rescue
+        UI.puts("\n[!] Error installing #{request.name}".red)
+        raise
+      end
+
+      # @return [Hash<String, Hash<Symbol, String>>]
+      #         A hash whose keys are the pod name
+      #         And values are a hash with the following keys:
+      #         :spec_file : path to the spec file
+      #         :name      : name of the pod
+      #         :version   : pod version
+      #         :release   : boolean to tell if that's a release pod
+      #         :slug      : the slug path where the pod cache is located
+      #
+      def cache_descriptors_per_pod
+        specs_dir = root + 'Specs'
+        release_specs_dir = specs_dir + 'Release'
+        return {} unless specs_dir.exist?
+
+        spec_paths = specs_dir.find.select { |f| f.fnmatch('*.podspec.json') }
+        spec_paths.reduce({}) do |hash, spec_path|
+          spec = Specification.from_file(spec_path)
+          hash[spec.name] ||= []
+          is_release = spec_path.to_s.start_with?(release_specs_dir.to_s)
+          request = Downloader::Request.new(:spec => spec, :released => is_release)
+          hash[spec.name] << {
+            :spec_file => spec_path,
+            :name => spec.name,
+            :version => spec.version,
+            :release => is_release,
+            :slug => root + request.slug,
+          }
+          hash
+        end
+      end
+
+      private
+
+      # Ensures the cache on disk was created with the same CocoaPods version as
+      # is currently running.
+      #
+      # @return [Void]
+      #
+      def ensure_matching_version
+        version_file = root + 'VERSION'
+        version = version_file.read.strip if version_file.file?
+
+        root.rmtree if version != Pod::VERSION && root.exist?
+        root.mkpath
+
+        version_file.open('w') { |f| f << Pod::VERSION }
+      end
+
+      # @param  [Request] request
+      #         the request to be downloaded.
+      #
+      # @param  [Hash<Symbol,String>] slug_opts
+      #         the download options that should be used in constructing the
+      #         cache slug for this request.
+      #
+      # @return [Pathname] The path for the Pod downloaded from the given
+      #         `request`.
+      #
+      def path_for_pod(request, slug_opts = {})
+        root + request.slug(slug_opts)
+      end
+
+      # @param  [Request] request
+      #         the request to be downloaded.
+      #
+      # @param  [Hash<Symbol,String>] slug_opts
+      #         the download options that should be used in constructing the
+      #         cache slug for this request.
+      #
+      # @return [Pathname] The path for the podspec downloaded from the given
+      #         `request`.
+      #
+      def path_for_spec(request, slug_opts = {})
+        path = root + 'Specs' + request.slug(slug_opts)
+        path.sub_ext('.podspec.json')
+      end
+
+      # @param  [Request] request
+      #         the request to be downloaded.
+      #
+      # @return [Response] The download response for the given `request` that
+      #         was found in the download cache.
+      #
+      def cached_pod(request)
+        cached_spec = cached_spec(request)
+        path = path_for_pod(request)
+
+        return unless cached_spec && path.directory?
+        spec = request.spec || cached_spec
+        Response.new(path, spec, request.params)
+      end
+
+      # @param  [Request] request
+      #         the request to be downloaded.
+      #
+      # @return [Specification] The cached specification for the given
+      #         `request`.
+      #
+      def cached_spec(request)
+        path = path_for_spec(request)
+        path.file? && Specification.from_file(path)
+      rescue JSON::ParserError
+        nil
+      end
+
+      # @param  [Request] request
+      #         the request to be downloaded.
+      #
+      # @return [Response] The download response for the given `request` that
+      #         was not found in the download cache.
+      #
+      def uncached_pod(request)
+        in_tmpdir do |target|
+          result, podspecs = download(request, target)
+          result.location = nil
+
+          podspecs.each do |name, spec|
+            destination = path_for_pod(request, :name => name, :params => result.checkout_options)
+            copy_and_clean(target, destination, spec)
+            write_spec(spec, path_for_spec(request, :name => name, :params => result.checkout_options))
+            if request.name == name
+              result.location = destination
+            end
+          end
+
+          result
+        end
+      end
+
+      def download(request, target)
+        Downloader.download_request(request, target)
+      end
+
+      # Performs the given block inside a temporary directory,
+      # which is removed at the end of the block's scope.
+      #
+      # @return [Object] The return value of the given block
+      #
+      def in_tmpdir(&blk)
+        tmpdir = Pathname(Dir.mktmpdir)
+        blk.call(tmpdir)
+      ensure
+        FileUtils.remove_entry(tmpdir, :force => true) if tmpdir && tmpdir.exist?
+      end
+
+      # Copies the `source` directory to `destination`, cleaning the directory
+      # of any files unused by `spec`.
+      #
+      # @param  [Pathname] source
+      #
+      # @param  [Pathname] destination
+      #
+      # @param  [Specification] spec
+      #
+      # @return [Void]
+      #
+      def copy_and_clean(source, destination, spec)
+        specs_by_platform = group_subspecs_by_platform(spec)
+        destination.parent.mkpath
+        FileUtils.rm_rf(destination)
+        FileUtils.cp_r(source, destination)
+        Pod::Installer::PodSourcePreparer.new(spec, destination).prepare!
+        Sandbox::PodDirCleaner.new(destination, specs_by_platform).clean!
+      end
+
+      def group_subspecs_by_platform(spec)
+        specs_by_platform = {}
+        [spec, *spec.recursive_subspecs].each do |ss|
+          ss.available_platforms.each do |platform|
+            specs_by_platform[platform] ||= []
+            specs_by_platform[platform] << ss
+          end
+        end
+        specs_by_platform
+      end
+
+      # Writes the given `spec` to the given `path`.
+      #
+      # @param  [Specification] spec
+      #         the specification to be written.
+      #
+      # @param  [Pathname] path
+      #         the path the specification is to be written to.
+      #
+      # @return [Void]
+      #
+      def write_spec(spec, path)
+        path.dirname.mkpath
+        path.open('w') { |f| f.write spec.to_pretty_json }
+      end
+    end
+  end
+end

data/lib/cocoapods/downloader/request.rb

@@ -0,0 +1,86 @@
+require 'digest'
+
+module Pod
+  module Downloader
+    # This class represents a download request for a given Pod.
+    #
+    class Request
+      # @return [Specification,Nil] The specification for the pod whose download
+      #         is being requested.
+      #
+      attr_reader :spec
+
+      # @return [Boolean] Whether this download request is for a released pod.
+      #
+      attr_reader :released_pod
+      alias_method :released_pod?, :released_pod
+
+      # @return [String] The name of the pod whose dowload is being requested.
+      #
+      attr_reader :name
+
+      # @return [Hash<Symbol, String>] The download parameters for this request.
+      #
+      attr_reader :params
+
+      # Initialize a new instance
+      #
+      # @param  [Specification,Nil] spec
+      #         see {#spec}
+      #
+      # @param  [Boolean] released
+      #         see {#released_pod}
+      #
+      # @param  [String,Nil] name
+      #         see {#name}
+      #
+      # @param  [Hash<Symbol,String>,Nil] params
+      #         see {#params}
+      #
+      def initialize(spec: nil, released: false, name: nil, params: false)
+        @released_pod = released
+        @spec = spec
+        @params = spec ? (spec.source && spec.source.dup) : params
+        @name = spec ? spec.name : name
+
+        validate!
+      end
+
+      # @param  [String] name
+      #         the name of the pod being downloaded.
+      #
+      # @param  [Hash<#to_s, #to_s>] params
+      #         the download parameters of the pod being downloaded.
+      #
+      # @param  [Specification] spec
+      #         the specification of the pod being downloaded.
+      #
+      # @return [String] The slug used to store the files resulting from this
+      #         download request.
+      #
+      def slug(name: self.name, params: self.params, spec: self.spec)
+        checksum = spec && spec.checksum && '-' << spec.checksum[0, 5]
+        if released_pod?
+          "Release/#{name}/#{spec.version}#{checksum}"
+        else
+          opts = params.to_a.sort_by(&:first).map { |k, v| "#{k}=#{v}" }.join('-')
+          digest = Digest::MD5.hexdigest(opts)
+          "External/#{name}/#{digest}#{checksum}"
+        end
+      end
+
+      private
+
+      # Validates that the given request is well-formed.
+      #
+      # @return [Void]
+      #
+      def validate!
+        raise ArgumentError, 'Requires a name' unless name
+        raise ArgumentError, 'Must give a spec for a released download request' if released_pod? && !spec
+        raise ArgumentError, 'Requires a version if released' if released_pod? && !spec.version
+        raise ArgumentError, 'Requires params' unless params
+      end
+    end
+  end
+end