cocoapods-tt 0.0.1

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

@@ -0,0 +1,470 @@
+require 'fileutils'
+
+module Pod
+  # The sandbox provides support for the directory that CocoaPods uses for an
+  # installation. In this directory the Pods projects, the support files and
+  # the sources of the Pods are stored.
+  #
+  # CocoaPods assumes to have control of the sandbox.
+  #
+  # Once completed the sandbox will have the following file structure:
+  #
+  #     Pods
+  #     |
+  #     +-- Headers
+  #     |   +-- Private
+  #     |   |   +-- [Pod Name]
+  #     |   +-- Public
+  #     |       +-- [Pod Name]
+  #     |
+  #     +-- Local Podspecs
+  #     |   +-- External Sources
+  #     |   +-- Normal Sources
+  #     |
+  #     +-- Target Support Files
+  #     |   +-- [Target Name]
+  #     |       +-- Pods-acknowledgements.markdown
+  #     |       +-- Pods-acknowledgements.plist
+  #     |       +-- Pods-dummy.m
+  #     |       +-- Pods-prefix.pch
+  #     |       +-- Pods.xcconfig
+  #     |
+  #     +-- [Pod Name]
+  #     |
+  #     +-- Manifest.lock
+  #     |
+  #     +-- Pods.xcodeproj
+  #  (if installation option 'generate_multiple_pod_projects' is enabled)
+  #     |
+  #     +-- PodTarget1.xcodeproj
+  #     |
+  #    ...
+  #     |
+  #     +-- PodTargetN.xcodeproj
+  #
+  #
+  class Sandbox
+    autoload :FileAccessor,  'cocoapods/sandbox/file_accessor'
+    autoload :HeadersStore,  'cocoapods/sandbox/headers_store'
+    autoload :PathList,      'cocoapods/sandbox/path_list'
+    autoload :PodDirCleaner, 'cocoapods/sandbox/pod_dir_cleaner'
+    autoload :PodspecFinder, 'cocoapods/sandbox/podspec_finder'
+
+    # @return [Pathname] the root of the sandbox.
+    #
+    attr_reader :root
+
+    # @return [HeadersStore] the header directory for the user targets.
+    #
+    attr_reader :public_headers
+
+    # Initialize a new instance
+    #
+    # @param [String, Pathname] root @see #root
+    #
+    def initialize(root)
+      FileUtils.mkdir_p(root)
+      @root = Pathname.new(root).realpath
+      @public_headers = HeadersStore.new(self, 'Public', :public)
+      @predownloaded_pods = []
+      @checkout_sources = {}
+      @development_pods = {}
+      @pods_with_absolute_path = []
+      @stored_podspecs = {}
+    end
+
+    # @return [Lockfile] the manifest which contains the information about the
+    #         installed pods or `nil` if one is not present.
+    #
+    def manifest
+      @manifest ||= begin
+        Lockfile.from_file(manifest_path) if manifest_path.exist?
+      end
+    end
+
+    # Removes the files of the Pod with the given name from the sandbox.
+    #
+    # @return [void]
+    #
+    def clean_pod(name)
+      root_name = Specification.root_name(name)
+      unless local?(root_name)
+        path = pod_dir(name)
+        path.rmtree if path.exist?
+      end
+      podspec_path = specification_path(name)
+      podspec_path.rmtree if podspec_path
+      pod_target_project_path = pod_target_project_path(name)
+      pod_target_project_path.rmtree if pod_target_project_path.exist?
+    end
+
+    # Prepares the sandbox for a new installation removing any file that will
+    # be regenerated and ensuring that the directories exists.
+    #
+    def prepare
+      FileUtils.mkdir_p(headers_root)
+      FileUtils.mkdir_p(sources_root)
+      FileUtils.mkdir_p(specifications_root)
+      FileUtils.mkdir_p(target_support_files_root)
+    end
+
+    # @return [String] a string representation suitable for debugging.
+    #
+    def inspect
+      "#<#{self.class}> with root #{root}"
+    end
+
+    #-------------------------------------------------------------------------#
+
+    public
+
+    # @!group Paths
+
+    # @return [Pathname] the path of the manifest.
+    #
+    def manifest_path
+      root + 'Manifest.lock'
+    end
+
+    # @return [Pathname] the path of the Pods project.
+    #
+    def project_path
+      root + 'Pods.xcodeproj'
+    end
+
+    # @return [Pathname] the path of the installation cache.
+    #
+    def project_installation_cache_path
+      root.join('.project_cache', 'installation_cache.yaml')
+    end
+
+    # @return [Pathname] the path of the metadata cache.
+    #
+    def project_metadata_cache_path
+      root.join('.project_cache', 'metadata_cache.yaml')
+    end
+
+    # @return [Pathname] the path of the version cache.
+    #
+    def project_version_cache_path
+      root.join('.project_cache', 'version')
+    end
+
+    # @param [String] pod_target_name
+    # Name of the pod target used to generate the path of its Xcode project.
+    #
+    # @return [Pathname] the path of the project for a pod target.
+    #
+    def pod_target_project_path(pod_target_name)
+      root + "#{pod_target_name}.xcodeproj"
+    end
+
+    # Returns the path for the directory where the support files of
+    # a target are stored.
+    #
+    # @param  [String] name
+    #         The name of the target.
+    #
+    # @return [Pathname] the path of the support files.
+    #
+    def target_support_files_dir(name)
+      target_support_files_root + name
+    end
+
+    # Returns the path where the Pod with the given name is stored, taking into
+    # account whether the Pod is locally sourced.
+    #
+    # @param  [String] name
+    #         The name of the Pod.
+    #
+    # @return [Pathname] the path of the Pod.
+    #
+    def pod_dir(name)
+      root_name = Specification.root_name(name)
+      if local?(root_name)
+        Pathname.new(development_pods[root_name].dirname)
+      else
+        sources_root + root_name
+      end
+    end
+
+    # Returns true if the path as originally specified was absolute.
+    #
+    # @param  [String] name
+    #
+    # @return [Bool] true if originally absolute
+    #
+    def local_path_was_absolute?(name)
+      @pods_with_absolute_path.include? name
+    end
+
+    # @return [Pathname] The directory where headers are stored.
+    #
+    def headers_root
+      root + 'Headers'
+    end
+
+    # @return [Pathname] The directory where the downloaded sources of
+    #         the Pods are stored.
+    #
+    def sources_root
+      root
+    end
+
+    # @return [Pathname] the path for the directory where the
+    #         specifications are stored.
+    #
+    def specifications_root
+      root + 'Local Podspecs'
+    end
+
+    # @return [Pathname] The directory where the files generated by
+    #         CocoaPods to support the umbrella targets are stored.
+    #
+    def target_support_files_root
+      root + 'Target Support Files'
+    end
+
+    #-------------------------------------------------------------------------#
+
+    public
+
+    # @!group Specification store
+
+    # Returns the specification for the Pod with the given name.
+    #
+    # @param  [String] name
+    #         the name of the Pod for which the specification is requested.
+    #
+    # @return [Specification] the specification if the file is found.
+    #
+    def specification(name)
+      @stored_podspecs[name] ||= if file = specification_path(name)
+                                   original_path = development_pods[name]
+                                   Specification.from_file(original_path || file)
+      end
+    end
+
+    # Returns the path of the specification for the Pod with the
+    # given name, if one is stored.
+    #
+    # @param  [String] name
+    #         the name of the Pod for which the podspec file is requested.
+    #
+    # @return [Pathname] the path or nil.
+    # @return [Nil] if the podspec is not stored.
+    #
+    def specification_path(name)
+      name = Specification.root_name(name)
+      path = specifications_root + "#{name}.podspec"
+      if path.exist?
+        path
+      else
+        path = specifications_root + "#{name}.podspec.json"
+        if path.exist?
+          path
+        end
+      end
+    end
+
+    # Stores a specification in the `Local Podspecs` folder.
+    #
+    # @param  [String] name
+    #         the name of the pod
+    #
+    # @param  [String, Pathname, Specification] podspec
+    #         The contents of the specification (String) or the path to a
+    #         podspec file (Pathname).
+    #
+    # @return [void]
+    #
+    #
+    def store_podspec(name, podspec, _external_source = false, json = false)
+      file_name = json ? "#{name}.podspec.json" : "#{name}.podspec"
+      output_path = specifications_root + file_name
+
+      spec =
+        case podspec
+        when String
+          Sandbox.update_changed_file(output_path, podspec)
+          Specification.from_file(output_path)
+        when Pathname
+          unless podspec.exist?
+            raise Informative, "No podspec found for `#{name}` in #{podspec}"
+          end
+          FileUtils.copy(podspec, output_path)
+          Specification.from_file(podspec)
+        when Specification
+          raise ArgumentError, 'can only store Specification objects as json' unless json
+          Sandbox.update_changed_file(output_path, podspec.to_pretty_json)
+          podspec.dup
+        else
+          raise ArgumentError, "Unknown type for podspec: #{podspec.inspect}"
+        end
+
+      # we force the file to be the file in the sandbox, so specs that have been serialized to
+      # json maintain a consistent checksum.
+      # this is safe to do because `spec` is always a clean instance
+      spec.defined_in_file = output_path
+
+      unless spec.name == name
+        raise Informative, "The name of the given podspec `#{spec.name}` doesn't match the expected one `#{name}`"
+      end
+      @stored_podspecs[spec.name] = spec
+    end
+
+    #-------------------------------------------------------------------------#
+
+    public
+
+    # @!group Pods information
+
+    # Marks a Pod as pre-downloaded
+    #
+    # @param  [String] name
+    #         The name of the Pod.
+    #
+    # @return [void]
+    #
+    def store_pre_downloaded_pod(name)
+      root_name = Specification.root_name(name)
+      predownloaded_pods << root_name
+    end
+
+    # @return [Array<String>] The names of the pods that have been
+    #         pre-downloaded from an external source.
+    #
+    attr_reader :predownloaded_pods
+
+    # Checks if a Pod has been pre-downloaded by the resolver in order to fetch
+    # the podspec.
+    #
+    # @param  [String] name
+    #         The name of the Pod.
+    #
+    # @return [Bool] Whether the Pod has been pre-downloaded.
+    #
+    def predownloaded?(name)
+      root_name = Specification.root_name(name)
+      predownloaded_pods.include?(root_name)
+    end
+
+    #--------------------------------------#
+
+    # Stores the local path of a Pod.
+    #
+    # @param  [String] name
+    #         The name of the Pod.
+    #
+    # @param  [Hash] source
+    #         The hash which contains the options as returned by the
+    #         downloader.
+    #
+    # @return [void]
+    #
+    def store_checkout_source(name, source)
+      root_name = Specification.root_name(name)
+      checkout_sources[root_name] = source
+    end
+
+    # Removes the checkout source of a Pod.
+    #
+    # @param  [String] name
+    #         The name of the Pod.
+    #
+    # @return [void]
+    #
+    def remove_checkout_source(name)
+      root_name = Specification.root_name(name)
+      checkout_sources.delete(root_name)
+    end
+
+    # Removes local podspec a Pod.
+    #
+    # @param  [String] name
+    #         The name of the Pod.
+    #
+    # @return [void]
+    #
+    def remove_local_podspec(name)
+      local_podspec = specification_path(name)
+      FileUtils.rm(local_podspec) if local_podspec
+    end
+
+    # @return [Hash{String=>Hash}] The options necessary to recreate the exact
+    #         checkout of a given Pod grouped by its name.
+    #
+    attr_reader :checkout_sources
+
+    #--------------------------------------#
+
+    # Stores the local path of a Pod.
+    #
+    # @param  [String] name
+    #         The name of the Pod.
+    #
+    # @param  [Pathname, String] path
+    #         The path to the local Podspec
+    #
+    # @param  [Bool] was_absolute
+    #         True if the specified local path was absolute.
+    #
+    # @return [void]
+    #
+    def store_local_path(name, path, was_absolute = false)
+      root_name = Specification.root_name(name)
+      path = Pathname.new(path) unless path.is_a?(Pathname)
+      development_pods[root_name] = path
+      @pods_with_absolute_path << root_name if was_absolute
+    end
+
+    # @return [Hash{String=>Pathname}] The path of the Pods' podspecs with a local source
+    #         grouped by their root name.
+    #
+    attr_reader :development_pods
+
+    # Checks if a Pod is locally sourced?
+    #
+    # @param  [String] name
+    #         The name of the Pod.
+    #
+    # @return [Bool] Whether the Pod is locally sourced.
+    #
+    def local?(name)
+      !local_podspec(name).nil?
+    end
+
+    # @param  [String] name
+    #         The name of a locally specified Pod
+    #
+    # @return [Pathname] Path to the local Podspec of the Pod
+    #
+    def local_podspec(name)
+      root_name = Specification.root_name(name)
+      development_pods[root_name]
+    end
+
+    # @!group Convenience Methods
+
+    # Writes a file if it does not exist or if its contents have changed.
+    #
+    # @param  [Pathname] path
+    #         The path to read from and write to.
+    #
+    # @param  [String] contents
+    #         The contents to write if they do not match or the file does not exist.
+    #
+    # @return [void]
+    #
+    def self.update_changed_file(path, contents)
+      if path.exist?
+        content_stream = StringIO.new(contents)
+        identical = File.open(path, 'rb') { |f| FileUtils.compare_stream(f, content_stream) }
+        return if identical
+      end
+      File.open(path, 'w') { |f| f.write(contents) }
+    end
+
+    #-------------------------------------------------------------------------#
+  end
+end

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

@@ -0,0 +1,221 @@
+require 'cocoapods-core/source'
+require 'cocoapods/open-uri'
+require 'netrc'
+require 'set'
+require 'rest'
+require 'yaml'
+
+module Pod
+  class Source
+    class Manager
+      # Returns the source whose {Source#url} is equal to `url`, adding the repo
+      # in a manner similarly to `pod repo add` if it is not found.
+      #
+      # @raise  If no source with the given `url` could be created,
+      #
+      # @return [Source] The source whose {Source#url} is equal to `url`,
+      #
+      # @param  [String] url
+      #         The URL of the source.
+      #
+      def find_or_create_source_with_url(url)
+        source_with_url(url) || create_source_with_url(url)
+      end
+
+      # Adds the source whose {Source#url} is equal to `url`,
+      # in a manner similarly to `pod repo add` if it is not found.
+      #
+      # @raise  If no source with the given `url` could be created,
+      #
+      # @return [Source] The source whose {Source#url} is equal to `url`,
+      #
+      # @param  [String] url
+      #         The URL of the source.
+      #
+      def create_source_with_url(url)
+        name = name_for_url(url)
+        is_cdn = cdn_url?(url)
+
+        # Hack to ensure that `repo add` output is shown.
+        previous_title_level = UI.title_level
+        UI.title_level = 0
+
+        begin
+          if is_cdn
+            Command::Repo::AddCDN.parse([name, url]).run
+          else
+            Command::Repo::Add.parse([name, url]).run
+          end
+        rescue Informative => e
+          message = "Unable to add a source with url `#{url}` " \
+            "named `#{name}`.\n"
+          message << "(#{e})\n" if Config.instance.verbose?
+          message << 'You can try adding it manually in ' \
+            "`#{Config.instance.repos_dir}` or via `pod repo add`."
+          raise Informative, message
+        ensure
+          UI.title_level = previous_title_level
+        end
+        source = source_with_url(url)
+
+        raise "Unable to create a source with URL #{url}" unless source
+
+        source
+      end
+
+      # Determines whether `url` is a CocoaPods CDN URL.
+      #
+      # @return [Boolean] whether `url` is a CocoaPods CDN URL,
+      #
+      # @param  [String] url
+      #         The URL of the source.
+      #
+      def cdn_url?(url)
+        return false unless url =~ %r{^https?:\/\/}
+
+        uri_options = {}
+
+        netrc_info = Netrc.read
+        uri = URI.parse(url)
+        return false unless uri.userinfo.nil?
+
+        netrc_host = uri.host
+        credentials = netrc_info[netrc_host]
+        uri_options[:http_basic_authentication] = credentials if credentials
+
+        response = OpenURI.open_uri(url.chomp('/') + '/CocoaPods-version.yml', uri_options)
+        response_hash = YAML.load(response.read) # rubocop:disable Security/YAMLLoad
+        response_hash.is_a?(Hash) && !Source::Metadata.new(response_hash).latest_cocoapods_version.nil?
+      rescue Psych::SyntaxError, ::OpenURI::HTTPError, SocketError
+        return false
+      rescue => e
+        raise Informative, "Couldn't determine repo type for URL: `#{url}`: #{e}"
+      end
+
+      # Returns the source whose {Source#name} or {Source#url} is equal to the
+      # given `name_or_url`.
+      #
+      # @return [Source] The source whose {Source#name} or {Source#url} is equal to the
+      #                  given `name_or_url`.
+      #
+      # @param  [String] name_or_url
+      #                  The name or the URL of the source.
+      #
+      def source_with_name_or_url(name_or_url)
+        all.find { |s| s.name == name_or_url } ||
+          find_or_create_source_with_url(name_or_url)
+      end
+
+      # @return [Pathname] The path where the search index should be stored.
+      #
+      def search_index_path
+        @search_index_path ||= Config.instance.search_index_file
+      end
+
+      # @!group Updating Sources
+
+      # Updates the local clone of the spec-repo with the given name or of all
+      # the git repos if the name is omitted.
+      #
+      # @param  [String] source_name
+      #
+      # @param  [Bool] show_output
+      #
+      # @return [void]
+      #
+      def update(source_name = nil, show_output = false)
+        if source_name
+          sources = [updateable_source_named(source_name)]
+        else
+          sources = updateable_sources
+        end
+
+        changed_spec_paths = {}
+
+        # Do not perform an update if the repos dir has not been setup yet.
+        return unless repos_dir.exist?
+
+        # Create the Spec_Lock file if needed and lock it so that concurrent
+        # repo updates do not cause each other to fail
+        File.open("#{repos_dir}/Spec_Lock", File::CREAT) do |f|
+          f.flock(File::LOCK_EX)
+          sources.each do |source|
+            UI.section "Updating spec repo `#{source.name}`" do
+              changed_source_paths = source.update(show_output)
+              changed_spec_paths[source] = changed_source_paths if changed_source_paths.count > 0
+              source.verify_compatibility!
+            end
+          end
+        end
+        # Perform search index update operation in background.
+        update_search_index_if_needed_in_background(changed_spec_paths)
+      end
+
+      # Adds the provided source to the list of sources
+      #
+      # @param [Source] source the source to add
+      #
+      def add_source(source)
+        all << source unless all.any? { |s| s.url == source || s.name == source.name }
+      end
+    end
+
+    extend Executable
+    executable :git
+
+    def repo_git(args, include_error: false)
+      Executable.capture_command('git', ['-C', repo] + args,
+                                 :capture => include_error ? :merge : :out,
+                                 :env => {
+                                   'GIT_CONFIG' => nil,
+                                   'GIT_DIR' => nil,
+                                   'GIT_WORK_TREE' => nil,
+                                 }
+                                ).
+        first.strip
+    end
+
+    def update_git_repo(show_output = false)
+      Config.instance.with_changes(:verbose => show_output) do
+        args = %W(-C #{repo} fetch origin)
+        args.push('--progress') if show_output
+        git!(args)
+        current_branch = git!(%W(-C #{repo} rev-parse --abbrev-ref HEAD)).strip
+        git!(%W(-C #{repo} reset --hard origin/#{current_branch}))
+      end
+    rescue
+      raise Informative, 'CocoaPods was not able to update the ' \
+        "`#{name}` repo. If this is an unexpected issue " \
+        'and persists you can inspect it running ' \
+        '`pod repo update --verbose`'
+    end
+  end
+
+  class TrunkSource
+    def verify_compatibility!
+      super
+      latest_cocoapods_version = metadata.latest_cocoapods_version && Gem::Version.create(metadata.latest_cocoapods_version)
+      return unless Config.instance.new_version_message? &&
+        latest_cocoapods_version &&
+        latest_cocoapods_version > Gem::Version.new(Pod::VERSION)
+
+      rc = latest_cocoapods_version.prerelease?
+      install_message = !Pathname(__FILE__).dirname.writable? ? 'sudo ' : ''
+      install_message << 'gem install cocoapods'
+      install_message << ' --pre' if rc
+      message = [
+        '',
+        "CocoaPods #{latest_cocoapods_version} is available.".green,
+        "To update use: `#{install_message}`".green,
+        ("[!] This is a test version we'd love you to try.".yellow if rc),
+        '',
+        'For more information, see https://blog.cocoapods.org ' \
+        'and the CHANGELOG for this version at ' \
+        "https://github.com/CocoaPods/CocoaPods/releases/tag/#{latest_cocoapods_version}".green,
+        '',
+        '',
+      ].compact.join("\n")
+      UI.puts(message)
+    end
+  end
+end