xcocoapods 1.5.3

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

@@ -0,0 +1,240 @@
+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 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
+
+        alias_method :update_mode?, :update_mode
+
+        # Init a new SandboxAnalyzer
+        #
+        # @param [Sandbox] sandbox @see sandbox
+        # @param [Array<Specifications>] specs @see specs
+        # @param [Bool] update_mode @see update_mode
+        #
+        def initialize(sandbox, specs, update_mode)
+          @sandbox = sandbox
+          @specs = specs
+          @update_mode = update_mode
+        end
+
+        # Performs the analysis to the detect the state of the sandbox respect
+        # to the resolved specifications.
+        #
+        # @return [void]
+        #
+        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.merge(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)
+          :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) && !sandbox.local?(pod)
+          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)
+          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 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)
+          false
+        end
+
+        #---------------------------------------------------------------------#
+
+        private
+
+        # @!group Private helpers
+
+        # @return [Lockfile] The manifest to use for the sandbox.
+        #
+        def sandbox_manifest
+          sandbox.manifest
+        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.sort
+        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.sort
+        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/analyzer/specs_state.rb

@@ -0,0 +1,84 @@
+require 'set'
+
+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
+        # @return [Set<String>] the names of the pods that were added.
+        #
+        attr_reader :added
+
+        # @return [Set<String>] the names of the pods that were changed.
+        #
+        attr_reader :changed
+
+        # @return [Set<String>] the names of the pods that were deleted.
+        #
+        attr_reader :deleted
+
+        # @return [Set<String>] the names of the pods that were unchanged.
+        #
+        attr_reader :unchanged
+
+        # 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     = Set.new
+          @deleted   = Set.new
+          @changed   = Set.new
+          @unchanged = Set.new
+
+          if pods_by_state
+            {
+              :added => :added,
+              :changed => :changed,
+              :removed => :deleted,
+              :unchanged => :unchanged,
+            }.each do |state, spec_state|
+              Array(pods_by_state[state]).each do |name|
+                add_name(name, spec_state)
+              end
+            end
+          end
+        end
+
+        # 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) << Specification.root_name(name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+module Pod
+  class Installer
+    class Analyzer
+      class TargetInspectionResult
+        # @return [TargetDefinition] the target definition, whose project was
+        #         inspected
+        #
+        attr_reader :target_definition
+
+        # @return [Xcodeproj::Project] the user's Xcode project
+        #
+        attr_reader :project
+
+        # @return [Array<String>] the uuid of the user's targets
+        #
+        attr_reader :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_reader :build_configurations
+
+        # @return [Platform] the platform of the user targets
+        #
+        attr_reader :platform
+
+        # @return [Array<String>] the architectures used by user's targets
+        #
+        attr_reader :archs
+
+        # Initialize a new instance
+        #
+        # @param [TargetDefinition] target_definition @see #target_definition
+        # @param [Xcodeproj::Project] project @see #project
+        # @param [Array<String>] project_target_uuids @see #project_target_uuids
+        # @param [Hash{String=>Symbol}] build_configurations @see #build_configurations
+        # @param [Platform] platform @see #platform
+        # @param [Array<String>] archs @see #archs
+        #
+        def initialize(target_definition, project, project_target_uuids, build_configurations, platform, archs)
+          @target_definition = target_definition
+          @project = project
+          @project_target_uuids = project_target_uuids
+          @build_configurations = build_configurations
+          @platform = platform
+          @archs = archs
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,260 @@
+require 'active_support/core_ext/array/conversions'
+
+module Pod
+  class Installer
+    class Analyzer
+      class TargetInspector
+        PLATFORM_INFO_URL = 'https://guides.cocoapods.org/syntax/podfile.html#platform'.freeze
+
+        # @return [TargetDefinition] the target definition to inspect
+        #
+        attr_reader :target_definition
+
+        # @return [Pathname] the root of the CocoaPods installation where the
+        #         Podfile is located
+        #
+        attr_reader :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
+        #
+        # @raise If no `user_project` is set
+        #
+        # @return [TargetInspectionResult] the result of the inspection of the target definition within the user project
+        #
+        def compute_results(user_project)
+          raise ArgumentError, 'Cannot compute results without a user project set' unless user_project
+
+          targets = compute_targets(user_project)
+          project_target_uuids = targets.map(&:uuid)
+          build_configurations = compute_build_configurations(targets)
+          platform = compute_platform(targets)
+          archs = compute_archs(targets)
+          swift_version = compute_swift_version_from_targets(targets)
+
+          result = TargetInspectionResult.new(target_definition, user_project, project_target_uuids,
+                                              build_configurations, platform, archs)
+          result.target_definition.swift_version = swift_version
+          result
+        end
+
+        # 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" \
+                "    project 'path/to/Project.xcodeproj'\n"
+            end
+          end
+          path
+        end
+
+        #-----------------------------------------------------------------------#
+
+        private
+
+        # 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
+          target = native_targets.find { |t| t.name == target_definition.name.to_s }
+          unless target
+            found = native_targets.map { |t| "`#{t.name}`" }.to_sentence
+            raise Informative, "Unable to find a target named `#{target_definition.name}`, did find #{found}."
+          end
+          [target]
+        end
+
+        # @param  [Array<PBXNativeTarget] user_targets 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] user_targets 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
+
+          unless name
+            raise Informative,
+                  "Unable to determine the platform for the `#{target_definition.name}` target."
+          end
+
+          UI.warn "Automatically assigning platform `#{name}` with version `#{deployment_target}` " \
+            "on target `#{target_definition.name}` because no platform was specified. " \
+            "Please specify a platform for this target in your Podfile. See `#{PLATFORM_INFO_URL}`."
+
+          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] user_targets 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
+
+        # Compute the Swift version for the target build configurations. If more
+        # than one Swift version is defined for a given target, then it will raise.
+        #
+        # @param  [Array<PBXNativeTarget>] targets
+        #         the targets that are checked for Swift versions.
+        #
+        # @return [String] the targets Swift version or nil
+        #
+        def compute_swift_version_from_targets(targets)
+          versions_to_targets = targets.inject({}) do |memo, target|
+            # User project may have an xcconfig that specifies the `SWIFT_VERSION`. We first check if that is true and
+            # that the xcconfig file actually exists. After the first integration the xcconfig set is most probably
+            # the one that was generated from CocoaPods. See https://github.com/CocoaPods/CocoaPods/issues/7731 for
+            # more details.
+            resolve_against_xcconfig = target.build_configuration_list.build_configurations.all? do |bc|
+              !bc.base_configuration_reference.nil? && File.exist?(bc.base_configuration_reference.real_path)
+            end
+            versions = target.resolved_build_setting('SWIFT_VERSION', resolve_against_xcconfig).values
+            versions.each do |version|
+              memo[version] = [] if memo[version].nil?
+              memo[version] << target.name unless memo[version].include? target.name
+            end
+            memo
+          end
+
+          case versions_to_targets.count
+          when 0
+            nil
+          when 1
+            versions_to_targets.keys.first
+          else
+            target_version_pairs = versions_to_targets.map do |version_names, target_names|
+              target_names.map { |target_name| [target_name, version_names] }
+            end
+
+            sorted_pairs = target_version_pairs.flat_map { |i| i }.sort_by do |target_name, version_name|
+              "#{target_name} #{version_name}"
+            end
+
+            formatted_output = sorted_pairs.map do |target, version_name|
+              "#{target}: Swift #{version_name}"
+            end.join("\n")
+
+            raise Informative, "There may only be up to 1 unique SWIFT_VERSION per target. Found target(s) with multiple Swift versions:\n#{formatted_output}"
+          end
+        end
+      end
+    end
+  end
+end