xcocoapods 1.5.3

data/lib/cocoapods/downloader/response.rb

@@ -0,0 +1,16 @@
+module Pod
+  module Downloader
+    # A response to a download request.
+    #
+    # @attr [Pathname] location
+    #       the location where this downloaded pod is stored on disk.
+    #
+    # @attr [Specification] spec
+    #       the specification that describes this downloaded pod.
+    #
+    # @attr [Hash<Symbol, String>] checkout_options
+    #       the downloader parameters necessary to recreate this exact download.
+    #
+    Response = Struct.new(:location, :spec, :checkout_options)
+  end
+end

data/lib/cocoapods/executable.rb

@@ -0,0 +1,222 @@
+module Pod
+  # Module which provides support for running executables.
+  #
+  # In a class it can be used as:
+  #
+  #     extend Executable
+  #     executable :git
+  #
+  # This will create two methods `git` and `git!` both accept a command but
+  # the later will raise on non successful executions. The methods return the
+  # output of the command.
+  #
+  module Executable
+    # Creates the methods for the executable with the given name.
+    #
+    # @param  [Symbol] name
+    #         the name of the executable.
+    #
+    # @return [void]
+    #
+    def executable(name)
+      define_method(name) do |*command|
+        Executable.execute_command(name, Array(command).flatten, false)
+      end
+
+      define_method(name.to_s + '!') do |*command|
+        Executable.execute_command(name, Array(command).flatten, true)
+      end
+    end
+
+    # Executes the given command displaying it if in verbose mode.
+    #
+    # @param  [String] executable
+    #         The binary to use.
+    #
+    # @param  [Array<#to_s>] command
+    #         The command to send to the binary.
+    #
+    # @param  [Bool] raise_on_failure
+    #         Whether it should raise if the command fails.
+    #
+    # @raise  If the executable could not be located.
+    #
+    # @raise  If the command fails and the `raise_on_failure` is set to true.
+    #
+    # @return [String] the output of the command (STDOUT and STDERR).
+    #
+    def self.execute_command(executable, command, raise_on_failure = true)
+      bin = which!(executable)
+
+      command = command.map(&:to_s)
+      full_command = "#{bin} #{command.join(' ')}"
+
+      if Config.instance.verbose?
+        UI.message("$ #{full_command}")
+        stdout = Indenter.new(STDOUT)
+        stderr = Indenter.new(STDERR)
+      else
+        stdout = Indenter.new
+        stderr = Indenter.new
+      end
+
+      status = popen3(bin, command, stdout, stderr)
+      stdout = stdout.join
+      stderr = stderr.join
+      output = stdout + stderr
+      unless status.success?
+        if raise_on_failure
+          raise Informative, "#{full_command}\n\n#{output}"
+        else
+          UI.message("[!] Failed: #{full_command}".red)
+        end
+      end
+
+      output
+    end
+
+    # Returns the absolute path to the binary with the given name on the current
+    # `PATH`, or `nil` if none is found.
+    #
+    # @param  [String] program
+    #         The name of the program being searched for.
+    #
+    # @return [String,Nil] The absolute path to the given program, or `nil` if
+    #                      it wasn't found in the current `PATH`.
+    #
+    def self.which(program)
+      program = program.to_s
+      paths = ENV.fetch('PATH') { '' }.split(File::PATH_SEPARATOR)
+      paths.unshift('./')
+      paths.uniq!
+      paths.each do |path|
+        bin = File.expand_path(program, path)
+        if File.file?(bin) && File.executable?(bin)
+          return bin
+        end
+      end
+      nil
+    end
+
+    # Returns the absolute path to the binary with the given name on the current
+    # `PATH`, or raises if none is found.
+    #
+    # @param  [String] program
+    #         The name of the program being searched for.
+    #
+    # @return [String] The absolute path to the given program.
+    #
+    def self.which!(program)
+      which(program).tap do |bin|
+        raise Informative, "Unable to locate the executable `#{program}`" unless bin
+      end
+    end
+
+    # Runs the given command, capturing the desired output.
+    #
+    # @param  [String] bin
+    #         The binary to use.
+    #
+    # @param  [Array<#to_s>] command
+    #         The command to send to the binary.
+    #
+    # @param  [Symbol] capture
+    #         Whether it should raise if the command fails.
+    #
+    # @raise  If the executable could not be located.
+    #
+    # @return [(String, Process::Status)]
+    #         The desired captured output from the command, and the status from
+    #         running the command.
+    #
+    def self.capture_command(executable, command, capture: :merge)
+      bin = which!(executable)
+
+      require 'open3'
+      command = command.map(&:to_s)
+      case capture
+      when :merge then Open3.capture2e(bin, *command)
+      when :both then Open3.capture3(bin, *command)
+      when :out then Open3.capture3(bin, *command).values_at(0, -1)
+      when :err then Open3.capture3(bin, *command).drop(1)
+      when :none then Open3.capture3(bin, *command).last
+      end
+    end
+
+    private
+
+    def self.popen3(bin, command, stdout, stderr)
+      require 'open3'
+      Open3.popen3(bin, *command) do |i, o, e, t|
+        reader(o, stdout)
+        reader(e, stderr)
+        i.close
+
+        status = t.value
+
+        o.flush
+        e.flush
+        sleep(0.01)
+
+        status
+      end
+    end
+
+    def self.reader(input, output)
+      Thread.new do
+        buf = ''
+        begin
+          loop do
+            buf << input.readpartial(4096)
+            loop do
+              string, separator, buf = buf.partition(/[\r\n]/)
+              if separator.empty?
+                buf = string
+                break
+              end
+              output << (string << separator)
+            end
+          end
+        rescue EOFError
+          output << (buf << $/) unless buf.empty?
+        end
+      end
+    end
+
+    #-------------------------------------------------------------------------#
+
+    # Helper class that allows to write to an {IO} instance taking into account
+    # the UI indentation level.
+    #
+    class Indenter < ::Array
+      # @return [Fixnum] The indentation level of the UI.
+      #
+      attr_reader :indent
+
+      # @return [IO] the {IO} to which the output should be printed.
+      #
+      attr_reader :io
+
+      # Init a new Indenter
+      #
+      # @param [IO] io @see io
+      #
+      def initialize(io = nil)
+        @io = io
+        @indent = ' ' * UI.indentation_level
+      end
+
+      # Stores a portion of the output and prints it to the {IO} instance.
+      #
+      # @param  [String] value
+      #         the output to print.
+      #
+      # @return [void]
+      #
+      def <<(value)
+        super
+        io << "#{indent}#{value}" if io
+      end
+    end
+  end
+end

data/lib/cocoapods/external_sources.rb

@@ -0,0 +1,57 @@
+require 'cocoapods/external_sources/abstract_external_source'
+require 'cocoapods/external_sources/downloader_source'
+require 'cocoapods/external_sources/path_source'
+require 'cocoapods/external_sources/podspec_source'
+
+module Pod
+  # Provides support for initializing the correct concrete class of an external
+  # source.
+  #
+  module ExternalSources
+    # Instantiate a matching {AbstractExternalSource} for a given dependency.
+    #
+    # @param  [Dependency] dependency
+    #         the dependency
+    #
+    # @param  [String] podfile_path
+    #         @see AbstractExternalSource#podfile_path
+    #
+    # @param  [Boolean] can_cache
+    #         @see AbstractExternalSource#can_cache
+    #
+    # @return [AbstractExternalSource] an initialized instance of the concrete
+    #         external source class associated with the option specified in the
+    #         hash.
+    #
+    def self.from_dependency(dependency, podfile_path, can_cache)
+      from_params(dependency.external_source, dependency, podfile_path, can_cache)
+    end
+
+    def self.from_params(params, dependency, podfile_path, can_cache)
+      name = dependency.root_name
+      if klass = concrete_class_from_params(params)
+        klass.new(name, params, podfile_path, can_cache)
+      else
+        msg = "Unknown external source parameters for `#{name}`: `#{params}`"
+        raise Informative, msg
+      end
+    end
+
+    # Get the class to represent the defined source type of a dependency
+    #
+    # @param  [Array<Symbol>] params
+    #         the source params of the dependency
+    #
+    # @return [Class]
+    #
+    def self.concrete_class_from_params(params)
+      if params.key?(:podspec)
+        PodspecSource
+      elsif params.key?(:path)
+        PathSource
+      elsif Downloader.strategy_from_options(params)
+        DownloaderSource
+      end
+    end
+  end
+end

data/lib/cocoapods/external_sources/abstract_external_source.rb

@@ -0,0 +1,205 @@
+module Pod
+  module ExternalSources
+    # Abstract class that defines the common behaviour of external sources.
+    #
+    class AbstractExternalSource
+      # @return [String] the name of the Pod described by this external source.
+      #
+      attr_reader :name
+
+      # @return [Hash{Symbol => String}] the hash representation of the
+      #         external source.
+      #
+      attr_reader :params
+
+      # @return [String] the path where the podfile is defined to resolve
+      #         relative paths.
+      #
+      attr_reader :podfile_path
+
+      # @return [Boolean] Whether the source is allowed to touch the cache.
+      #
+      attr_reader :can_cache
+      alias_method :can_cache?, :can_cache
+
+      # Initialize a new instance
+      #
+      # @param [String] name @see #name
+      # @param [Hash] params @see #params
+      # @param [String] podfile_path @see #podfile_path
+      # @param [Boolean] can_cache @see #can_cache
+      #
+      def initialize(name, params, podfile_path, can_cache = true)
+        @name = name
+        @params = params
+        @podfile_path = podfile_path
+        @can_cache = can_cache
+      end
+
+      # @return [Bool] whether an external source source is equal to another
+      #         according to the {#name} and to the {#params}.
+      #
+      def ==(other)
+        return false if other.nil?
+        name == other.name && params == other.params
+      end
+
+      public
+
+      # @!group Subclasses hooks
+
+      # Fetches the external source from the remote according to the params.
+      #
+      # @param  [Sandbox] _sandbox
+      #         the sandbox where the specification should be stored.
+      #
+      # @return [void]
+      #
+      def fetch(_sandbox)
+        raise 'Abstract method'
+      end
+
+      # @return [String] a string representation of the source suitable for UI.
+      #
+      def description
+        raise 'Abstract method'
+      end
+
+      protected
+
+      # Return the normalized path for a podspec for a relative declared path.
+      #
+      # @param  [String] declared_path
+      #         The path declared in the podfile.
+      #
+      # @return [String] The uri of the podspec appending the name of the file
+      #         and expanding it if necessary.
+      #
+      # @note   If the declared path is expanded only if the represents a path
+      #         relative to the file system.
+      #
+      def normalized_podspec_path(declared_path)
+        extension = File.extname(declared_path)
+        if extension == '.podspec' || extension == '.json'
+          path_with_ext = declared_path
+        else
+          path_with_ext = "#{declared_path}/#{name}.podspec"
+        end
+        podfile_dir = File.dirname(podfile_path || '')
+        File.expand_path(path_with_ext, podfile_dir)
+      end
+
+      private
+
+      # @! Subclasses helpers
+
+      # Pre-downloads a Pod passing the options to the downloader and informing
+      # the sandbox.
+      #
+      # @param  [Sandbox] sandbox
+      #         The sandbox where the Pod should be downloaded.
+      #
+      # @note   To prevent a double download of the repository the pod is
+      #         marked as pre-downloaded indicating to the installer that only
+      #         clean operations are needed.
+      #
+      # @todo  The downloader configuration is the same of the
+      #        #{PodSourceInstaller} and it needs to be kept in sync.
+      #
+      # @return [void]
+      #
+      def pre_download(sandbox)
+        title = "Pre-downloading: `#{name}` #{description}"
+        UI.titled_section(title,  :verbose_prefix => '-> ') do
+          target = sandbox.pod_dir(name)
+          begin
+            download_result = Downloader.download(download_request, target, :can_cache => can_cache)
+          rescue Pod::DSLError => e
+            raise Informative, "Failed to load '#{name}' podspec: #{e.message}"
+          rescue => e
+            raise Informative, "Failed to download '#{name}': #{e.message}"
+          end
+
+          spec = download_result.spec
+          raise Informative, "Unable to find a specification for '#{name}'." unless spec
+
+          # since the podspec might be cleaned, we want the checksum to refer
+          # to the json in the sandbox
+          spec.defined_in_file = nil
+
+          store_podspec(sandbox, spec)
+          sandbox.store_pre_downloaded_pod(name)
+          sandbox.store_checkout_source(name, download_result.checkout_options)
+        end
+      end
+
+      def download_request
+        Downloader::Request.new(
+          :name => name,
+          :params => params,
+        )
+      end
+
+      # Stores the podspec in the sandbox and marks it as from an external
+      # source.
+      #
+      # @param  [Sandbox] sandbox
+      #         The sandbox where the specification should be stored.
+      #
+      # @param  [Pathname, String, Specification] spec
+      #         The path of the specification or its contents.
+      #
+      # @note   All the concrete implementations of #{fetch} should invoke this
+      #         method.
+      #
+      # @note   The sandbox ensures that the podspec exists and that the names
+      #         match.
+      #
+      # @return [void]
+      #
+      def store_podspec(sandbox, spec, json = false)
+        begin
+          spec = case spec
+                 when Pathname
+                   Specification.from_file(spec)
+                 when String
+                   path = "#{name}.podspec"
+                   path << '.json' if json
+                   Specification.from_string(spec, path).tap { |s| s.defined_in_file = nil }
+                 when Specification
+                   spec.dup
+                 else
+                   raise "Unknown spec type: #{spec}"
+                 end
+        rescue Pod::DSLError => e
+          raise Informative, "Failed to load '#{name}' podspec: #{e.message}"
+        end
+
+        validate_podspec(spec)
+        sandbox.store_podspec(name, spec, true, true)
+      end
+
+      def validate_podspec(podspec)
+        defined_in_file = podspec.defined_in_file
+        podspec.defined_in_file = nil
+
+        validator = validator_for_podspec(podspec)
+        validator.quick = true
+        validator.allow_warnings = true
+        validator.ignore_public_only_results = true
+        Config.instance.with_changes(:silent => true) do
+          validator.validate
+        end
+        unless validator.validated?
+          raise Informative, "The `#{name}` pod failed to validate due to #{validator.failure_reason}:\n#{validator.results_message}"
+        end
+      ensure
+        podspec.defined_in_file = defined_in_file
+      end
+
+      def validator_for_podspec(podspec)
+        Validator.new(podspec, [], [])
+      end
+    end
+  end
+end