cocoapods-tt 0.0.1

data/lib/cocoapods-tt/native/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

data/lib/cocoapods-tt/native/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-tt/native/downloader.rb

@@ -0,0 +1,192 @@
+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
+          Cache.read_lock(result.location) do
+            FileUtils.rm_rf target
+            FileUtils.cp_r(result.location, target)
+          end
+        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-tt/native/executable.rb

@@ -0,0 +1,247 @@
+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)
+      if File.basename(bin) == 'tar.exe'
+        # Tar on Windows needs --force-local
+        command.push('--force-local')
+      end
+      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 Gem.win_platform?
+          bin += '.exe'
+        end
+        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] executable
+    #         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.
+    #
+    # @param  [Hash] env
+    #         Environment variables to be set for the command.
+    #
+    # @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, env: {}, **kwargs)
+      bin = which!(executable)
+
+      require 'open3'
+      command = command.map(&:to_s)
+      case capture
+      when :merge then Open3.capture2e(env, [bin, bin], *command, **kwargs)
+      when :both then Open3.capture3(env, [bin, bin], *command, **kwargs)
+      when :out then Open3.capture3(env, [bin, bin], *command, **kwargs).values_at(0, -1)
+      when :err then Open3.capture3(env, [bin, bin], *command, **kwargs).drop(1)
+      when :none then Open3.capture3(env, [bin, bin], *command, **kwargs).last
+      end
+    end
+
+    # (see Executable.capture_command)
+    #
+    # @raise  If running the command fails
+    #
+    def self.capture_command!(executable, command, **kwargs)
+      capture_command(executable, command, **kwargs).tap do |result|
+        result = Array(result)
+        status = result.last
+        unless status.success?
+          output = result[0..-2].join
+          raise Informative, "#{executable} #{command.join(' ')}\n\n#{output}".strip
+        end
+      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, IOError
+          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