cocoapods 0.16.4 → 0.17.0.rc1

data/lib/cocoapods/generator/xcconfig.rb

@@ -0,0 +1,130 @@
+module Pod
+  module Generator
+
+    # Generates an xcconfig file for each target of the Pods project. The
+    # configuration file should be used by the user target as well.
+    #
+    class XCConfig
+
+      # @return [Sandbox] the sandbox where the Pods project is installed.
+      #
+      attr_reader :sandbox
+
+      # @return [Array<Specification::Consumer>] the consumers for the
+      #         specifications of the library which needs the xcconfig.
+      #
+      attr_reader :spec_consumers
+
+      # @return [String] the relative path of the Pods root respect the user
+      #         project that should be integrated by this library.
+      #
+      attr_reader :relative_pods_root
+
+      # @param  [Sandbox] sandbox @see sandbox
+      # @param  [Array<LocalPod>] pods @see pods
+      # @param  [String] relative_pods_root @see relative_pods_root
+      #
+      def initialize(sandbox, spec_consumers, relative_pods_root)
+        @sandbox = sandbox
+        @spec_consumers = spec_consumers
+        @relative_pods_root = relative_pods_root
+      end
+
+      # @return [Bool] whether the Podfile specifies to add the `-fobjc-arc`
+      #         flag for compatibility.
+      #
+      attr_accessor :set_arc_compatibility_flag
+
+      #-----------------------------------------------------------------------#
+
+      # Generates the xcconfig for the library.
+      #
+      # @return [Xcodeproj::Config]
+      #
+      # @note   The value `PODS_HEADERS_SEARCH_PATHS` is used to store the headers
+      #         so xcconfig can reference the variable.
+      #
+      def generate
+        ld_flags = '-ObjC'
+        if  set_arc_compatibility_flag && spec_consumers.any? { |consumer| consumer.requires_arc }
+          ld_flags << ' -fobjc-arc'
+        end
+
+        @xcconfig = Xcodeproj::Config.new({
+          'ALWAYS_SEARCH_USER_PATHS'         => 'YES',
+          'OTHER_LDFLAGS'                    => ld_flags,
+          'HEADER_SEARCH_PATHS'              => '${PODS_HEADERS_SEARCH_PATHS}',
+          'PODS_ROOT'                        => relative_pods_root,
+          'PODS_HEADERS_SEARCH_PATHS'        => '${PODS_PUBLIC_HEADERS_SEARCH_PATHS}',
+          'PODS_BUILD_HEADERS_SEARCH_PATHS'  => quote(sandbox.build_headers.search_paths),
+          'PODS_PUBLIC_HEADERS_SEARCH_PATHS' => quote(sandbox.public_headers.search_paths),
+        })
+
+        spec_consumers.each do |consumer|
+          @xcconfig.merge!(consumer.xcconfig);
+          @xcconfig.libraries.merge(consumer.libraries);
+          @xcconfig.frameworks.merge(consumer.frameworks);
+          @xcconfig.weak_frameworks.merge(consumer.weak_frameworks);
+        end
+
+        @xcconfig
+      end
+
+      # @return [Xcodeproj::Config] The generated xcconfig.
+      #
+      attr_reader :xcconfig
+
+      # @return [Hash] The settings of the xcconfig that the Pods project
+      #         needs to override.
+      #
+      def self.pods_project_settings
+        { 'PODS_ROOT' => '${SRCROOT}',
+          'PODS_HEADERS_SEARCH_PATHS' => '${PODS_BUILD_HEADERS_SEARCH_PATHS}' }
+      end
+
+      # Generates and saves the xcconfig to the given path.
+      #
+      # @param  [Pathname] path
+      #         the path where the prefix header should be stored.
+      #
+      # @return [void]
+      #
+      def save_as(path)
+        path.open('w') { |file| file.write(generate) }
+      end
+
+      #-----------------------------------------------------------------------#
+
+      # @!group Private helpers.
+
+      private
+
+      # @return [String] the default linker flags. `-ObjC` is always included
+      #         while `-fobjc-arc` is included only if requested in the
+      #         Podfile.
+      #
+      def default_ld_flags
+        flags = %w[ -ObjC ]
+        requires_arc = pods.any? { |pod| pod.requires_arc? }
+        if  requires_arc && set_arc_compatibility_flag
+          flags << '-fobjc-arc'
+        end
+        flags.join(" ")
+      end
+
+      # Converts an array of strings to a single string where the each string
+      # is surrounded by double quotes and separated by a space. Used to
+      # represent strings in a xcconfig file.
+      #
+      # @param  [Array<String>] strings
+      #         a list of strings.
+      #
+      # @return [String] the resulting string.
+      #
+      def quote(strings)
+        strings.sort.map { |s| %W|"#{s}"| }.join(" ")
+      end
+    end
+  end
+end
+

data/lib/cocoapods/hooks/installer_representation.rb

@@ -0,0 +1,123 @@
+module Pod
+
+  class Podfile
+    def config
+      UI.warn "Podfile#config is deprecated. The config is accessible from " \
+        "the parameter passed to the hooks"
+      Config.instance
+    end
+  end
+
+  module Hooks
+
+    # The installer representation to pass to the hooks.
+    #
+    class InstallerRepresentation
+
+      public
+
+      # @!group Public Hooks API
+
+      # @return [Pathname] The root of the sandbox.
+      #
+      def sandbox_root
+        installer.sandbox.root
+      end
+
+      # @return [Pod::Project] the `Pods/Pods.xcodeproj` project.
+      #
+      def project
+        installer.pods_project
+      end
+
+      # @return [Array<PodRepresentation>] The representation of the Pods.
+      #
+      def pods
+        installer.pod_reps
+      end
+
+      # @return [Array<LibraryRepresentation>] The representation of the
+      #         libraries.
+      #
+      def libraries
+        installer.library_reps
+      end
+
+      # @return [Hash{LibraryRepresentation => Array<Specification>}] The
+      #         specifications grouped by target definition.
+      #
+      def specs_by_lib
+        result = {}
+        installer.libraries.each do |lib|
+          result[installer.library_rep(lib)] = lib.specs
+        end
+        result
+      end
+
+      # @return [Hash{LibraryRepresentation => Array<PodRepresentation>}] The
+      #         local pod instances grouped by target.
+      #
+      def pods_by_lib
+        result = {}
+        installer.libraries.each do |lib|
+          pod_names = lib.specs.map { |spec| spec.root.name }.uniq
+          pod_reps = pods.select { |rep| pod_names.include?(rep.name) }
+          result[lib.target_definition] = pod_reps
+        end
+        result
+      end
+
+      #-----------------------------------------------------------------------#
+      public
+
+      # @!group Compatibility
+      #
+      # The following aliases provides compatibility with CP < 0.17
+
+      alias :target_installers :libraries
+      alias :specs_by_target :specs_by_lib
+      alias :local_pods_by_target :pods_by_lib
+
+      #-----------------------------------------------------------------------#
+
+      public
+
+      # @!group Unsafe Hooks API
+      #
+      # The interface of the following objects might change at any time.
+      # If there some information which is needed, please open an issue.
+
+      # @return [Sandbox] sandbox the sandbox where the support files should
+      #         be generated.
+      #
+      def sandbox
+        installer.sandbox
+      end
+
+      # @return [Config] The config singleton used for the installation.
+      #
+      def config
+        Config.instance
+      end
+
+      # @return [Installer] The installer described by this instance.
+      #
+      attr_reader :installer
+
+      #-----------------------------------------------------------------------#
+
+      # @!group Private implementation
+
+      # @param [Installer] installer @see installer
+      #
+      def initialize(installer)
+        @installer = installer
+      end
+
+      #-----------------------------------------------------------------------#
+
+    end
+  end
+end
+
+

data/lib/cocoapods/hooks/library_representation.rb

@@ -0,0 +1,79 @@
+module Pod
+  module Hooks
+    class LibraryRepresentation
+
+      # Stores the information of the target installer
+
+      #-----------------------------------------------------------------------#
+
+      # @return [String] The name of the Pods library.
+      #
+      def name
+        library.name
+      end
+
+      # @return [Array<Dependency>] The dependencies of this library.
+      #
+      def dependencies
+        target_definition.dependencies
+      end
+
+      # @return [Pathname] The path of the prefix_header
+      #
+      def prefix_header_filename
+        library.prefix_header_path
+      end
+
+      # @return [Project] The Pods project of the sandbox.
+      #
+      def project
+        sandbox.project
+      end
+
+      # @return [TargetDefinition] The target definition of the library.
+      #
+      def target_definition
+        library.target_definition
+      end
+
+      #-----------------------------------------------------------------------#
+
+      public
+
+      # @!group Unsafe Hooks API
+
+      # @return [Sandbox] sandbox the sandbox where the support files should
+      #         be generated.
+      #
+      attr_reader :sandbox
+
+      # @return [Library] The library whose target needs to be generated.
+      #
+      attr_reader :library
+
+      # @return [PBXNativeTarget] The target generated by the installation
+      #         process.
+      #
+      def target
+        library.target
+      end
+
+      #-----------------------------------------------------------------------#
+
+      # @!group Private implementation
+
+      # @param [Sandbox] sandbox @see sandbox
+      # @param [Library] library @see library
+      #
+      def initialize(sandbox, library)
+        @sandbox = sandbox
+        @library = library
+      end
+
+      #-----------------------------------------------------------------------#
+
+    end
+  end
+end
+
+

data/lib/cocoapods/hooks/pod_representation.rb

@@ -0,0 +1,74 @@
+module Pod
+
+  class Specification
+    def config
+      UI.warn "Specification#config is deprecated. The config is accessible from " \
+        "the parameter passed to the hooks"
+      Config.instance
+    end
+  end
+
+  module Hooks
+
+    # Stores the information of the Installer for the hooks
+    #
+    class PodRepresentation
+
+      # @return [String]
+      #
+      attr_accessor :name
+
+      # @return [Version]
+      #
+      def version
+        root_spec.version
+      end
+
+      # @return [Specification]
+      #
+      def root_spec
+        file_accessors.first.spec.root
+      end
+
+      # @return [Array<Specification>]
+      #
+      def specs
+        file_accessors.map(&:spec).uniq
+      end
+
+      # @return [Pathname]
+      #
+      def root
+        file_accessors.first.path_list.root
+      end
+
+      # @return [Array<Pathname>]
+      #
+      def source_files
+        file_accessors.map(&:source_files).flatten.uniq
+      end
+
+      #-----------------------------------------------------------------------#
+
+      # @!group Private implementation
+
+      # @param [Installer] installer @see installer
+      #
+      def initialize(name, file_accessors)
+        @name = name
+        @file_accessors = file_accessors
+      end
+
+      def to_s
+        root_spec.to_s
+      end
+
+      private
+
+      attr_reader :file_accessors
+
+      #-----------------------------------------------------------------------#
+
+    end
+  end
+end

data/lib/cocoapods/installer.rb

@@ -1,216 +1,467 @@
-require 'colored'
-
 module Pod
+
+  # The Installer is responsible of taking a Podfile and transform it in the
+  # Pods libraries. It also integrates the user project so the Pods
+  # libraries can be used out of the box.
+  #
+  # The Installer is capable of doing incremental updates to an existing Pod
+  # installation.
+  #
+  # The Installer gets the information that it needs mainly from 3 files:
+  #
+  #   - Podfile: The specification written by the user that contains
+  #     information about targets and Pods.
+  #   - Podfile.lock: Contains information about the pods that were previously
+  #     installed and in concert with the Podfile provides information about
+  #     which specific version of a Pod should be installed. This file is
+  #     ignored in update mode.
+  #   - Manifest.lock: A file contained in the Pods folder that keeps track of
+  #     the pods installed in the local machine. This files is used once the
+  #     exact versions of the Pods has been computed to detect if that version
+  #     is already installed. This file is not intended to be kept under source
+  #     control and is a copy of the Podfile.lock.
+  #
+  # The Installer is designed to work in environments where the Podfile folder
+  # is under source control and environments where it is not. The rest of the
+  # files, like the user project and the workspace are assumed to be under
+  # source control.
+  #
   class Installer
-    autoload :TargetInstaller,       'cocoapods/installer/target_installer'
-    autoload :UserProjectIntegrator, 'cocoapods/installer/user_project_integrator'
+
+    autoload :Analyzer,                'cocoapods/installer/analyzer'
+    autoload :FileReferencesInstaller, 'cocoapods/installer/file_references_installer'
+    autoload :PodSourceInstaller,      'cocoapods/installer/pod_source_installer'
+    autoload :TargetInstaller,         'cocoapods/installer/target_installer'
+    autoload :UserProjectIntegrator,   'cocoapods/installer/user_project_integrator'
 
     include Config::Mixin
 
-    attr_reader :resolver, :sandbox, :lockfile
+    # @return [Sandbox] The sandbox where the Pods should be installed.
+    #
+    attr_reader :sandbox
+
+    # @return [Podfile] The Podfile specification that contains the information
+    #         of the Pods that should be installed.
+    #
+    attr_reader :podfile
+
+    # @return [Lockfile] The Lockfile that stores the information about the
+    #         Pods previously installed on any machine.
+    #
+    attr_reader :lockfile
+
+    # @param  [Sandbox]  sandbox     @see sandbox
+    # @param  [Podfile]  podfile     @see podfile
+    # @param  [Lockfile] lockfile    @see lockfile
+    #
+    def initialize(sandbox, podfile, lockfile = nil)
+      @sandbox  =  sandbox
+      @podfile  =  podfile
+      @lockfile =  lockfile
+    end
+
+    # @return [Bool] Whether the installer is in update mode. In update mode
+    #         the contents of the Lockfile are not taken into account for
+    #         deciding what Pods to install.
+    #
+    attr_accessor :update_mode
+
+    # Installs the Pods.
+    #
+    # The installation process of is mostly linear with few minor complications
+    # to keep in mind:
+    #
+    # - The stored podspecs need to be cleaned before the resolution step
+    #   otherwise the sandbox might return an old podspec and not download
+    #   the new one from an external source.
+    # - The resolver might trigger the download of Pods from external sources
+    #   necessary to retrieve their podspec (unless it is instructed not to
+    #   do it).
+    #
+    # @return [void]
+    #
+    def install!
+      resolve_dependencies
+      download_dependencies
+      generate_pods_project
+      integrate_user_project if config.integrate_targets?
+    end
 
-    def initialize(resolver)
-      @resolver = resolver
-      @podfile = resolver.podfile
-      @sandbox = resolver.sandbox
+    def resolve_dependencies
+      UI.section "Analyzing dependencies" do
+        analyze
+        prepare_for_legacy_compatibility
+        clean_sandbox
+      end
     end
 
-    def project
-      return @project if @project
-      @project = Pod::Project.new
-      @project.user_build_configurations = @podfile.user_build_configurations
-      pods.each { |p| p.add_file_references_to_project(@project) }
-      pods.each { |p| p.link_headers }
-      @project
+    def download_dependencies
+      UI.section "Downloading dependencies" do
+        create_file_accessors
+        install_pod_sources
+      end
     end
 
-    def target_installers
-      @target_installers ||= @podfile.target_definitions.values.map do |definition|
-        TargetInstaller.new(@podfile, project, definition) unless definition.empty?
-      end.compact
+    def generate_pods_project
+      UI.section "Generating Pods project" do
+        prepare_pods_project
+        run_pre_install_hooks
+        install_file_references
+        install_targets
+        run_post_install_hooks
+        write_pod_project
+        write_lockfiles
+      end
     end
 
-    # Install the Pods. If the resolver indicated that a Pod should be installed
-    #   and it exits, it is removed an then reinstalled. In any case if the Pod
-    #   doesn't exits it is installed.
+    #-------------------------------------------------------------------------#
+
+    public
+
+    # @!group Installation results
+
+    # @return [Analyzer] the analyzer which provides the information about what
+    #         needs to be installed.
+    #
+    attr_reader :analysis_result
+
+    # @return [Pod::Project] the `Pods/Pods.xcodeproj` project.
+    #
+    attr_reader :pods_project
+
+    # @return [Array<String>] The Pods that should be installed.
+    #
+    attr_reader :names_of_pods_to_install
+
+    # @return [Array<Library>] The libraries generated by the installation
+    #         process.
+    #
+    attr_reader :libraries
+
+    # @return [Array<Specification>] The specifications that where installed.
+    #
+    attr_accessor :installed_specs
+
+    #-------------------------------------------------------------------------#
+
+    private
+
+    # @!group Installation steps
+
+    # @return [void]
+    #
+    def analyze
+      analyzer = Analyzer.new(sandbox, podfile, lockfile)
+      analyzer.update_mode = update_mode
+      @analysis_result = analyzer.analyze
+      @libraries = analyzer.result.libraries
+    end
+
+    # Prepares the Pods folder in order to be compatible with the most recent
+    # version of CocoaPods.
     #
     # @return [void]
     #
-    def install_dependencies!
-      pods.sort_by { |pod| pod.top_specification.name.downcase }.each do |pod|
-        should_install = @resolver.should_install?(pod.top_specification.name) || !pod.exists?
-        if should_install
-          UI.section("Installing #{pod}".green, "-> ".green) do
-            unless pod.downloaded?
-              pod.implode
-              download_pod(pod)
-            end
-            # The docs need to be generated before cleaning because the
-            # documentation is created for all the subspecs.
-            generate_docs(pod)
-            # Here we clean pod's that just have been downloaded or have been
-            # pre-downloaded in AbstractExternalSource#specification_from_sandbox.
-            pod.clean! if config.clean?
+    def prepare_for_legacy_compatibility
+      # move_target_support_files_if_needed
+      # move_Local_Podspecs_to_Podspecs_if_needed
+      # move_pods_to_sources_folder_if_needed
+    end
+
+    # @return [void] In this step we clean all the folders that will be
+    #         regenerated from scratch and any file which might not be
+    #         overwritten.
+    #
+    # @todo   [#247] Clean the headers of only the pods to install.
+    #
+    def clean_sandbox
+      sandbox.build_headers.implode!
+      sandbox.public_headers.implode!
+
+      unless sandbox_state.deleted.empty?
+        title_options = { :verbose_prefix => "-> ".red }
+        sandbox_state.deleted.each do |pod_name|
+          UI.titled_section("Removing #{pod_name}".red, title_options) do
+            sandbox.clean_pod(pod_name)
           end
-        else
-          UI.section("Using #{pod}", "-> ".green)
         end
       end
     end
 
-    def download_pod(pod)
-      downloader = Downloader.for_pod(pod)
-      # Force the `bleeding edge' version if necessary.
-      if pod.top_specification.version.head?
-        if downloader.respond_to?(:download_head)
-          downloader.download_head
-        else
-          raise Informative, "The downloader of class `#{downloader.class.name}' does not support the `:head' option."
+    # TODO: the file accessor should be initialized by the sandbox as they
+    #       created by the Pod source installer as well.
+    #
+    def create_file_accessors
+      libraries.each do |library|
+        library.specs.each do |spec|
+          pod_root = sandbox.pod_dir(spec.root.name)
+          path_list = Sandbox::PathList.new(pod_root)
+          file_accessor = Sandbox::FileAccessor.new(path_list, spec.consumer(library.platform))
+          library.file_accessors ||= []
+          library.file_accessors << file_accessor
         end
-      else
-        downloader.download
       end
-      pod.downloaded = true
     end
 
-    #TODO: move to generator ?
-    def generate_docs(pod)
-      doc_generator = Generator::Documentation.new(pod)
-      if ( config.generate_docs? && !doc_generator.already_installed? )
-        UI.section " > Installing documentation"
-        doc_generator.generate(config.doc_install?)
-      else
-        UI.section " > Using existing documentation"
+    # Downloads, installs the documentation and cleans the sources of the Pods
+    # which need to be installed.
+    #
+    # @return [void]
+    #
+    def install_pod_sources
+      @installed_specs = []
+      pods_to_install = sandbox_state.added | sandbox_state.changed
+      title_options = { :verbose_prefix => "-> ".green }
+      root_specs.sort_by(&:name).each do |spec|
+        if pods_to_install.include?(spec.name)
+          UI.titled_section("Installing #{spec}".green, title_options) do
+            install_source_of_pod(spec.name)
+          end
+        else
+          UI.titled_section("Using #{spec}", title_options)
+        end
       end
     end
 
-    # @TODO: use the local pod implode
+    # Install the Pods. If the resolver indicated that a Pod should be
+    # installed and it exits, it is removed an then reinstalled. In any case if
+    # the Pod doesn't exits it is installed.
     #
-    def remove_deleted_dependencies!
-      resolver.removed_pods.each do |pod_name|
-        UI.section("Removing #{pod_name}", "-> ".red) do
-          path = sandbox.root + pod_name
-          path.rmtree if path.exist?
+    # @return [void]
+    #
+    def install_source_of_pod(pod_name)
+      specs_by_platform = {}
+      libraries.each do |library|
+        specs = library.specs.select { |spec| spec.root.name == pod_name }
+
+        unless specs.empty?
+          specs_by_platform[library.platform] ||= []
+          specs_by_platform[library.platform].concat(specs)
         end
       end
+
+      pod_installer = PodSourceInstaller.new(sandbox, specs_by_platform)
+      pod_installer.clean = config.clean?
+      pod_installer.aggressive_cache = config.aggressive_cache?
+      pod_installer.generate_docs = config.generate_docs?
+      pod_installer.install_docs = config.install_docs?
+      pod_installer.install!
+      @installed_specs.concat(specs_by_platform.values.flatten)
     end
 
-    def install!
-      @sandbox.prepare_for_install
-      UI.section "Resolving dependencies of #{UI.path @podfile.defined_in_file}" do
-        specs_by_target
+    # Creates the Pods project from scratch if it doesn't exists.
+    #
+    # @return [void]
+    #
+    # @todo   Clean and modify the project if it exists.
+    #
+    def prepare_pods_project
+      UI.message "- Creating Pods project" do
+        @pods_project = Pod::Project.new(sandbox.project_path)
+        if config.podfile_path.exist?
+          @pods_project.add_podfile(config.podfile_path)
+        end
+        sandbox.project = @pods_project
       end
+    end
 
-      UI.section "Removing deleted dependencies" do
-        remove_deleted_dependencies!
-      end unless resolver.removed_pods.empty?
-
-      UI.section "Downloading dependencies" do
-        install_dependencies!
-      end
 
-      UI.section "Generating support files" do
-        UI.message "- Running pre install hooks" do
-          run_pre_install_hooks
-        end
+    # Installs the file references in the Pods project. This is done once per
+    # Pod as the same file reference might be shared by multiple targets.
+    #
+    # @return [void]
+    #
+    def install_file_references
+      installer = FileReferencesInstaller.new(sandbox, libraries, pods_project)
+      installer.install!
+    end
 
-        UI.message"- Generating project" do
-          project
+    # Installs the targets of the Pods projects and generates their support
+    # files.
+    #
+    # @return [void]
+    #
+    def install_targets
+      UI.message"- Installing targets" do
+        libraries.sort_by(&:name).each do |library|
+          next if library.target_definition.empty?
+          target_installer = TargetInstaller.new(sandbox, library)
+          target_installer.install!
         end
+      end
+    end
 
-        UI.message"- Installing targets" do
-          generate_target_support_files
-        end
+    # Writes the Pods project to the disk.
+    #
+    # @return [void]
+    #
+    def write_pod_project
+      UI.message "- Writing Xcode project file to #{UI.path sandbox.project_path}" do
+        pods_project.main_group.sort_by_type!
+        pods_project['Frameworks'].sort_by_type!
+        pods_project.save_as(sandbox.project_path)
+      end
+    end
 
-        UI.message "- Running post install hooks" do
-          # Post install hooks run _before_ saving of project, so that they can alter it before saving.
-          run_post_install_hooks
-        end
+    # Writes the Podfile and the lock files.
+    #
+    # @todo   Pass the checkout options to the Lockfile.
+    #
+    # @return [void]
+    #
+    def write_lockfiles
+      # checkout_options = sandbox.checkout_options
+      @lockfile = Lockfile.generate(podfile, analysis_result.specifications)
 
-        UI.message "- Writing Xcode project file to #{UI.path @sandbox.project_path}" do
-          project.save_as(@sandbox.project_path)
-        end
+      UI.message "- Writing Lockfile in #{UI.path config.lockfile_path}" do
+        @lockfile.write_to_disk(config.lockfile_path)
+      end
 
-        UI.message "- Writing lockfile in #{UI.path config.project_lockfile}" do
-          @lockfile = Lockfile.generate(@podfile, specs_by_target.values.flatten)
-          @lockfile.write_to_disk(config.project_lockfile)
-        end
+      UI.message "- Writing Manifest in #{UI.path sandbox.manifest_path}" do
+        @lockfile.write_to_disk(sandbox.manifest_path)
       end
+    end
 
-        UserProjectIntegrator.new(@podfile).integrate! if config.integrate_targets?
+    # Integrates the user projects adding the dependencies on the CocoaPods
+    # libraries, setting them up to use the xcconfigs and performing other
+    # actions. This step is also responsible of creating the workspace if
+    # needed.
+    #
+    # @return [void]
+    #
+    # @todo   [#397] The libraries should be cleaned and the re-added on every
+    #         installation. Maybe a clean_user_project phase should be added.
+    #         In any case it appears to be a good idea store target definition
+    #         information in the lockfile.
+    #
+    def integrate_user_project
+      UI.section "Integrating client #{'project'.pluralize(libraries.map(&:user_project_path).uniq.count) }" do
+        installation_root = config.installation_root
+        integrator = UserProjectIntegrator.new(podfile, sandbox, installation_root, libraries)
+        integrator.integrate!
+      end
     end
 
+    #-------------------------------------------------------------------------#
+
+    private
+
+    # @!group Hooks
+
+    # Runs the pre install hooks of the installed specs and of the Podfile.
+    #
+    # @return [void]
+    #
     def run_pre_install_hooks
-      pods_by_target.each do |target_definition, pods|
-        pods.each do |pod|
-          pod.top_specification.pre_install(pod, target_definition)
+      UI.message "- Running pre install hooks" do
+        installed_specs.each do |spec|
+          executed = false
+          libraries_using_spec(spec).each do |lib|
+            executed ||= spec.pre_install!(pod_rep(spec.root.name), library_rep(lib))
+          end
+          UI.message "- #{spec.name}" if executed
         end
+
+        executed = @podfile.pre_install!(installer_rep)
+        UI.message "- Podfile" if executed
       end
-      @podfile.pre_install!(self)
     end
 
+    # Runs the post install hooks of the installed specs and of the Podfile.
+    #
+    # @note   Post install hooks run _before_ saving of project, so that they
+    #         can alter it before it is written to the disk.
+    #
+    # @return [void]
+    #
     def run_post_install_hooks
-      # we loop over target installers instead of pods, because we yield the target installer
-      # to the spec post install hook.
-      target_installers.each do |target_installer|
-        specs_by_target[target_installer.target_definition].each do |spec|
-          spec.post_install(target_installer)
+      UI.message "- Running post install hooks" do
+        installed_specs.each do |spec|
+          executed = false
+          libraries_using_spec(spec).each do |lib|
+            executed ||= spec.post_install!(library_rep(lib))
+          end
+          UI.message "- #{spec.name}" if executed
         end
+        executed = @podfile.post_install!(installer_rep)
+        UI.message "- Podfile" if executed
       end
-      @podfile.post_install!(self)
     end
 
-    def generate_target_support_files
-      target_installers.each do |target_installer|
-        pods_for_target = pods_by_target[target_installer.target_definition]
-        target_installer.install!(pods_for_target, @sandbox)
-        acknowledgements_path = target_installer.target_definition.acknowledgements_path
-        Generator::Acknowledgements.new(target_installer.target_definition,
-                                        pods_for_target).save_as(acknowledgements_path)
-        generate_dummy_source(target_installer)
-      end
+    #-------------------------------------------------------------------------#
+
+    public
+
+    # @!group Hooks Data
+
+    # @return [InstallerRepresentation]
+    #
+    def installer_rep
+      Hooks::InstallerRepresentation.new(self)
     end
 
-    def generate_dummy_source(target_installer)
-      class_name_identifier = target_installer.target_definition.label
-      dummy_source = Generator::DummySource.new(class_name_identifier)
-      filename = "#{dummy_source.class_name}.m"
-      pathname = Pathname.new(sandbox.root + filename)
-      dummy_source.save_as(pathname)
+    # @return [PodRepresentation] The hook representation of a Pod.
+    #
+    # @param  [String] pod
+    #         The name of the pod.
+    #
+    # @return [PodRepresentation] The pod representation.
+    #
+    def pod_rep(pod)
+      all_file_accessors = libraries.map(&:file_accessors).flatten.compact
+      file_accessors = all_file_accessors.select { |fa| fa.spec.root.name == pod }
+      Hooks::PodRepresentation.new(pod, file_accessors)
+    end
 
-      file = project.new_file(filename, "Targets Support Files")
-      target_installer.target.source_build_phase.add_file_reference(file)
+    # @return [LibraryRepresentation]
+    #
+    def library_rep(library)
+      Hooks::LibraryRepresentation.new(sandbox, library)
     end
 
-    def specs_by_target
-      @specs_by_target ||= @resolver.resolve
+    # @return [Array<LibraryRepresentation>]
+    #
+    def library_reps
+      @library_reps ||= libraries.map { |lib| library_rep(lib) }
     end
 
-    # @return [Array<Specification>]  All dependencies that have been resolved.
-    def specifications
-      specs_by_target.values.flatten
+    # @return [Array<PodRepresentation>]
+    #
+    def pod_reps
+      root_specs.sort_by { |spec| spec.name }.map { |spec| pod_rep(spec.name) }
     end
 
-    # @return [Array<LocalPod>]  A list of LocalPod instances for each
-    #                            dependency that is not a download-only one.
-    def pods
-      pods_by_target.values.flatten.uniq
+    # Returns the libraries which use the given specification.
+    #
+    # @param  [Specification] spec
+    #         The specification for which the client libraries are needed.
+    #
+    # @return [Array<Library>] The library.
+    #
+    def libraries_using_spec(spec)
+      libraries.select { |lib| lib.specs.include?(spec) }
     end
 
-    def pods_by_target
-      @pods_by_spec = {}
-      result = {}
-      specs_by_target.each do |target_definition, specs|
-        @pods_by_spec[target_definition.platform] = {}
-        result[target_definition] = specs.map do |spec|
-          if spec.local?
-            @sandbox.locally_sourced_pod_for_spec(spec, target_definition.platform)
-          else
-            @sandbox.local_pod_for_spec(spec, target_definition.platform)
-          end
-        end.uniq.compact
-      end
-      result
+    #-------------------------------------------------------------------------#
+
+    private
+
+    # @!group Private helpers
+
+    # @return [Array<Specification>] All the root specifications of the
+    #         installation.
+    #
+    def root_specs
+      analysis_result.specifications.map { |spec| spec.root }.uniq
+    end
+
+    # @return [SpecsState] The state of the sandbox returned by the analyzer.
+    #
+    def sandbox_state
+      analysis_result.sandbox_state
     end
+
+    #-------------------------------------------------------------------------#
+
   end
 end