cocoapods-core 0.30.0 → 1.15.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: c825fb07fe0a09f2aff4865eee906d366068abe9
-  data.tar.gz: f15b33a4eb444034bc3165faee0080cec4cc7bfc
+SHA256:
+  metadata.gz: 28b58aee1d429faed6b698b36263cc7e86e1ebe4540b2c7e03d1883e28e74f59
+  data.tar.gz: 81da93773c4f3cff54ae532ef20b3fd9b3190fbca1fc4d7fa89e57da4c840ab3
 SHA512:
-  metadata.gz: ed161124fa1f352f2914afeb6eb5ce6fb290eb3fde1ecdb2aa0da7de163b56ac329447bdfc721813d10f458374fa7a44dfd43b8f7920b6553f5e46b8e40f8b50
-  data.tar.gz: c23cd0cbfa5a2ece6550c30755222d9d9981b18f0ed89a8957b81333771c598c3a271031dfa682074e695d8b99ca2bfb9541a99ecdd1bd9e1bfb978450ccb1af
+  metadata.gz: 6ab7a1a1c329774e398f25080dd03f3fda96bc96be0c5582088010b317e2c64876f2d3b01e1ae4d0ea48f32839443ff907f90b9cd27aa681cf9a9e1c94eee43d
+  data.tar.gz: 7a82bc2bda4f3f2cf4f54bf70300bc5c633073696d5882cd282d302ec5b00d8a33072edd7cbaa60812b52525b51cce47ca10597dcefd1b82fb001c55e7852aa4

data/README.md

@@ -1,17 +1,17 @@
 # CocoaPods Core
 
-[![Build Status](https://travis-ci.org/CocoaPods/Core.svg?branch=master)](https://travis-ci.org/CocoaPods/Core)
-[![Coverage Status](https://img.shields.io/coveralls/CocoaPods/Core.svg)](https://coveralls.io/r/CocoaPods/Core)
-[![Code Climate](https://img.shields.io/codeclimate/github/CocoaPods/Core.svg)](https://codeclimate.com/github/CocoaPods/Core)
+[![Build Status](https://github.com/CocoaPods/Core/workflows/Specs/badge.svg)](https://github.com/CocoaPods/Core/actions/workflows/Specs.yml)
+[![Test Coverage](https://api.codeclimate.com/v1/badges/91a2d70b9ed977815c66/test_coverage)](https://codeclimate.com/github/CocoaPods/Core/test_coverage)
+[![Maintainability](https://api.codeclimate.com/v1/badges/91a2d70b9ed977815c66/maintainability)](https://codeclimate.com/github/CocoaPods/Core/maintainability)
 
 The CocoaPods-Core gem provides support to work with the models of CocoaPods.
-It is intended to be used in place of the CocoaPods when the installation
+It is intended to be used in place of the CocoaPods gem when the installation
 of the dependencies is not needed. Therefore, it is suitable for web services.
 
 Provides support for working with the following models:
 
-- `Pod::Specification` - [podspec files](http://cocoapods.github.com/specification.html).
-- `Pod::Podfile` - [podfile specifications](http://cocoapods.github.com/podfile.html).
+- `Pod::Specification` - [Podspec Syntax Reference](https://guides.cocoapods.org/syntax/podspec.html).
+- `Pod::Podfile` - [Podfile Syntax Reference](https://guides.cocoapods.org/syntax/podfile.html).
 - `Pod::Source` - collections of podspec files like the [CocoaPods Spec repo](https://github.com/CocoaPods/Specs).
 
 The gem also provides support for ancillary features like
@@ -25,10 +25,7 @@ files.
 $ [sudo] gem install cocoapods-core
 ```
 
-The `cocoapods-core` gem requires either:
-
-- Ruby 1.8.7 (shipped with OS X 10.8).
-- Ruby 1.9.3 (recommended).
+The `cocoapods-core` gem requires Ruby 2.6.0 or later.
 
 ## Collaborate
 

data/lib/cocoapods-core/build_type.rb

@@ -0,0 +1,121 @@
+module Pod
+  class BuildType
+    # @return [Array<Symbol>] known packaging options.
+    #
+    KNOWN_PACKAGING_OPTIONS = %i(library framework).freeze
+
+    # @return [Array<Symbol>] known linking options.
+    #
+    KNOWN_LINKAGE_OPTIONS = %i(static dynamic).freeze
+
+    # @return [Symbol] the packaging for this build type, one of #KNOWN_PACKAGING_OPTIONS
+    #
+    attr_reader :packaging
+
+    # @return [Symbol] the linkage for this build type, one of #KNOWN_LINKAGE_OPTIONS
+    #
+    attr_reader :linkage
+
+    attr_reader :hash
+
+    def initialize(linkage: :static, packaging: :library)
+      unless KNOWN_LINKAGE_OPTIONS.include?(linkage)
+        raise ArgumentError, "Invalid linkage option #{linkage.inspect}, valid options are #{KNOWN_LINKAGE_OPTIONS.inspect}"
+      end
+      unless KNOWN_PACKAGING_OPTIONS.include?(packaging)
+        raise ArgumentError, "Invalid packaging option #{packaging.inspect}, valid options are #{KNOWN_PACKAGING_OPTIONS.inspect}"
+      end
+      @packaging = packaging
+      @linkage = linkage
+      @hash = packaging.hash ^ linkage.hash
+    end
+
+    # @return [BuildType] the build type for a dynamic library
+    def self.dynamic_library
+      new(:linkage => :dynamic, :packaging => :library)
+    end
+
+    # @return [BuildType] the build type for a static library
+    #
+    def self.static_library
+      new(:linkage => :static, :packaging => :library)
+    end
+
+    # @return [BuildType] the build type for a dynamic framework
+    #
+    def self.dynamic_framework
+      new(:linkage => :dynamic, :packaging => :framework)
+    end
+
+    # @return [BuildType] the build type for a static framework
+    #
+    def self.static_framework
+      new(:linkage => :static, :packaging => :framework)
+    end
+
+    # @return [Boolean] whether the target is built dynamically
+    #
+    def dynamic?
+      linkage == :dynamic
+    end
+
+    # @return [Boolean] whether the target is built statically
+    #
+    def static?
+      linkage == :static
+    end
+
+    # @return [Boolean] whether the target is built as a framework
+    #
+    def framework?
+      packaging == :framework
+    end
+
+    # @return [Boolean] whether the target is built as a library
+    #
+    def library?
+      packaging == :library
+    end
+
+    # @return [Boolean] whether the target is built as a dynamic framework
+    #
+    def dynamic_framework?
+      dynamic? && framework?
+    end
+
+    # @return [Boolean] whether the target is built as a dynamic library
+    #
+    def dynamic_library?
+      dynamic? && library?
+    end
+
+    # @return [Boolean] whether the target is built as a static framework
+    #
+    def static_framework?
+      static? && framework?
+    end
+
+    # @return [Boolean] whether the target is built as a static library
+    #
+    def static_library?
+      static? && library?
+    end
+
+    def to_s
+      "#{linkage} #{packaging}"
+    end
+
+    def to_hash
+      { :linkage => linkage, :packaging => packaging }
+    end
+
+    def inspect
+      "#<#{self.class} linkage=#{linkage} packaging=#{packaging}>"
+    end
+
+    def ==(other)
+      linkage == other.linkage &&
+        packaging == other.packaging
+    end
+  end
+end

data/lib/cocoapods-core/cdn_source.rb

@@ -0,0 +1,501 @@
+require 'cocoapods-core/source'
+require 'rest'
+require 'concurrent'
+require 'netrc'
+require 'addressable'
+
+module Pod
+  # Subclass of Pod::Source to provide support for CDN-based Specs repositories
+  #
+  class CDNSource < Source
+    include Concurrent
+
+    MAX_NUMBER_OF_RETRIES = (ENV['COCOAPODS_CDN_MAX_NUMBER_OF_RETRIES'] || 5).to_i
+    # Single thread executor for all network activity.
+    HYDRA_EXECUTOR = Concurrent::SingleThreadExecutor.new
+
+    private_constant :HYDRA_EXECUTOR
+
+    # @param [String] repo The name of the repository
+    #
+    def initialize(repo)
+      @check_existing_files_for_update = false
+      # Optimization: we initialize startup_time when the source is first initialized
+      # and then test file modification dates against it. Any file that was touched
+      # after the source was initialized, is considered fresh enough.
+      @startup_time = Time.new
+
+      @version_arrays_by_fragment_by_name = {}
+
+      super(repo)
+    end
+
+    # @return [String] The URL of the source.
+    #
+    def url
+      @url ||= File.read(repo.join('.url')).chomp.chomp('/') + '/'
+    end
+
+    # @return [String] The type of the source.
+    #
+    def type
+      'CDN'
+    end
+
+    def refresh_metadata
+      if metadata.nil?
+        unless repo.exist?
+          debug "CDN: Repo #{name} does not exist!"
+          return
+        end
+
+        specs_dir.mkpath
+        download_file('CocoaPods-version.yml')
+      end
+
+      super
+    end
+
+    def preheat_existing_files
+      files_to_update = files_definitely_to_update + deprecated_local_podspecs - ['deprecated_podspecs.txt']
+      debug "CDN: #{name} Going to update #{files_to_update.count} files"
+
+      concurrent_requests_catching_errors do
+        # Queue all tasks first
+        loaders = files_to_update.map do |file|
+          download_file_async(file)
+        end
+        # Block and wait for all to complete running on Hydra
+        Promises.zip_futures_on(HYDRA_EXECUTOR, *loaders).wait!
+      end
+    end
+
+    def files_definitely_to_update
+      Pathname.glob(repo.join('**/*.{txt,yml}')).map { |f| f.relative_path_from(repo).to_s }
+    end
+
+    def deprecated_local_podspecs
+      download_file('deprecated_podspecs.txt')
+      local_file('deprecated_podspecs.txt', &:to_a).
+        map { |f| Pathname.new(f.chomp) }.
+        select { |f| repo.join(f).exist? }
+    end
+
+    # @return [Pathname] The directory where the specs are stored.
+    #
+    def specs_dir
+      @specs_dir ||= repo + 'Specs'
+    end
+
+    # @!group Querying the source
+    #-------------------------------------------------------------------------#
+
+    # @return [Array<String>] the list of the name of all the Pods.
+    #
+    def pods
+      download_file('all_pods.txt')
+      local_file('all_pods.txt', &:to_a).map(&:chomp)
+    end
+
+    # @return [Array<Version>] all the available versions for the Pod, sorted
+    #         from highest to lowest.
+    #
+    # @param  [String] name
+    #         the name of the Pod.
+    #
+    def versions(name)
+      return nil unless specs_dir
+      raise ArgumentError, 'No name' unless name
+
+      fragment = pod_shard_fragment(name)
+
+      ensure_versions_file_loaded(fragment)
+
+      return @versions_by_name[name] unless @versions_by_name[name].nil?
+
+      pod_path_actual = pod_path(name)
+      pod_path_relative = relative_pod_path(name)
+
+      return nil if @version_arrays_by_fragment_by_name[fragment][name].nil?
+
+      concurrent_requests_catching_errors do
+        loaders = []
+
+        @versions_by_name[name] ||= @version_arrays_by_fragment_by_name[fragment][name].map do |version|
+          # Optimization: ensure all the podspec files at least exist. The correct one will get refreshed
+          # in #specification_path regardless.
+          podspec_version_path_relative = Pathname.new(version).join("#{name}.podspec.json")
+
+          unless pod_path_actual.join(podspec_version_path_relative).exist?
+            # Queue all podspec download tasks first
+            loaders << download_file_async(pod_path_relative.join(podspec_version_path_relative).to_s)
+          end
+
+          begin
+            Version.new(version) if version[0, 1] != '.'
+          rescue ArgumentError
+            raise Informative, 'An unexpected version directory ' \
+            "`#{version}` was encountered for the " \
+            "`#{pod_path_actual}` Pod in the `#{name}` repository."
+          end
+        end.compact.sort.reverse
+
+        # Block and wait for all to complete running on Hydra
+        Promises.zip_futures_on(HYDRA_EXECUTOR, *loaders).wait!
+      end
+
+      @versions_by_name[name]
+    end
+
+    # Returns the path of the specification with the given name and version.
+    #
+    # @param  [String] name
+    #         the name of the Pod.
+    #
+    # @param  [Version,String] version
+    #         the version for the specification.
+    #
+    # @return [Pathname] The path of the specification.
+    #
+    def specification_path(name, version)
+      raise ArgumentError, 'No name' unless name
+      raise ArgumentError, 'No version' unless version
+      unless versions(name).include?(Version.new(version))
+        raise StandardError, "Unable to find the specification #{name} " \
+          "(#{version}) in the #{self.name} source."
+      end
+
+      podspec_version_path_relative = Pathname.new(version.to_s).join("#{name}.podspec.json")
+      relative_podspec = relative_pod_path(name).join(podspec_version_path_relative).to_s
+      download_file(relative_podspec)
+      pod_path(name).join(podspec_version_path_relative)
+    end
+
+    # @return [Array<Specification>] all the specifications contained by the
+    #         source.
+    #
+    def all_specs
+      raise Informative, "Can't retrieve all the specs for a CDN-backed source, it will take forever"
+    end
+
+    # @return [Array<Sets>] the sets of all the Pods.
+    #
+    def pod_sets
+      raise Informative, "Can't retrieve all the pod sets for a CDN-backed source, it will take forever"
+    end
+
+    # @!group Searching the source
+    #-------------------------------------------------------------------------#
+
+    # @return [Set] a set for a given dependency. The set is identified by the
+    #               name of the dependency and takes into account subspecs.
+    #
+    # @note   This method is optimized for fast lookups by name, i.e. it does
+    #         *not* require iterating through {#pod_sets}
+    #
+    # @todo   Rename to #load_set
+    #
+    def search(query)
+      unless specs_dir
+        raise Informative, "Unable to find a source named: `#{name}`"
+      end
+      if query.is_a?(Dependency)
+        query = query.root_name
+      end
+
+      fragment = pod_shard_fragment(query)
+
+      ensure_versions_file_loaded(fragment)
+
+      version_arrays_by_name = @version_arrays_by_fragment_by_name[fragment] || {}
+
+      found = version_arrays_by_name[query].nil? ? nil : query
+
+      if found
+        set = set(query)
+        set if set.specification_name == query
+      end
+    end
+
+    # @return [Array<Set>] The list of the sets that contain the search term.
+    #
+    # @param  [String] query
+    #         the search term. Can be a regular expression.
+    #
+    # @param  [Boolean] full_text_search
+    #         performed using Algolia
+    #
+    # @note   full text search requires to load the specification for each pod,
+    #         and therefore not supported.
+    #
+    def search_by_name(query, full_text_search = false)
+      if full_text_search
+        require 'algoliasearch'
+        begin
+          algolia_result = algolia_search_index.search(query, :attributesToRetrieve => 'name')
+          names = algolia_result['hits'].map { |r| r['name'] }
+          names.map { |n| set(n) }.reject { |s| s.versions.compact.empty? }
+        rescue Algolia::AlgoliaError => e
+          raise Informative, "CDN: #{name} - Cannot perform full-text search because Algolia returned an error: #{e}"
+        end
+      else
+        super(query)
+      end
+    end
+
+    # Check update dates for all existing files.
+    # Does not download non-existing specs, since CDN-backed repo is updated live.
+    #
+    # @param  [Boolean] show_output
+    #
+    # @return  [Array<String>] Always returns empty array, as it cannot know
+    #          everything that actually changed.
+    #
+    def update(_show_output)
+      @check_existing_files_for_update = true
+      begin
+        preheat_existing_files
+      ensure
+        @check_existing_files_for_update = false
+      end
+      []
+    end
+
+    def updateable?
+      true
+    end
+
+    def git?
+      false
+    end
+
+    def indexable?
+      false
+    end
+
+    private
+
+    def ensure_versions_file_loaded(fragment)
+      return if !@version_arrays_by_fragment_by_name[fragment].nil? && !@check_existing_files_for_update
+
+      # Index file that contains all the versions for all the pods in the shard.
+      # We use those because you can't get a directory listing from a CDN.
+      index_file_name = index_file_name_for_fragment(fragment)
+      download_file(index_file_name)
+      versions_raw = local_file(index_file_name, &:to_a).map(&:chomp)
+      @version_arrays_by_fragment_by_name[fragment] = versions_raw.reduce({}) do |hash, row|
+        row = row.split('/')
+        pod = row.shift
+        versions = row
+
+        hash[pod] = versions
+        hash
+      end
+    end
+
+    def algolia_search_index
+      @index ||= begin
+        require 'algoliasearch'
+
+        raise Informative, "Cannot perform full-text search in repo #{name} because it's missing Algolia config" if download_file('AlgoliaSearch.yml').nil?
+        algolia_config = YAMLHelper.load_string(local_file('AlgoliaSearch.yml', &:read))
+
+        client = Algolia::Client.new(:application_id => algolia_config['application_id'], :api_key => algolia_config['api_key'])
+        Algolia::Index.new(algolia_config['index'], client)
+      end
+    end
+
+    def index_file_name_for_fragment(fragment)
+      fragment_joined = fragment.join('_')
+      fragment_joined = '_' + fragment_joined unless fragment.empty?
+      "all_pods_versions#{fragment_joined}.txt"
+    end
+
+    def pod_shard_fragment(pod_name)
+      metadata.path_fragment(pod_name)[0..-2]
+    end
+
+    def local_file_okay?(partial_url)
+      file_path = repo.join(partial_url)
+      File.exist?(file_path) && File.size(file_path) > 0
+    end
+
+    def local_file(partial_url)
+      file_path = repo.join(partial_url)
+      File.open(file_path) do |file|
+        yield file if block_given?
+      end
+    end
+
+    def relative_pod_path(pod_name)
+      pod_path(pod_name).relative_path_from(repo)
+    end
+
+    def download_file(partial_url)
+      # Block the main thread waiting for Hydra to finish
+      #
+      # Used for single-file downloads
+      download_file_async(partial_url).wait!
+    end
+
+    def download_file_async(partial_url)
+      file_remote_url = Addressable::URI.encode(url + partial_url.to_s)
+      path = repo + partial_url
+
+      file_okay = local_file_okay?(partial_url)
+      if file_okay
+        if @startup_time < File.mtime(path)
+          debug "CDN: #{name} Relative path: #{partial_url} modified during this run! Returning local"
+          return Promises.fulfilled_future(partial_url, HYDRA_EXECUTOR)
+        end
+
+        unless @check_existing_files_for_update
+          debug "CDN: #{name} Relative path: #{partial_url} exists! Returning local because checking is only performed in repo update"
+          return Promises.fulfilled_future(partial_url, HYDRA_EXECUTOR)
+        end
+      end
+
+      path.dirname.mkpath
+
+      etag_path = path.sub_ext(path.extname + '.etag')
+
+      etag = File.read(etag_path) if file_okay && File.exist?(etag_path)
+      debug "CDN: #{name} Relative path: #{partial_url}, has ETag? #{etag}" unless etag.nil?
+
+      download_and_save_with_retries_async(partial_url, file_remote_url, etag)
+    end
+
+    def download_and_save_with_retries_async(partial_url, file_remote_url, etag, retries = MAX_NUMBER_OF_RETRIES)
+      path = repo + partial_url
+      etag_path = path.sub_ext(path.extname + '.etag')
+
+      download_task = download_typhoeus_impl_async(file_remote_url, etag).then do |response|
+        case response.response_code
+        when 301, 302
+          redirect_location = response.headers['location']
+          debug "CDN: #{name} Redirecting from #{file_remote_url} to #{redirect_location}"
+          download_and_save_with_retries_async(partial_url, redirect_location, etag)
+        when 304
+          debug "CDN: #{name} Relative path not modified: #{partial_url}"
+          # We need to update the file modification date, as it is later used for freshness
+          # optimization. See #initialize for more information.
+          FileUtils.touch path
+          partial_url
+        when 200
+          File.open(path, 'w') { |f| f.write(response.response_body.force_encoding('UTF-8')) }
+
+          etag_new = response.headers['etag'] unless response.headers.nil?
+          debug "CDN: #{name} Relative path downloaded: #{partial_url}, save ETag: #{etag_new}"
+          File.open(etag_path, 'w') { |f| f.write(etag_new) } unless etag_new.nil?
+          partial_url
+        when 404
+          debug "CDN: #{name} Relative path couldn't be downloaded: #{partial_url} Response: #{response.response_code}"
+          nil
+        when 502, 503, 504
+          # Retryable HTTP errors, usually related to server overloading
+          if retries <= 1
+            raise Informative, "CDN: #{name} URL couldn't be downloaded: #{file_remote_url} Response: #{response.response_code} #{response.response_body}"
+          else
+            debug "CDN: #{name} URL couldn't be downloaded: #{file_remote_url} Response: #{response.response_code} #{response.response_body}, retries: #{retries - 1}"
+            exponential_backoff_async(retries).then do
+              download_and_save_with_retries_async(partial_url, file_remote_url, etag, retries - 1)
+            end
+          end
+        when 0
+          # Non-HTTP errors, usually network layer
+          if retries <= 1
+            raise Informative, "CDN: #{name} URL couldn't be downloaded: #{file_remote_url} Response: #{response.return_message}"
+          else
+            debug "CDN: #{name} URL couldn't be downloaded: #{file_remote_url} Response: #{response.return_message}, retries: #{retries - 1}"
+            exponential_backoff_async(retries).then do
+              download_and_save_with_retries_async(partial_url, file_remote_url, etag, retries - 1)
+            end
+          end
+        else
+          raise Informative, "CDN: #{name} URL couldn't be downloaded: #{file_remote_url} Response: #{response.response_code} #{response.response_body}"
+        end
+      end
+
+      # Calling `Future#run` flattens the chained futures created by retries or redirects
+      #
+      # Does not, in fact, run the task - that is already happening in Hydra at this point
+      download_task.run
+    end
+
+    def exponential_backoff_async(retries)
+      sleep_async(backoff_time(retries))
+    end
+
+    def backoff_time(retries)
+      current_retry = MAX_NUMBER_OF_RETRIES - retries
+      4 * 2**current_retry
+    end
+
+    def sleep_async(seconds)
+      # Async sleep to avoid blocking either the main or the Hydra thread
+      Promises.schedule_on(HYDRA_EXECUTOR, seconds)
+    end
+
+    def download_typhoeus_impl_async(file_remote_url, etag)
+      require 'typhoeus'
+
+      # Create a prefereably HTTP/2 request - the protocol is ultimately responsible for picking
+      # the maximum supported protocol
+      # When debugging with proxy, use the following extra options:
+      # :proxy => 'http://localhost:8888',
+      # :ssl_verifypeer => false,
+      # :ssl_verifyhost => 0,
+      request = Typhoeus::Request.new(
+        file_remote_url,
+        :method => :get,
+        :http_version => :httpv2_0,
+        :timeout => 10,
+        :connecttimeout => 10,
+        :accept_encoding => 'gzip',
+        :netrc => :optional,
+        :netrc_file => Netrc.default_path,
+        :headers => etag.nil? ? {} : { 'If-None-Match' => etag },
+      )
+
+      future = Promises.resolvable_future_on(HYDRA_EXECUTOR)
+      queue_request(request)
+      request.on_complete do |response|
+        future.fulfill(response)
+      end
+
+      # This `Future` should never reject, network errors are exposed on `Typhoeus::Response`
+      future
+    end
+
+    def debug(message)
+      if defined?(Pod::UI)
+        Pod::UI.message(message)
+      else
+        CoreUI.puts(message)
+      end
+    end
+
+    def concurrent_requests_catching_errors
+      yield
+    rescue MultipleErrors => e
+      # aggregated error message from `Concurrent`
+      errors = e.errors
+      raise Informative, "CDN: #{name} Repo update failed - #{e.errors.size} error(s):\n#{errors.join("\n")}"
+    end
+
+    def queue_request(request)
+      @hydra ||= Typhoeus::Hydra.new
+
+      # Queue the request into the Hydra (libcurl reactor).
+      @hydra.queue(request)
+
+      # Cycle the reactor on a separate thread
+      #
+      # The way it works is that if more requests are queued while Hydra is in the `#run`
+      # method, it will keep executing them
+      #
+      # The upcoming calls to `#run` will simply run empty.
+      HYDRA_EXECUTOR.post(@hydra, &:run)
+    end
+  end
+end

data/lib/cocoapods-core/core_ui.rb

@@ -1,18 +1,19 @@
 module Pod
-
   # Manages the UI output so dependent gems can customize it.
   #
   module CoreUI
-
     def self.puts(message)
       STDOUT.puts message
     end
 
+    def self.print(message)
+      STDOUT.print(message)
+    end
+
     def self.warn(message)
       STDERR.puts message
     end
 
     #-------------------------------------------------------------------------#
-
   end
 end