cocoapods 0.16.4 → 0.17.0.rc1

data/lib/cocoapods/installer/user_project_integrator.rb

@@ -6,208 +6,172 @@ require 'active_support/core_ext/array/conversions'
 
 module Pod
   class Installer
+
+    # The {UserProjectIntegrator} integrates the libraries generated by
+    # TargetDefinitions of the {Podfile} with their correspondent user
+    # projects.
+    #
     class UserProjectIntegrator
-      include Pod::Config::Mixin
 
-      def initialize(podfile)
+      autoload :TargetIntegrator, 'cocoapods/installer/user_project_integrator/target_integrator'
+
+      # @return [Podfile] the podfile that should be integrated with the user
+      #         projects.
+      #
+      attr_reader :podfile
+
+      # @return [Project] the pods project which contains the libraries to
+      #         integrate.
+      #
+      # attr_reader :pods_project
+
+      attr_reader :sandbox
+
+      # @return [Pathname] the path of the installation.
+      #
+      # @todo This is only used to compute the workspace path in case that it
+      #       should be inferred by the project. If the workspace should be in
+      #       the same dir of the project, this could be removed.
+      #
+      attr_reader :installation_root
+
+      # @return [Library] the libraries generated by the installer.
+      #
+      attr_reader :libraries
+
+      # @param  [Podfile]  podfile @see #podfile
+      # @param  [Sandbox]  sandbox @see #sandbox
+      # @param  [Pathname] installation_root @see #installation_root
+      # @param  [Library]  libraries @see #libraries
+      #
+      # @todo   Too many initialization arguments
+      #
+      def initialize(podfile, sandbox, installation_root, libraries)
         @podfile = podfile
+        @sandbox = sandbox
+        @installation_root = installation_root
+        @libraries = libraries
       end
 
+      # Integrates the user projects associated with the {TargetDefinitions}
+      # with the Pods project and its products.
+      #
+      # @return [void]
+      #
       def integrate!
-        create_workspace!
-
-        # Only need to write out the user's project if any of the target
-        # integrators actually did some work.
-        target_integrators.map(&:integrate!)
-      end
-
-      def workspace_path
-        @podfile.workspace || raise(Informative, "Could not automatically select an Xcode workspace. " \
-                                                 "Specify one in your Podfile.")
+        create_workspace
+        integrate_user_targets
+        warn_about_empty_podfile
       end
 
-      def pods_project_path
-        config.project_root + "Pods/Pods.xcodeproj"
-      end
+      #-----------------------------------------------------------------------#
+
+      private
+
+      # @!group Integration steps
+
+      # Creates and saved the workspace containing the Pods project and the
+      # user projects, if needed.
+      #
+      # @note If the workspace already contains the projects it is not saved
+      #       to avoid Xcode from displaying the revert dialog: `Do you want to
+      #       keep the Xcode version or revert to the version on disk?`
+      #
+      # @return [void]
+      #
+      def create_workspace
+        all_projects = user_project_paths.sort.push(sandbox.project_path).uniq
+        projpaths = all_projects.map do |path|
+          path.relative_path_from(workspace_path.dirname).to_s
+        end
 
-      def target_integrators
-        @target_integrators ||= @podfile.target_definitions.values.map do |definition|
-          TargetIntegrator.new(definition) unless definition.empty?
-        end.compact
-      end
+        if workspace_path.exist?
+          workspace = Xcodeproj::Workspace.new_from_xcworkspace(workspace_path)
+          new_projpaths = projpaths - workspace.projpaths
+          unless new_projpaths.empty?
+            workspace.projpaths.concat(new_projpaths)
+            workspace.save_as(workspace_path)
+          end
 
-      def user_project_paths
-        @podfile.target_definitions.values.map do |td|
-          next if td.empty?
-          td.user_project.path #|| raise(Informative, "Could not resolve the Xcode project in which the " \
-                               #                      "`#{td.name}' target should be integrated.")
-        end.compact
+        else
+          UI.notice "From now on use `#{workspace_path.basename}`."
+          workspace = Xcodeproj::Workspace.new(*projpaths)
+          workspace.save_as(workspace_path)
+        end
       end
 
-      def create_workspace!
-        workspace = Xcodeproj::Workspace.new_from_xcworkspace(workspace_path)
-        [pods_project_path, *user_project_paths].each do |project_path|
-          project_path = project_path.relative_path_from(config.project_root).to_s
-          workspace << project_path unless workspace.include?(project_path)
-        end
-        unless workspace_path.exist? || config.silent?
-          UI.notice "From now on use `#{workspace_path.basename}'."
+      # Integrates the targets of the user projects with the libraries
+      # generated from the {Podfile}.
+      #
+      # @note   {TargetDefinition} without dependencies are skipped prevent
+      #         creating empty libraries for targets definitions which are only
+      #         wrappers for others.
+      #
+      # @return [void]
+      #
+      def integrate_user_targets
+        libraries_to_integrate.sort_by(&:name).each do |lib|
+          TargetIntegrator.new(lib).integrate!
         end
-        workspace.save_as(workspace_path)
       end
 
-      class TargetIntegrator
-        include Pod::Config::Mixin
-
-        attr_reader :target_definition
-
-        def initialize(target_definition)
-          @target_definition = target_definition
+      # Warns the user if the podfile is empty.
+      #
+      # @note   The workspace is created in any case and all the user projects
+      #         are added to it, however the projects are not integrated as
+      #         there is no way to discern between target definitions which are
+      #         empty and target definitions which just serve the purpose to
+      #         wrap other ones. This is not an issue because empty target
+      #         definitions generate empty libraries.
+      #
+      # @return [void]
+      #
+      def warn_about_empty_podfile
+        if podfile.target_definitions.values.all?{ |td| td.empty? }
+          UI.warn "[!] The Podfile does not contain any dependency."
         end
+      end
 
-        def inspect
-          "#<#{self.class} for target `#{@target_definition.label}'>"
-        end
+      #-----------------------------------------------------------------------#
 
-        # Integrates the user project targets. Only the targets that do **not**
-        # already have the Pods library in their frameworks build phase are
-        # processed.
-        #
-        # @return [void]
-        #
-        def integrate!
-          return if targets.empty?
-
-          UI.section("Integrating `#{@target_definition.lib_name}' into #{'target'.pluralize(targets.size)} " \
-                      "`#{targets.map(&:name).to_sentence}' of Xcode project #{UI.path user_project_path}.") do
-            add_xcconfig_base_configuration
-            add_pods_library
-            add_copy_resources_script_phase
-            user_project.save_as(@target_definition.user_project.path)
-          end
-        end
+      private
 
-        # @return [Pathname] the path of the user project.
-        #
-        # @raises If the path doesn't exits.
-        #
-        # @raises If the project is implicit and there are multiple projects.
-        #
-        def user_project_path
-          if path = @target_definition.user_project.path
-            unless path.exist?
-              raise Informative, "The Xcode project `#{path}' does not exist."
-            end
-            path
-          else
-            raise Informative, "Could not automatically select an Xcode project.\n" \
-                               "Specify one in your Podfile like so:\n\n" \
-                               "  xcodeproj 'path/to/XcodeProject'"
-          end
-        end
+      # @!group Helpers.
 
-        # @return [Xcodeproj::Project] Returns the project of the user.
-        #
-        def user_project
-          @user_project ||= Xcodeproj::Project.new(user_project_path)
+      # @return [Pathname] the path where the workspace containing the Pods
+      #         project and the user projects should be saved.
+      #
+      def workspace_path
+        if podfile.workspace_path
+          podfile.workspace_path
+        elsif user_project_paths.count == 1
+          project = user_project_paths.first.basename('.xcodeproj')
+          installation_root + "#{project}.xcworkspace"
+        else
+          raise Informative, "Could not automatically select an Xcode " \
+            "workspace. Specify one in your Podfile like so:\n\n"       \
+            "    workspace 'path/to/Workspace.xcworkspace'\n"
         end
+      end
 
-        # @return [Array<PBXNativeTarget>] Returns the user’s targets,
-        #                                  excluding aggregate targets.
-        def native_targets
-          user_project.targets.reject do |target|
-            target.is_a? Xcodeproj::Project::Object::PBXAggregateTarget
-          end
-        end
+      # @return [Array<Pathname>] the paths of all the user projects referenced
+      #         by the target definitions.
+      #
+      # @note   Empty target definitions are ignored.
+      #
+      def user_project_paths
+        libraries.map do |lib|
+          lib.user_project_path
+        end.compact.uniq
+      end
 
-        # This returns a list of the targets from the user’s project to which
-        # this Pods static library should be linked. If no explicit target was
-        # specified, then the first encountered target is assumed.
-        #
-        # In addition this will only return targets that do **not** already
-        # have the Pods library in their frameworks build phase.
-        #
-        # @return [Array<PBXNativeTarget>]  Returns the list of targets that
-        #                                   the Pods lib should be linked with.
-        def targets
-          if @targets.nil?
-            targets = nil
-            # Find explicitly linked targets.
-            if link_with = @target_definition.link_with
-              targets = native_targets.select do |target|
-                link_with.include? target.name
-              end
-
-            # Otherwise try to find a target matching the name.
-            elsif @target_definition.name != :default
-              target = native_targets.find do |target|
-                target.name == @target_definition.name.to_s
-              end
-              unless target
-                raise Informative, "Unable to find a target named `#{@target_definition.name.to_s}'"
-              end
-              targets = [target]
-
-            # Default to the first target, which in a simple project is
-            # probably an app target.
-            else
-              targets = [native_targets.first]
-            end
-
-            # Reject any target that already has this Pods library in one of
-            # its frameworks build phases
-            @targets = targets.reject do |target|
-              target.frameworks_build_phase.files.any? do |build_file|
-                file_ref = build_file.file_ref
-                !file_ref.proxy? && file_ref.display_name == @target_definition.lib_name
-              end
-            end
-          end
-          @targets
-        end
 
-        def add_xcconfig_base_configuration
-          xcconfig = user_project.new_file(@target_definition.xcconfig_relative_path)
-          targets.each do |target|
-            config_build_names_by_overriden_key = {}
-            target.build_configurations.each do |config|
-              config_name = config.name
-              if @target_definition.xcconfig
-                @target_definition.xcconfig.attributes.each do |key, value|
-                  target_value = config.build_settings[key]
-                  if target_value && !target_value.include?('$(inherited)')
-                    config_build_names_by_overriden_key[key] ||= []
-                    config_build_names_by_overriden_key[key] << config_name
-                  end
-                end
-              end
-
-              config.base_configuration_reference = xcconfig
-            end
-
-            config_build_names_by_overriden_key.each do |key, config_build_names|
-              name    = "#{target.name} [#{config_build_names.join(' - ')}]"
-              actions = [ "Use the `$(inherited)' flag, or", "Remove the build settings from the target." ]
-              UI.warn("The target `#{name}' overrides the `#{key}' build setting defined in `#{@target_definition.xcconfig_relative_path}'.", actions)
-            end
-          end
-        end
+      def libraries_to_integrate
+        libraries.reject { |lib| lib.target_definition.empty? }
+      end
 
-        def add_pods_library
-          frameworks = user_project.frameworks_group
-          pods_library = frameworks.new_static_library(@target_definition.label)
-          targets.each do |target|
-            target.frameworks_build_phase.add_file_reference(pods_library)
-          end
-        end
+      #-----------------------------------------------------------------------#
 
-        def add_copy_resources_script_phase
-          targets.each do |target|
-            phase = target.new_shell_script_build_phase('Copy Pods Resources')
-            phase.shell_script = %{"#{@target_definition.copy_resources_script_relative_path}"\n}
-          end
-        end
-      end
     end
   end
 end

data/lib/cocoapods/installer/user_project_integrator/target_integrator.rb

@@ -0,0 +1,193 @@
+module Pod
+  class Installer
+    class UserProjectIntegrator
+
+      # This class is responsible for integrating the library generated by a
+      # {TargetDefinition} with its destination project.
+      #
+      class TargetIntegrator
+
+        # @return [Library] the library that should be integrated.
+        #
+        attr_reader :library
+
+        # @param  [Library] library @see #target_definition
+        #
+        def initialize(library)
+          @library = library
+        end
+
+        # Integrates the user project targets. Only the targets that do **not**
+        # already have the Pods library in their frameworks build phase are
+        # processed.
+        #
+        # @return [void]
+        #
+        def integrate!
+          return if targets.empty?
+          UI.section(integration_message) do
+            add_xcconfig_base_configuration
+            add_pods_library
+            add_copy_resources_script_phase
+            save_user_project
+          end
+        end
+
+        # @return [Array<PBXNativeTarget>] the list of targets that the Pods
+        #         lib that need to be integrated.
+        #
+        # @note   A target is considered integrated if it already references
+        #
+        def targets
+          unless @targets
+            target_uuids = library.user_target_uuids
+            targets = target_uuids.map do |uuid|
+              target = user_project.objects_by_uuid[uuid]
+              unless target
+                raise Informative, "[Bug] Unable to find the target with " \
+                  "the `#{uuid}` UUID for the `#{library}` library"
+              end
+              target
+            end
+            non_integrated = targets.reject do |target|
+              target.frameworks_build_phase.files.any? do |build_file|
+                file_ref = build_file.file_ref
+                !file_ref.proxy? && file_ref.display_name == library.product_name
+              end
+            end
+            @targets = non_integrated
+          end
+          @targets
+        end
+
+        # Read the project from the disk to ensure that it is up to date as
+        # other TargetIntegrators might have modified it.
+        #
+        def user_project
+          @user_project ||= Xcodeproj::Project.new(library.user_project_path)
+        end
+
+        # @return [String] a string representation suitable for debugging.
+        #
+        def inspect
+          "#<#{self.class} for target `#{target_definition.label}'>"
+        end
+
+        #---------------------------------------------------------------------#
+
+        # @!group Integration steps
+
+        private
+
+        # Adds the `xcconfig` configurations files generated for the current
+        # {TargetDefinition} to the build configurations of the targets that
+        # should be integrated.
+        #
+        # @note   It also checks if any build setting of the build
+        #         configurations overrides the `xcconfig` file and warns the
+        #         user.
+        #
+        # @todo   If the xcconfig is already set don't override it and inform
+        #         the user.
+        #
+        # @return [void]
+        #
+        def add_xcconfig_base_configuration
+          xcconfig = user_project.new_file(library.xcconfig_relative_path)
+          targets.each do |target|
+            check_overridden_build_settings(library.xcconfig, target)
+            target.build_configurations.each do |config|
+              config.base_configuration_reference = xcconfig
+            end
+          end
+        end
+
+        # Adds a file reference to the library of the {TargetDefinition} and
+        # adds it to the frameworks build phase of the targets.
+        #
+        # @return [void]
+        #
+        def add_pods_library
+          frameworks = user_project.frameworks_group
+          pods_library = frameworks.new_static_library(library.label)
+          targets.each do |target|
+            target.frameworks_build_phase.add_file_reference(pods_library)
+          end
+        end
+
+        # Adds a shell script build phase responsible to copy the resources
+        # generated by the TargetDefinition to the bundle of the product of the
+        # targets.
+        #
+        # @return [void]
+        #
+        def add_copy_resources_script_phase
+          targets.each do |target|
+            phase = target.new_shell_script_build_phase('Copy Pods Resources')
+            path  = library.copy_resources_script_relative_path
+            phase.shell_script = %{"#{path}"\n}
+          end
+        end
+
+        # Saves the changes to the user project to the disk.
+        #
+        # @return [void]
+        #
+        def save_user_project
+          user_project.save_as(library.user_project_path)
+        end
+
+        #---------------------------------------------------------------------#
+
+        # @!group Private helpers.
+
+        private
+
+        # Informs the user about any build setting of the target which might
+        # override the given xcconfig file.
+        #
+        # @return [void]
+        #
+        def check_overridden_build_settings(xcconfig, target)
+          return unless xcconfig
+
+          configs_by_overridden_key = {}
+          target.build_configurations.each do |config|
+            xcconfig.attributes.keys.each do |key|
+              target_value = config.build_settings[key]
+
+              if target_value && !target_value.include?('$(inherited)')
+                configs_by_overridden_key[key] ||= []
+                configs_by_overridden_key[key] << config.name
+              end
+            end
+
+            configs_by_overridden_key.each do |key, config_names|
+              name    = "#{target.name} [#{config_names.join(' - ')}]"
+              actions = [
+                "Use the `$(inherited)` flag, or",
+                "Remove the build settings from the target."
+              ]
+              UI.warn("The target `#{name}` overrides the `#{key}` build " \
+                      "setting defined in `#{library.xcconfig_relative_path}'.",
+                      actions)
+            end
+          end
+        end
+
+        # @return [String] the message that should be displayed for the target
+        #         integration.
+        #
+        def integration_message
+          "Integrating `#{library.product_name}` into " \
+            "#{'target'.pluralize(targets.size)} "  \
+            "`#{targets.map(&:name).to_sentence}` " \
+            "of project #{UI.path library.user_project_path}."
+        end
+
+        #---------------------------------------------------------------------#
+
+      end
+    end
+  end
+end