cocoapods-tt 0.0.1

data/lib/cocoapods-tt/native/config.rb

@@ -0,0 +1,366 @@
+require 'active_support/multibyte/unicode'
+
+module Pod
+  # Stores the global configuration of CocoaPods.
+  #
+  class Config
+    # The default settings for the configuration.
+    #
+    # Users can specify custom settings in `~/.cocoapods/config.yaml`.
+    # An example of the contents of this file might look like:
+    #
+    #     ---
+    #     skip_repo_update: true
+    #     new_version_message: false
+    #
+    DEFAULTS = {
+      :verbose             => false,
+      :silent              => false,
+      :skip_download_cache => !ENV['COCOAPODS_SKIP_CACHE'].nil?,
+
+      :new_version_message => ENV['COCOAPODS_SKIP_UPDATE_MESSAGE'].nil?,
+
+      :cache_root          => Pathname.new(Dir.home) + 'Library/Caches/CocoaPods',
+    }
+
+    # Applies the given changes to the config for the duration of the given
+    # block.
+    #
+    # @param [Hash<#to_sym,Object>] changes
+    #        the changes to merge temporarily with the current config
+    #
+    # @yield [] is called while the changes are applied
+    #
+    def with_changes(changes)
+      old = {}
+      changes.keys.each do |key|
+        key = key.to_sym
+        old[key] = send(key) if respond_to?(key)
+      end
+      configure_with(changes)
+      yield if block_given?
+    ensure
+      configure_with(old)
+    end
+
+    public
+
+    #-------------------------------------------------------------------------#
+
+    # @!group UI
+
+    # @return [Bool] Whether CocoaPods should provide detailed output about the
+    #         performed actions.
+    #
+    attr_accessor :verbose
+    alias_method :verbose?, :verbose
+
+    # @return [Bool] Whether CocoaPods should produce not output.
+    #
+    attr_accessor :silent
+    alias_method :silent?, :silent
+
+    # @return [Bool] Whether CocoaPods is allowed to run as root.
+    #
+    attr_accessor :allow_root
+    alias_method :allow_root?, :allow_root
+
+    # @return [Bool] Whether a message should be printed when a new version of
+    #         CocoaPods is available.
+    #
+    attr_accessor :new_version_message
+    alias_method :new_version_message?, :new_version_message
+
+    #-------------------------------------------------------------------------#
+
+    # @!group Installation
+
+    # @return [Bool] Whether the installer should skip the download cache.
+    #
+    attr_accessor :skip_download_cache
+    alias_method :skip_download_cache?, :skip_download_cache
+
+    public
+
+    #-------------------------------------------------------------------------#
+
+    # @!group Cache
+
+    # @return [Pathname] The directory where CocoaPods should cache remote data
+    #         and other expensive to compute information.
+    #
+    attr_accessor :cache_root
+
+    def cache_root
+      @cache_root.mkpath unless @cache_root.exist?
+      @cache_root
+    end
+
+    public
+
+    #-------------------------------------------------------------------------#
+
+    # @!group Initialization
+
+    def initialize(use_user_settings = true)
+      configure_with(DEFAULTS)
+
+      unless ENV['CP_HOME_DIR'].nil?
+        @cache_root = home_dir + 'cache'
+      end
+
+      if use_user_settings && user_settings_file.exist?
+        require 'yaml'
+        user_settings = YAML.load_file(user_settings_file)
+        configure_with(user_settings)
+      end
+
+      unless ENV['CP_CACHE_DIR'].nil?
+        @cache_root = Pathname.new(ENV['CP_CACHE_DIR']).expand_path
+      end
+    end
+
+    def verbose
+      @verbose && !silent
+    end
+
+    public
+
+    #-------------------------------------------------------------------------#
+
+    # @!group Paths
+
+    # @return [Pathname] the directory where repos, templates and configuration
+    #         files are stored.
+    #
+    def home_dir
+      @home_dir ||= Pathname.new(ENV['CP_HOME_DIR'] || '~/.cocoapods').expand_path
+    end
+
+    # @return [Pathname] the directory where the CocoaPods sources are stored.
+    #
+    def repos_dir
+      @repos_dir ||= Pathname.new(ENV['CP_REPOS_DIR'] || (home_dir + 'repos')).expand_path
+    end
+
+    attr_writer :repos_dir
+
+    # @return [Source::Manager] the source manager for the spec repos in `repos_dir`
+    #
+    def sources_manager
+      return @sources_manager if @sources_manager && @sources_manager.repos_dir == repos_dir
+      @sources_manager = Source::Manager.new(repos_dir)
+    end
+
+    # @return [Pathname] the directory where the CocoaPods templates are stored.
+    #
+    def templates_dir
+      @templates_dir ||= Pathname.new(ENV['CP_TEMPLATES_DIR'] || (home_dir + 'templates')).expand_path
+    end
+
+    # @return [Pathname] the root of the CocoaPods installation where the
+    #         Podfile is located.
+    #
+    def installation_root
+      @installation_root ||= begin
+        current_dir = Pathname.new(Dir.pwd.unicode_normalize(:nfkc))
+        current_path = current_dir
+        until current_path.root?
+          if podfile_path_in_dir(current_path)
+            installation_root = current_path
+            unless current_path == current_dir
+              UI.puts("[in #{current_path}]")
+            end
+            break
+          else
+            current_path = current_path.parent
+          end
+        end
+        installation_root || current_dir
+      end
+    end
+
+    attr_writer :installation_root
+    alias_method :project_root, :installation_root
+
+    # @return [Pathname] The root of the sandbox.
+    #
+    def sandbox_root
+      @sandbox_root ||= installation_root + 'Pods'
+    end
+
+    attr_writer :sandbox_root
+    alias_method :project_pods_root, :sandbox_root
+
+    # @return [Sandbox] The sandbox of the current project.
+    #
+    def sandbox
+      @sandbox ||= Sandbox.new(sandbox_root)
+    end
+
+    # @return [Podfile] The Podfile to use for the current execution.
+    # @return [Nil] If no Podfile is available.
+    #
+    def podfile
+      @podfile ||= Podfile.from_file(podfile_path) if podfile_path
+    end
+    attr_writer :podfile
+
+    # @return [Lockfile] The Lockfile to use for the current execution.
+    # @return [Nil] If no Lockfile is available.
+    #
+    def lockfile
+      @lockfile ||= Lockfile.from_file(lockfile_path) if lockfile_path
+    end
+
+    # Returns the path of the Podfile.
+    #
+    # @note The Podfile can be named either `CocoaPods.podfile.yaml`,
+    #       `CocoaPods.podfile` or `Podfile`.  The first two are preferred as
+    #       they allow to specify an OS X UTI.
+    #
+    # @return [Pathname]
+    # @return [Nil]
+    #
+    def podfile_path
+      @podfile_path ||= podfile_path_in_dir(installation_root)
+    end
+
+    # Returns the path of the Lockfile.
+    #
+    # @note The Lockfile is named `Podfile.lock`.
+    #
+    def lockfile_path
+      @lockfile_path ||= installation_root + 'Podfile.lock'
+    end
+
+    # Returns the path of the default Podfile pods.
+    #
+    # @note The file is expected to be named Podfile.default
+    #
+    # @return [Pathname]
+    #
+    def default_podfile_path
+      @default_podfile_path ||= templates_dir + 'Podfile.default'
+    end
+
+    # Returns the path of the default Podfile test pods.
+    #
+    # @note The file is expected to be named Podfile.test
+    #
+    # @return [Pathname]
+    #
+    def default_test_podfile_path
+      @default_test_podfile_path ||= templates_dir + 'Podfile.test'
+    end
+
+    # @return [Pathname] The file to use to cache the search data.
+    #
+    def search_index_file
+      cache_root + 'search_index.json'
+    end
+
+    private
+
+    #-------------------------------------------------------------------------#
+
+    # @!group Private helpers
+
+    # @return [Pathname] The path of the file which contains the user settings.
+    #
+    def user_settings_file
+      home_dir + 'config.yaml'
+    end
+
+    # Sets the values of the attributes with the given hash.
+    #
+    # @param  [Hash{String,Symbol => Object}] values_by_key
+    #         The values of the attributes grouped by key.
+    #
+    # @return [void]
+    #
+    def configure_with(values_by_key)
+      return unless values_by_key
+      values_by_key.each do |key, value|
+        if key.to_sym == :cache_root
+          value = Pathname.new(value).expand_path
+        end
+        instance_variable_set("@#{key}", value)
+      end
+    end
+
+    # @return [Array<String>] The filenames that the Podfile can have ordered
+    #         by priority.
+    #
+    PODFILE_NAMES = [
+      'CocoaPods.podfile.yaml',
+      'CocoaPods.podfile',
+      'Podfile',
+      'Podfile.rb',
+    ].freeze
+
+    public
+
+    # Returns the path of the Podfile in the given dir if any exists.
+    #
+    # @param  [Pathname] dir
+    #         The directory where to look for the Podfile.
+    #
+    # @return [Pathname] The path of the Podfile.
+    # @return [Nil] If not Podfile was found in the given dir
+    #
+    def podfile_path_in_dir(dir)
+      PODFILE_NAMES.each do |filename|
+        candidate = dir + filename
+        if candidate.file?
+          return candidate
+        end
+      end
+      nil
+    end
+
+    # Excludes the given dir from Time Machine backups.
+    #
+    # @param  [Pathname] dir
+    #         The directory to exclude from Time Machine backups.
+    #
+    # @return [void]
+    #
+    def exclude_from_backup(dir)
+      return if Gem.win_platform?
+      system('tmutil', 'addexclusion', dir.to_s, %i(out err) => File::NULL)
+    end
+
+    public
+
+    #-------------------------------------------------------------------------#
+
+    # @!group Singleton
+
+    # @return [Config] the current config instance creating one if needed.
+    #
+    def self.instance
+      @instance ||= new
+    end
+
+    # Sets the current config instance. If set to nil the config will be
+    # recreated when needed.
+    #
+    # @param  [Config, Nil] the instance.
+    #
+    # @return [void]
+    #
+    class << self
+      attr_writer :instance
+    end
+
+    # Provides support for accessing the configuration instance in other
+    # scopes.
+    #
+    module Mixin
+      def config
+        Config.instance
+      end
+    end
+  end
+end

data/lib/cocoapods-tt/native/core_overrides.rb

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

data/lib/cocoapods-tt/native/downloader/cache.rb

@@ -0,0 +1,322 @@
+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
+
+      # Convenience method for acquiring a shared lock to safely read from the
+      # cache. See `Cache.lock` for more details.
+      #
+      # @param  [Pathname] location
+      #         the path to require a lock for.
+      #
+      # @param  [block] &block
+      #         the block to execute inside the lock.
+      #
+      # @return [void]
+      #
+      def self.read_lock(location, &block)
+        Cache.lock(location, File::LOCK_SH, &block)
+      end
+
+      # Convenience method for acquiring an exclusive lock to safely write to
+      # the cache. See `Cache.lock` for more details.
+      #
+      # @param  [Pathname] location
+      #         the path to require a lock for.
+      #
+      # @param  [block] &block
+      #         the block to execute inside the lock.
+      #
+      # @return [void]
+      #
+      def self.write_lock(location, &block)
+        Cache.lock(location, File::LOCK_EX, &block)
+      end
+
+      # Creates a .lock file at `location`, aquires a lock of type
+      # `lock_type`, checks that it is valid, and executes passed block while
+      # holding on to that lock. Afterwards, the .lock file is deleted, which is
+      # why validation of the lock is necessary, as you might have a lock on a
+      # file that doesn't exist on the filesystem anymore.
+      #
+      # @param  [Pathname] location
+      #         the path to require a lock for.
+      #
+      # @param  [locking_constant] lock_type
+      #         the type of lock, either exclusive (File::LOCK_EX) or shared
+      #         (File::LOCK_SH).
+      #
+      # @return [void]
+      #
+      def self.lock(location, lock_type)
+        raise ArgumentError, 'no block given' unless block_given?
+        lockfile = "#{location}.lock"
+        f = nil
+        loop do
+          f.close if f
+          f = File.open(lockfile, File::CREAT, 0o644)
+          f.flock(lock_type)
+          break if Cache.valid_lock?(f, lockfile)
+        end
+        begin
+          yield location
+        ensure
+          if lock_type == File::LOCK_SH
+            f.flock(File::LOCK_EX)
+            File.delete(lockfile) if Cache.valid_lock?(f, lockfile)
+          else
+            File.delete(lockfile)
+          end
+          f.close
+        end
+      end
+
+      # Checks that the lock is on a file that still exists on the filesystem.
+      #
+      # @param  [File] file
+      #         the actual file that we have a lock for.
+      #
+      # @param  [String] filename
+      #         the filename of the file that we have a lock for.
+      #
+      # @return [Boolean]
+      #         true if `filename` still exists and is the same file as `file`
+      #
+      def self.valid_lock?(file, filename)
+        file.stat.ino == File.stat(filename).ino
+      rescue Errno::ENOENT
+        false
+      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)
+        Pathname.new(path.to_path + '.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
+        Cache.write_lock(destination) do
+          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
+      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
+        Cache.write_lock(path) do
+          path.open('w') { |f| f.write spec.to_pretty_json }
+        end
+      end
+    end
+  end
+end