cocoapods 0.16.4 → 0.17.0.rc1

data/lib/cocoapods/installer/analyzer/sandbox_analyzer.rb

@@ -0,0 +1,253 @@
+module Pod
+  class Installer
+    class Analyzer
+
+      # Analyze the sandbox to detect which Pods should be removed, and which
+      # ones should be reinstalled.
+      #
+      # The logic is the following:
+      #
+      # Added
+      # - If not present in the sandbox lockfile.
+      # - The directory of the Pod doesn't exits.
+      #
+      # Changed
+      # - The version of the Pod changed.
+      # - The SHA of the specification file changed.
+      # - The specific installed (sub)specs of the same Pod changed.
+      # - The specification is in head mode or from an external source and the
+      #   installation process is in update mode.
+      # - The directory of the Pod is empty.
+      # - The Pod has been pre-downloaded.
+      #
+      # Removed
+      # - If a specification is present in the lockfile but not in the resolved
+      #   specs.
+      #
+      # Unchanged
+      # - If none of the above conditions match.
+      #
+      class SandboxAnalyzer
+
+        # @return [Sandbox] The sandbox to analyze.
+        #
+        attr_reader :sandbox
+
+        # @return [Array<Specifications>] The specifications returned by the
+        #         resolver.
+        #
+        attr_reader :specs
+
+        # @return [Bool] Whether the installation is performed in update mode.
+        #
+        attr_reader :update_mode
+
+        # @return [Lockfile] The lockfile of the installation as a fall-back if
+        #         there is no sandbox manifest. This is indented as a temporary
+        #         solution to prevent the full re-installation from users which
+        #         are upgrading from CP < 0.17.
+        #
+        # @todo   Remove for CP 0.18.
+        #
+        attr_reader :lockfile
+
+        # @param [Sandbox] sandbox @see sandbox
+        # @param [Array<Specifications>] specs @see specs
+        # @param [Bool] update_mode @see update_mode
+        # @param [Lockfile] lockfile @see lockfile
+        #
+        def initialize(sandbox, specs, update_mode, lockfile = nil)
+          @sandbox = sandbox
+          @specs = specs
+          @update_mode = update_mode
+          @lockfile = lockfile
+        end
+
+        # Performs the analysis to the detect the state of the sandbox respect
+        # to the resolved specifications.
+        #
+        # @return [SpecsState] the state of the sandbox.
+        #
+        def analyze
+          state = SpecsState.new
+          if sandbox_manifest
+            all_names = (resolved_pods + sandbox_pods).uniq.sort
+            all_names.sort.each do |name|
+              state.add_name(name, pod_state(name))
+            end
+          else
+            state.added.concat(resolved_pods)
+          end
+          state
+        end
+
+        #---------------------------------------------------------------------#
+
+        private
+
+        # @!group Pod state
+
+        # Returns the state of the Pod with the given name.
+        #
+        # @param  [String] pod
+        #         the name of the Pod.
+        #
+        # @return [Symbol] The state
+        #
+        def pod_state(pod)
+          return :added   if pod_added?(pod)
+          return :deleted if pod_deleted?(pod)
+          return :changed if pod_changed?(pod)
+          return :unchanged
+        end
+
+        # Returns whether the Pod with the given name should be installed.
+        #
+        # @note   A Pod whose folder doesn't exists is considered added.
+        #
+        # @param  [String] pod
+        #         the name of the Pod.
+        #
+        # @return [Bool] Whether the Pod is added.
+        #
+        def pod_added?(pod)
+          return true if resolved_pods.include?(pod) && !sandbox_pods.include?(pod)
+          return true if !folder_exist?(pod)
+          return false
+        end
+
+        # Returns whether the Pod with the given name should be removed from
+        # the installation.
+        #
+        # @param  [String] pod
+        #         the name of the Pod.
+        #
+        # @return [Bool] Whether the Pod is deleted.
+        #
+        def pod_deleted?(pod)
+          return true if !resolved_pods.include?(pod) && sandbox_pods.include?(pod)
+          return false
+        end
+
+        # Returns whether the Pod with the given name should be considered
+        # changed and thus should be reinstalled.
+        #
+        # @note   In update mode, as there is no way to know if a remote source
+        #         hash changed the Pods in head mode and the ones from external
+        #         sources are always marked as changed.
+        #
+        # @note   A Pod whose folder is empty is considered changed.
+        #
+        # @param  [String] pod
+        #         the name of the Pod.
+        #
+        # @return [Bool] Whether the Pod is changed.
+        #
+        def pod_changed?(pod)
+          spec = root_spec(pod)
+          return true if spec.version != sandbox_version(pod)
+          return true if spec.checksum != sandbox_checksum(pod)
+          return true if resolved_spec_names(pod) != sandbox_spec_names(pod)
+          return true if sandbox.predownloaded?(pod)
+          return true if folder_empty?(pod)
+          if update_mode
+            return true if spec.version.head?
+          end
+          return false
+        end
+
+        #---------------------------------------------------------------------#
+
+        private
+
+        # @!group Private helpers
+
+        # @return [Lockfile] The manifest to use for the sandbox.
+        #
+        def sandbox_manifest
+          sandbox.manifest || lockfile
+        end
+
+        #--------------------------------------#
+
+        # @return [Array<String>] The name of the resolved Pods.
+        #
+        def resolved_pods
+          specs.map { |spec| spec.root.name }.uniq
+        end
+
+        # @return [Array<String>] The name of the Pods stored in the sandbox
+        #         manifest.
+        #
+        def sandbox_pods
+          sandbox_manifest.pod_names.map { |name| Specification.root_name(name) }.uniq
+        end
+
+        # @return [Array<String>] The name of the resolved specifications
+        #         (includes subspecs).
+        #
+        # @param  [String] pod
+        #         the name of the Pod.
+        #
+        def resolved_spec_names(pod)
+          specs.select { |s| s.root.name == pod }.map(&:name).uniq
+        end
+
+        # @return [Array<String>] The name of the specifications stored in the
+        #         sandbox manifest (includes subspecs).
+        #
+        # @param  [String] pod
+        #         the name of the Pod.
+        #
+        def sandbox_spec_names(pod)
+          sandbox_manifest.pod_names.select { |name| Specification.root_name(name) == pod }.uniq
+        end
+
+        # @return [Specification] The root specification for the Pod with the
+        #         given name.
+        #
+        # @param  [String] pod
+        #         the name of the Pod.
+        #
+        def root_spec(pod)
+          specs.find { |s| s.root.name == pod }.root
+        end
+
+        #--------------------------------------#
+
+        # @return [Version] The version of Pod with the given name stored in
+        #         the sandbox.
+        #
+        # @param  [String] pod
+        #         the name of the Pod.
+        #
+        def sandbox_version(pod)
+          sandbox_manifest.version(pod)
+        end
+
+        # @return [String] The checksum of the specification of the Pod with
+        #         the given name stored in the sandbox.
+        #
+        # @param  [String] pod
+        #         the name of the Pod.
+        #
+        def sandbox_checksum(pod)
+          sandbox_manifest.checksum(pod)
+        end
+
+        #--------------------------------------#
+
+        def folder_exist?(pod)
+          sandbox.pod_dir(pod).exist?
+        end
+
+        def folder_empty?(pod)
+          Dir.glob(sandbox.pod_dir(pod) + '*').empty?
+        end
+
+        #---------------------------------------------------------------------#
+
+      end
+    end
+  end
+end

data/lib/cocoapods/installer/file_references_installer.rb

@@ -0,0 +1,179 @@
+module Pod
+  class Installer
+
+    # Controller class responsible of installing the file references of the
+    # specifications in the Pods project.
+    #
+    class FileReferencesInstaller
+
+      # @return [Sandbox] The sandbox of the installation.
+      #
+      attr_reader :sandbox
+
+      # @return [Array<Library>] The libraries of the installation.
+      #
+      attr_reader :libraries
+
+      # @return [Project] The Pods project.
+      #
+      attr_reader :pods_project
+
+      # @param [Sandbox] sandbox @see sandbox
+      # @param [Array<Library>] libraries @see libraries
+      # @param [Project] libraries @see libraries
+      #
+      def initialize(sandbox, libraries, pods_project)
+        @sandbox = sandbox
+        @libraries = libraries
+        @pods_project = pods_project
+      end
+
+      # Installs the file references.
+      #
+      # @return [void]
+      #
+      def install!
+        refresh_file_accessors
+        add_source_files_references
+        add_resources_references
+        link_headers
+      end
+
+      #-----------------------------------------------------------------------#
+
+      private
+
+      # @!group Installation Steps
+
+      # Reads the file accessors contents from the file system.
+      #
+      # @note   The contents of the file accessors are modified by the clean
+      #         step of the #{PodSourceInstaller} and by the pre install hooks.
+      #
+      # @return [void]
+      #
+      def refresh_file_accessors
+        file_accessors.each do |fa|
+          fa.path_list.read_file_system
+        end
+      end
+
+      # Adds the source files of the Pods to the Pods project.
+      #
+      # @note   The source files are grouped by Pod and in turn by subspec
+      #         (recursively).
+      #
+      # @note   Pods are generally added to the `Pods` group, however, if they
+      #         have a local source they are added to the
+      #         `Local Pods` group.
+      #
+      # @return [void]
+      #
+      def add_source_files_references
+        UI.message "- Adding source files to Pods project" do
+          file_accessors.each do |file_accessor|
+            files = file_accessor.source_files
+            spec_name = file_accessor.spec.name
+            local = sandbox.local?(file_accessor.spec.root.name)
+            parent_group = local ? pods_project.local_pods : pods_project.pods
+            pods_project.add_file_references(files, spec_name, parent_group)
+          end
+        end
+      end
+
+      # Adds the resources of the Pods to the Pods project.
+      #
+      # @note   The source files are grouped by Pod and in turn by subspec
+      #         (recursively) in the resources group.
+      #
+      # @return [void]
+      #
+      def add_resources_references
+        UI.message "- Adding resources to Pods project" do
+          file_accessors.each do |file_accessor|
+            file_accessor.resources.each do |resources|
+              files = file_accessor.resources
+              spec_name = file_accessor.spec.name
+              parent_group = pods_project.resources
+              pods_project.add_file_references(files, spec_name, parent_group)
+            end
+          end
+        end
+      end
+
+      # Creates the link to the headers of the Pod in the sandbox.
+      #
+      # @return [void]
+      #
+      def link_headers
+        UI.message "- Linking headers" do
+
+          file_accessors.each do |file_accessor|
+            headers_sandbox = Pathname.new(file_accessor.spec.root.name)
+            sandbox.build_headers.add_search_path(headers_sandbox)
+            sandbox.public_headers.add_search_path(headers_sandbox)
+
+            consumer = file_accessor.spec_consumer
+            header_mappings(headers_sandbox, consumer, file_accessor.headers).each do |namespaced_path, files|
+              sandbox.build_headers.add_files(namespaced_path, files)
+            end
+
+            header_mappings(headers_sandbox, consumer, file_accessor.public_headers).each do |namespaced_path, files|
+              sandbox.public_headers.add_files(namespaced_path, files)
+            end
+          end
+        end
+      end
+
+      #-----------------------------------------------------------------------#
+
+      private
+
+      # @!group Private Helpers
+
+      # @return [Array<Sandbox::FileAccessor>] The file accessors for all the
+      #         specs platform combinations.
+      #
+      def file_accessors
+        @file_accessors ||= libraries.map(&:file_accessors).flatten.compact
+      end
+
+      # Computes the destination sub-directory in the sandbox
+      #
+      # @param  [Pathname] headers_sandbox
+      #         The sandbox where the headers links should be stored for this
+      #         Pod.
+      #
+      # @param  [Specification::Consumer] consumer
+      #         The consumer for which the headers need to be linked.
+      #
+      # @param  [Array<Pathname>] headers
+      #         The absolute paths of the headers which need to be mapped.
+      #
+      # @return [Hash{Pathname => Array<Pathname>}] A hash containing the
+      #         headers folders as the keys and the absolute paths of the
+      #         header files as the values.
+      #
+      def header_mappings(headers_sandbox, consumer, headers)
+        dir = headers_sandbox
+        dir = dir + consumer.header_dir if consumer.header_dir
+
+        mappings = {}
+        headers.each do |header|
+          sub_dir = dir
+          if consumer.header_mappings_dir
+            header_mappings_dir = Pathname.new(consumer.header_mappings_dir)
+            relative_path = header.relative_path_from(header_mappings_dir)
+            sub_dir = sub_dir + relative_path.dirname
+          end
+          mappings[sub_dir] ||= []
+          mappings[sub_dir] << header
+        end
+        mappings
+      end
+
+      #-----------------------------------------------------------------------#
+
+    end
+  end
+end

data/lib/cocoapods/installer/pod_source_installer.rb

@@ -0,0 +1,289 @@
+module Pod
+  class Installer
+
+    # Controller class responsible of installing the activated specifications
+    # of a single Pod.
+    #
+    # @note This class needs to consider all the activated specs of a Pod.
+    #
+    class PodSourceInstaller
+
+      # @return [Sandbox]
+      #
+      attr_reader :sandbox
+
+      # @return [Hash{Symbol=>Array}] The specifications that need to be
+      #         installed grouped by platform.
+      #
+      attr_reader :specs_by_platform
+
+      # @param [Sandbox] sandbox @see sandbox
+      # @param [Hash{Symbol=>Array}] specs_by_platform @see specs_by_platform
+      #
+      def initialize(sandbox, specs_by_platform)
+        @sandbox = sandbox
+        @specs_by_platform = specs_by_platform
+
+        @clean            = true
+        @generate_docs    = false
+        @install_docs     = false
+        @aggressive_cache = false
+      end
+
+      # @return [String] A string suitable for debugging.
+      #
+      def inspect
+        "<#{self.class} sandbox=#{sandbox.root} pod=#{root_spec.name}"
+      end
+
+      #-----------------------------------------------------------------------#
+
+      public
+
+      # @!group Configuration
+
+      # @return [Bool] whether the file not used by CocoaPods should be
+      #         removed.
+      #
+      attr_accessor :clean
+      alias_method  :clean?, :clean
+
+      # @return [Bool] whether the documentation should be generated for the
+      #         Pod.
+      #
+      attr_accessor :generate_docs
+      alias_method  :generate_docs?, :generate_docs
+
+      # @return [Bool] whether the generated documentation should be installed
+      #         in Xcode.
+      #
+      attr_accessor :install_docs
+      alias_method  :install_docs?, :install_docs
+
+      # @return [Bool] whether the downloader should always check against the
+      #         remote if issues might be generated (mostly useful to speed up
+      #         testing).
+      #
+      # @note   This might be removed in future.
+      #
+      attr_accessor :aggressive_cache
+      alias_method  :aggressive_cache?, :aggressive_cache
+
+      #-----------------------------------------------------------------------#
+
+      public
+
+      # @!group Installation
+
+      # Creates the target in the Pods project and the relative support files.
+      #
+      # @return [void]
+      #
+      def install!
+        download_source     unless predownloaded? || local?
+        generate_docs       if generate_docs?
+        clean_installation  if clean? && !local?
+      end
+
+      # @return [Hash]
+      #
+      attr_reader :specific_source
+
+      #-----------------------------------------------------------------------#
+
+      private
+
+      # @!group Installation Steps
+
+      # Downloads the source of the Pod. It also stores the specific options
+      # needed to recreate the same exact installation if needed in
+      # `#specific_source`.
+      #
+      # @return [void]
+      #
+      def download_source
+        root.rmtree if root.exist?
+        if root_spec.version.head?
+          downloader.download_head
+          @specific_source = downloader.checkout_options
+        else
+          downloader.download
+          unless downloader.options_specific?
+            @specific_source = downloader.checkout_options
+          end
+        end
+
+        if specific_source
+        sandbox.store_checkout_source(root_spec.name, specific_source)
+        end
+      end
+
+      # Generates the documentation for the Pod.
+      #
+      # @return [void]
+      #
+      def generate_docs
+        if @cleaned
+          raise Informative, "Attempt to generate the documentation from a cleaned Pod."
+        end
+
+        if documentation_generator.already_installed?
+          UI.section " > Using existing documentation"
+        else
+          UI.section " > Installing documentation" do
+            documentation_generator.generate(install_docs?)
+          end
+        end
+      end
+
+      # Removes all the files not needed for the installation according to the
+      # specs by platform.
+      #
+      # @return [void]
+      #
+      def clean_installation
+        clean_paths.each { |path| FileUtils.rm_rf(path) }
+        @cleaned = true
+      end
+
+      #-----------------------------------------------------------------------#
+
+      public
+
+      # @!group Dependencies
+
+      # @return [String] The directory where CocoaPods caches the downloads.
+      #
+      CACHE_ROOT = "~/Library/Caches/CocoaPods"
+
+      # @return [Fixnum] The maximum size for the cache expressed in Mb.
+      #
+      MAX_CACHE_SIZE = 500
+
+      # @return [Downloader] The downloader to use for the retrieving the
+      #         source.
+      #
+      def downloader
+        return @downloader if @downloader
+        @downloader = Downloader.for_target(root, root_spec.source.dup)
+        @downloader.cache_root = CACHE_ROOT
+        @downloader.max_cache_size = MAX_CACHE_SIZE
+        @downloader.aggressive_cache = aggressive_cache?
+        @downloader
+      end
+
+      # @return [Generator::Documentation] The documentation generator to use
+      #         for generating the documentation.
+      #
+      def documentation_generator
+        @documentation_generator ||= Generator::Documentation.new(sandbox, root_spec, path_list)
+      end
+
+      #-----------------------------------------------------------------------#
+
+      private
+
+      # @!group Convenience methods.
+
+      # @return [Array<Specifications>] the specification of the Pod used in
+      #         this installation.
+      #
+      def specs
+        specs_by_platform.values.flatten
+      end
+
+      # @return [Specification] the root specification of the Pod.
+      #
+      def root_spec
+        specs.first.root
+      end
+
+      # @return [Pathname] the folder where the source of the Pod is located.
+      #
+      def root
+        sandbox.pod_dir(root_spec.name)
+      end
+
+      # @return [Boolean] whether the source has been pre downloaded in the
+      #         resolution process to retrieve its podspec.
+      #
+      def predownloaded?
+        sandbox.predownloaded_pods.include?(root_spec.name)
+      end
+
+      # @return [Boolean] whether the pod uses the local option and thus
+      #         CocoaPods should not interfere with the files of the user.
+      #
+      def local?
+        sandbox.local?(root_spec.name)
+      end
+
+      #-----------------------------------------------------------------------#
+
+      private
+
+      # @!group Private helpers
+
+      # @return [Array<Sandbox::FileAccessor>] the file accessors for all the
+      #         specifications on their respective platform.
+      #
+      def file_accessors
+        return @file_accessors if @file_accessors
+        @file_accessors = []
+        specs_by_platform.each do |platform, specs|
+          specs.each do |spec|
+            @file_accessors << Sandbox::FileAccessor.new(path_list, spec.consumer(platform))
+          end
+        end
+        @file_accessors
+      end
+
+      # @return [Sandbox::PathList] The path list for this Pod.
+      #
+      def path_list
+        @path_list ||= Sandbox::PathList.new(root)
+      end
+
+      # Finds the absolute paths, including hidden ones, of the files
+      # that are not used by the pod and thus can be safely deleted.
+      #
+      # @note   Implementation detail: Don't use `Dir#glob` as there is an
+      #         unexplained issue (#568, #572 and #602).
+      #
+      # @return [Array<Strings>] The paths that can be deleted.
+      #
+      def clean_paths
+        cached_used = used_files
+        glob_options = File::FNM_DOTMATCH | File::FNM_CASEFOLD
+        files = Pathname.glob(root + "**/*", glob_options).map(&:to_s)
+
+        files.reject! do |candidate|
+          candidate.end_with?('.', '..') || cached_used.any? do |path|
+            path.include?(candidate) || candidate.include?(path)
+          end
+        end
+        files
+      end
+
+      # @return [Array<String>] The absolute path of all the files used by the
+      #         specifications (according to their platform) of this Pod.
+      #
+      def used_files
+
+        files = [
+          file_accessors.map(&:source_files),
+          file_accessors.map(&:resources),
+          file_accessors.map(&:preserve_paths),
+          file_accessors.map(&:prefix_header),
+          file_accessors.map(&:readme),
+          file_accessors.map(&:license),
+        ]
+
+        files.flatten.compact.map{ |path| path.to_s }.uniq
+      end
+
+      #-----------------------------------------------------------------------#
+
+    end
+  end
+end