cocoapods 0.37.2 → 0.38.0.beta.1

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

@@ -0,0 +1,46 @@
+module Pod
+  class Installer
+    class Analyzer
+      class AnalysisResult
+        # @return [SpecsState] the states of the Podfile specs.
+        #
+        attr_accessor :podfile_state
+
+        # @return [Hash{TargetDefinition => Array<Specification>}] the
+        #         specifications grouped by target.
+        #
+        attr_accessor :specs_by_target
+
+        # @return [Array<Specification>] the specifications of the resolved
+        #         version of Pods that should be installed.
+        #
+        attr_accessor :specifications
+
+        # @return [SpecsState] the states of the {Sandbox} respect the resolved
+        #         specifications.
+        #
+        attr_accessor :sandbox_state
+
+        # @return [Array<Target>] The Podfile targets containing library
+        #         dependencies.
+        #
+        attr_accessor :targets
+
+        # @return [Hash{TargetDefinition => Array<TargetInspectionResult>}] the
+        #         results of inspecting the user targets
+        attr_accessor :target_inspections
+
+        # @return [Hash{String=>Symbol}] A hash representing all the user build
+        #         configurations across all integration targets. Each key
+        #         corresponds to the name of a configuration and its value to
+        #         its type (`:debug` or `:release`).
+        #
+        def all_user_build_configurations
+          targets.reduce({}) do |result, target|
+            result.merge(target.user_build_configurations)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+module Pod
+  class Installer
+    class Analyzer
+      # This class represents the state of a collection of Pods.
+      #
+      # @note The names of the pods stored by this class are always the **root**
+      #       name of the specification.
+      #
+      # @note The motivation for this class is to ensure that the names of the
+      #       subspecs are added instead of the name of the Pods.
+      #
+      class SpecsState
+        # Initialize a new instance
+        #
+        # @param  [Hash{Symbol=>String}] pods_by_state
+        #         The name of the pods grouped by their state
+        #         (`:added`, `:removed`, `:changed` or `:unchanged`).
+        #
+        def initialize(pods_by_state = nil)
+          @added     = []
+          @deleted   = []
+          @changed   = []
+          @unchanged = []
+
+          if pods_by_state
+            @added     = pods_by_state[:added]     || []
+            @deleted   = pods_by_state[:removed]   || []
+            @changed   = pods_by_state[:changed]   || []
+            @unchanged = pods_by_state[:unchanged] || []
+          end
+        end
+
+        # @return [Array<String>] the names of the pods that were added.
+        #
+        attr_accessor :added
+
+        # @return [Array<String>] the names of the pods that were changed.
+        #
+        attr_accessor :changed
+
+        # @return [Array<String>] the names of the pods that were deleted.
+        #
+        attr_accessor :deleted
+
+        # @return [Array<String>] the names of the pods that were unchanged.
+        #
+        attr_accessor :unchanged
+
+        # Displays the state of each pod.
+        #
+        # @return [void]
+        #
+        def print
+          added    .sort.each { |pod| UI.message('A'.green  + " #{pod}", '', 2) }
+          deleted  .sort.each { |pod| UI.message('R'.red    + " #{pod}", '', 2) }
+          changed  .sort.each { |pod| UI.message('M'.yellow + " #{pod}", '', 2) }
+          unchanged.sort.each { |pod| UI.message('-'        + " #{pod}", '', 2) }
+        end
+
+        # Adds the name of a Pod to the give state.
+        #
+        # @param  [String] name
+        #         the name of the Pod.
+        #
+        # @param  [Symbol] state
+        #         the state of the Pod.
+        #
+        # @return [void]
+        #
+        def add_name(name, state)
+          send(state) << name
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module Pod
+  class Installer
+    class Analyzer
+      class TargetInspectionResult
+        # @return [TargetDefinition] the target definition, whose project was
+        #         inspected
+        #
+        attr_accessor :target_definition
+
+        # @return [Pathname] the path of the user project that the
+        #         #target_definition should integrate
+        #
+        attr_accessor :project_path
+
+        # @return [Array<String>] the uuid of the user's targets
+        #
+        attr_accessor :project_target_uuids
+
+        # @return [Hash{String=>Symbol}] A hash representing the user build
+        #         configurations where each key corresponds to the name of a
+        #         configuration and its value to its type (`:debug` or
+        #         `:release`).
+        #
+        attr_accessor :build_configurations
+
+        # @return [Platform] the platform of the user targets
+        #
+        attr_accessor :platform
+
+        # @return [Array<String>] the architectures used by user's targets
+        #
+        attr_accessor :archs
+
+        # @return [Bool] whether frameworks are recommended for the integration
+        #         due to the presence of Swift source in the user's targets
+        #
+        attr_accessor :recommends_frameworks
+      end
+    end
+  end
+end

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

@@ -0,0 +1,203 @@
+module Pod
+  class Installer
+    class Analyzer
+      class TargetInspector
+        # @return [TargetDefinition] the target definition to inspect
+        #
+        attr_accessor :target_definition
+
+        # @return [Pathname] the root of the CocoaPods installation where the
+        #         Podfile is located
+        attr_accessor :installation_root
+
+        # Initialize a new instance
+        #
+        # @param [TargetDefinition] target_definition
+        #        @see #target_definition
+        #
+        # @param [Pathname] installation_root
+        #        @see #installation_root
+        #
+        def initialize(target_definition, installation_root)
+          @target_definition = target_definition
+          @installation_root = installation_root
+        end
+
+        # Inspect the #target_definition
+        #
+        # @return [TargetInspectionResult]
+        #
+        def compute_results
+          project_path = compute_project_path
+          user_project = Xcodeproj::Project.open(project_path)
+          targets = compute_targets(user_project)
+
+          result = TargetInspectionResult.new
+          result.target_definition = target_definition
+          result.project_path = project_path
+          result.project_target_uuids = targets.map(&:uuid)
+          result.build_configurations = compute_build_configurations(targets)
+          result.platform = compute_platform(targets)
+          result.archs = compute_archs(targets)
+          result
+        end
+
+        #-----------------------------------------------------------------------#
+
+        private
+
+        # Returns the path of the user project that the #target_definition
+        # should integrate.
+        #
+        # @raise  If the project is implicit and there are multiple projects.
+        #
+        # @raise  If the path doesn't exits.
+        #
+        # @return [Pathname] the path of the user project.
+        #
+        def compute_project_path
+          if target_definition.user_project_path
+            path = installation_root + target_definition.user_project_path
+            path = "#{path}.xcodeproj" unless File.extname(path) == '.xcodeproj'
+            path = Pathname.new(path)
+            unless path.exist?
+              raise Informative, 'Unable to find the Xcode project ' \
+              "`#{path}` for the target `#{target_definition.label}`."
+            end
+          else
+            xcodeprojs = installation_root.children.select { |e| e.fnmatch('*.xcodeproj') }
+            if xcodeprojs.size == 1
+              path = xcodeprojs.first
+            else
+              raise Informative, 'Could not automatically select an Xcode project. ' \
+                "Specify one in your Podfile like so:\n\n" \
+                "    xcodeproj 'path/to/Project.xcodeproj'\n"
+            end
+          end
+          path
+        end
+
+        # Returns a list of the targets from the project of #target_definition
+        # that needs to be integrated.
+        #
+        # @note   The method first looks if there is a target specified with
+        #         the `link_with` option of the {TargetDefinition}. Otherwise
+        #         it looks for the target that has the same name of the target
+        #         definition.  Finally if no target was found the first
+        #         encountered target is returned (it is assumed to be the one
+        #         to integrate in simple projects).
+        #
+        # @param  [Xcodeproj::Project] user_project
+        #         the user project
+        #
+        # @return [Array<PBXNativeTarget>]
+        #
+        def compute_targets(user_project)
+          native_targets = user_project.native_targets
+          if link_with = target_definition.link_with
+            targets = native_targets.select { |t| link_with.include?(t.name) }
+            raise Informative, "Unable to find the targets named #{link_with.map { |x| "`#{x}`" }.to_sentence}" \
+              "to link with target definition `#{target_definition.name}`" if targets.empty?
+          elsif target_definition.link_with_first_target?
+            targets = [native_targets.first].compact
+            raise Informative, 'Unable to find a target' if targets.empty?
+          else
+            target = native_targets.find { |t| t.name == target_definition.name.to_s }
+            targets = [target].compact
+            raise Informative, "Unable to find a target named `#{target_definition.name}`" if targets.empty?
+          end
+          targets
+        end
+
+        # @param  [Array<PBXNativeTarget] the user's targets of the project of
+        #         #target_definition which needs to be integrated
+        #
+        # @return [Hash{String=>Symbol}] A hash representing the user build
+        #         configurations where each key corresponds to the name of a
+        #         configuration and its value to its type (`:debug` or `:release`).
+        #
+        def compute_build_configurations(user_targets)
+          if user_targets
+            user_targets.flat_map { |t| t.build_configurations.map(&:name) }.each_with_object({}) do |name, hash|
+              hash[name] = name == 'Debug' ? :debug : :release
+            end.merge(target_definition.build_configurations || {})
+          else
+            target_definition.build_configurations || {}
+          end
+        end
+
+        # @param  [Array<PBXNativeTarget] the user's targets of the project of
+        #         #target_definition which needs to be integrated
+        #
+        # @return [Platform] The platform of the user's targets
+        #
+        # @note   This resolves to the lowest deployment target across the user
+        #         targets.
+        #
+        # @todo   Is assigning the platform to the target definition the best way
+        #         to go?
+        #
+        def compute_platform(user_targets)
+          return target_definition.platform if target_definition.platform
+          name = nil
+          deployment_target = nil
+
+          user_targets.each do |target|
+            name ||= target.platform_name
+            raise Informative, 'Targets with different platforms' unless name == target.platform_name
+            if !deployment_target || deployment_target > Version.new(target.deployment_target)
+              deployment_target = Version.new(target.deployment_target)
+            end
+          end
+
+          target_definition.set_platform(name, deployment_target)
+          Platform.new(name, deployment_target)
+        end
+
+        # Computes the architectures relevant for the user's targets.
+        #
+        # @param  [Array<PBXNativeTarget] the user's targets of the project of
+        #         #target_definition which needs to be integrated
+        #
+        # @return [Array<String>]
+        #
+        def compute_archs(user_targets)
+          user_targets.flat_map do |target|
+            Array(target.common_resolved_build_setting('ARCHS'))
+          end.compact.uniq.sort
+        end
+
+        # Checks if any of the targets for the {TargetDefinition} computed before
+        # by #compute_user_project_targets is recommended to be build as a framework
+        # due the presence of Swift source code in any of the source build phases.
+        #
+        # @param  [TargetDefinition] target_definition
+        #         the target definition
+        #
+        # @param  [Array<PBXNativeTarget>] native_targets
+        #         the targets which are checked for presence of Swift source code
+        #
+        # @return [Boolean] Whether the user project targets to integrate into
+        #         uses Swift
+        #
+        def compute_recommends_frameworks(target_definition, native_targets)
+          file_predicate = nil
+          file_predicate = proc do |file_ref|
+            if file_ref.respond_to?(:last_known_file_type)
+              file_ref.last_known_file_type == 'sourcecode.swift'
+            elsif file_ref.respond_to?(:files)
+              file_ref.files.any?(&file_predicate)
+            else
+              false
+            end
+          end
+          target_definition.platform.supports_dynamic_frameworks? || native_targets.any? do |target|
+            target.source_build_phase.files.any? do |build_file|
+              file_predicate.call(build_file.file_ref)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cocoapods/installer/file_references_installer.rb

@@ -8,9 +8,9 @@ module Pod
       #
       attr_reader :sandbox
 
-      # @return [Array<PodTarget>] The libraries of the installation.
+      # @return [Array<PodTarget>] The pod targets of the installation.
       #
-      attr_reader :libraries
+      attr_reader :pod_targets
 
       # @return [Project] The Pods project.
       #
@@ -19,12 +19,12 @@ module Pod
       # Initialize a new instance
       #
       # @param [Sandbox] sandbox @see sandbox
-      # @param [Array<PodTarget>] libraries @see libraries
-      # @param [Project] libraries @see libraries
+      # @param [Array<PodTarget>] pod_targets @see pod_targets
+      # @param [Project] pods_project @see pod_project
       #
-      def initialize(sandbox, libraries, pods_project)
+      def initialize(sandbox, pod_targets, pods_project)
         @sandbox = sandbox
-        @libraries = libraries
+        @pod_targets = pod_targets
         @pods_project = pods_project
       end
 
@@ -113,18 +113,23 @@ module Pod
       #
       def link_headers
         UI.message '- Linking headers' do
-          libraries.each do |library|
-            library.file_accessors.each do |file_accessor|
+          pod_targets.each do |pod_target|
+            pod_target.file_accessors.each do |file_accessor|
+              framework_exp = /.framework\//
               headers_sandbox = Pathname.new(file_accessor.spec.root.name)
-              library.build_headers.add_search_path(headers_sandbox, library.platform)
-              sandbox.public_headers.add_search_path(headers_sandbox, library.platform)
+              pod_target.build_headers.add_search_path(headers_sandbox, pod_target.platform)
+              sandbox.public_headers.add_search_path(headers_sandbox, pod_target.platform)
 
               header_mappings(headers_sandbox, file_accessor, file_accessor.headers).each do |namespaced_path, files|
-                library.build_headers.add_files(namespaced_path, files, library.platform)
+                pod_target.build_headers.add_files(namespaced_path, files.reject { |f| f.to_path =~ framework_exp }, pod_target.platform)
               end
 
               header_mappings(headers_sandbox, file_accessor, file_accessor.public_headers).each do |namespaced_path, files|
-                sandbox.public_headers.add_files(namespaced_path, files, library.platform)
+                sandbox.public_headers.add_files(namespaced_path, files.reject { |f| f.to_path =~ framework_exp }, pod_target.platform)
+              end
+
+              vendored_frameworks_header_mappings(headers_sandbox, file_accessor).each do |namespaced_path, files|
+                sandbox.public_headers.add_files(namespaced_path, files, pod_target.platform)
               end
             end
           end
@@ -141,7 +146,7 @@ module Pod
       #         specs platform combinations.
       #
       def file_accessors
-        @file_accessors ||= libraries.map(&:file_accessors).flatten.compact
+        @file_accessors ||= pod_targets.map(&:file_accessors).flatten.compact
       end
 
       # Adds file references to the list of the paths returned by the file
@@ -208,6 +213,36 @@ module Pod
         mappings
       end
 
+      # Computes the destination sub-directory in the sandbox for headers
+      # from inside vendored frameworks.
+      #
+      # @param  [Pathname] headers_sandbox
+      #         The sandbox where the header links should be stored for this
+      #         Pod.
+      #
+      # @param  [Sandbox::FileAccessor] file_accessor
+      #         The consumer file accessor for which the headers need to be
+      #         linked.
+      #
+      def vendored_frameworks_header_mappings(headers_sandbox, file_accessor)
+        mappings = {}
+        file_accessor.vendored_frameworks.each do |framework|
+          headers_dir = Sandbox::FileAccessor.vendored_frameworks_headers_dir(framework)
+          headers = Sandbox::FileAccessor.vendored_frameworks_headers(framework)
+          framework_name = framework.basename(framework.extname)
+          dir = headers_sandbox + framework_name
+          headers.each do |header|
+            # the relative path of framework headers should be kept,
+            # not flattened like is done for most public headers.
+            relative_path = header.relative_path_from(headers_dir)
+            sub_dir = dir + relative_path.dirname
+            mappings[sub_dir] ||= []
+            mappings[sub_dir] << header
+          end
+        end
+        mappings
+      end
+
       #-----------------------------------------------------------------------#
     end
   end