xcocoapods 1.5.3

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

@@ -0,0 +1,87 @@
+module Pod
+  class Installer
+    class Analyzer
+      # A simple container produced after a analysis is completed by the {Analyzer}.
+      #
+      class AnalysisResult
+        # @return [SpecsState] the states of the Podfile specs.
+        #
+        attr_reader :podfile_state
+
+        # @return [Hash{TargetDefinition => Array<Specification>}] the specifications grouped by target.
+        #
+        attr_reader :specs_by_target
+
+        # @return [Hash{Source => Array<Specification>}] the specifications grouped by spec repo source.
+        #
+        attr_reader :specs_by_source
+
+        # @return [Array<Specification>] the specifications of the resolved version of Pods that should be installed.
+        #
+        attr_reader :specifications
+
+        # @return [SpecsState] the states of the {Sandbox} respect the resolved specifications.
+        #
+        attr_accessor :sandbox_state
+
+        # @return [Array<AggregateTarget>] The aggregate targets created for each {TargetDefinition} from the {Podfile}.
+        #
+        attr_reader :targets
+
+        # @return [Array<PodTarget>] The pod targets created for all the aggregate targets.
+        #
+        attr_reader :pod_targets
+
+        # @return [PodfileDependencyCache] the cache of all dependencies in the podfile.
+        #
+        attr_reader :podfile_dependency_cache
+
+        def initialize(podfile_state, specs_by_target, specs_by_source, specifications, sandbox_state, targets, pod_targets,
+                       podfile_dependency_cache)
+          @podfile_state = podfile_state
+          @specs_by_target = specs_by_target
+          @specs_by_source = specs_by_source
+          @specifications = specifications
+          @sandbox_state = sandbox_state
+          @targets = targets
+          @pod_targets = pod_targets
+          @podfile_dependency_cache = podfile_dependency_cache
+        end
+
+        # @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
+
+        # @return [Bool] Whether an installation should be performed or this
+        #         CocoaPods project is already up to date.
+        #
+        def needs_install?
+          podfile_needs_install? || sandbox_needs_install?
+        end
+
+        # @return [Bool] Whether the podfile has changes respect to the lockfile.
+        #
+        def podfile_needs_install?
+          state = podfile_state
+          needing_install = state.added.length + state.changed.length + state.deleted.length
+          needing_install > 0
+        end
+
+        # @return [Bool] Whether the sandbox is in synch with the lockfile.
+        #
+        def sandbox_needs_install?
+          state = sandbox_state
+          needing_install = state.added.length + state.changed.length + state.deleted.length
+          needing_install > 0
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+require 'molinillo/dependency_graph'
+
+module Pod
+  class Installer
+    class Analyzer
+      # Generates dependencies that require the specific version of the Pods
+      # that haven't changed in the {Lockfile}.
+      module LockingDependencyAnalyzer
+        # Generates dependencies that require the specific version of the Pods
+        # that haven't changed in the {Lockfile}.
+        #
+        # These dependencies are passed to the {Resolver}, unless the installer
+        # is in update mode, to prevent it from upgrading the Pods that weren't
+        # changed in the {Podfile}.
+        #
+        # @param [Lockfile] lockfile the lockfile containing dependency constraints
+        #
+        # @param [Array<String>] pods_to_update
+        #        List of pod names which needs to be updated because installer is
+        #        in update mode for these pods. Pods in this list and all their recursive dependencies
+        #        will not be included in generated dependency graph
+        #
+        # @param [Array<String>] pods_to_unlock
+        #        List of pod names whose version constraints will be removed from  the generated dependency graph.
+        #        Recursive dependencies of the pods won't be affected. This is currently used to force local pods
+        #        to be evaluated again whenever checksum of the specification of the local pods changes.
+        #
+        # @return [Molinillo::DependencyGraph<Dependency>] the dependencies
+        #         generated by the lockfile that prevent the resolver to update
+        #         a Pod.
+        #
+        def self.generate_version_locking_dependencies(lockfile, pods_to_update, pods_to_unlock = [])
+          dependency_graph = Molinillo::DependencyGraph.new
+
+          if lockfile
+            added_dependency_strings = Set.new
+
+            explicit_dependencies = lockfile.dependencies
+            explicit_dependencies.each do |dependency|
+              dependency_graph.add_vertex(dependency.name, dependency, true)
+            end
+
+            pods = lockfile.to_hash['PODS'] || []
+            pods.each do |pod|
+              add_to_dependency_graph(pod, [], dependency_graph, pods_to_unlock, added_dependency_strings)
+            end
+
+            pods_to_update = pods_to_update.flat_map do |u|
+              root_name = Specification.root_name(u).downcase
+              dependency_graph.vertices.each_key.select { |n| Specification.root_name(n).downcase == root_name }
+            end
+
+            pods_to_update.each do |u|
+              dependency_graph.detach_vertex_named(u)
+            end
+          end
+
+          dependency_graph
+        end
+
+        # Generates a completely 'unlocked' dependency graph.
+        #
+        # @return [Molinillo::DependencyGraph<Dependency>] an empty dependency
+        #         graph
+        #
+        def self.unlocked_dependency_graph
+          Molinillo::DependencyGraph.new
+        end
+
+        private
+
+        def self.add_child_vertex_to_graph(dependency_string, parents, dependency_graph, pods_to_unlock, added_dependency_strings)
+          return unless added_dependency_strings.add?(dependency_string)
+          dependency = Dependency.from_string(dependency_string)
+          if pods_to_unlock.include?(dependency.root_name)
+            dependency = Dependency.new(dependency.name)
+          end
+          vertex = dependency_graph.add_child_vertex(dependency.name, nil, parents, nil)
+          dependency = vertex.payload.merge(dependency) if vertex.payload
+          vertex.payload = dependency
+          dependency
+        end
+
+        def self.add_to_dependency_graph(object, parents, dependency_graph, pods_to_unlock, added_dependency_strings)
+          case object
+          when String
+            add_child_vertex_to_graph(object, parents, dependency_graph, pods_to_unlock, added_dependency_strings)
+          when Hash
+            object.each do |key, value|
+              dependency = add_child_vertex_to_graph(key, parents, dependency_graph, pods_to_unlock, added_dependency_strings)
+              value.each { |v| add_to_dependency_graph(v, [dependency.name], dependency_graph, pods_to_unlock, added_dependency_strings) }
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+module Pod
+  class Installer
+    class Analyzer
+      # Bundles the information needed to setup a {PodTarget}.
+      class PodVariant
+        # @return [Array<Specification>] the spec and subspecs for the target
+        #
+        attr_reader :specs
+
+        # @return [Array<Specification>] the test specs for the target
+        #
+        attr_reader :test_specs
+
+        # @return [Platform] the platform
+        #
+        attr_reader :platform
+
+        # @return [Bool] whether this pod should be built as framework
+        #
+        attr_reader :requires_frameworks
+        alias_method :requires_frameworks?, :requires_frameworks
+
+        # @return [Specification] the root specification
+        #
+        def root_spec
+          specs.first.root
+        end
+
+        # Initialize a new instance from its attributes.
+        #
+        # @param [Array<Specification>] specs      @see #specs
+        # @param [Array<Specification>] test_specs @see #test_specs
+        # @param [Platform] platform               @see #platform
+        # @param [Bool] requires_frameworks        @see #requires_frameworks?
+        #
+        def initialize(specs, test_specs, platform, requires_frameworks = false)
+          @specs = specs
+          @test_specs = test_specs
+          @platform = platform
+          @requires_frameworks = requires_frameworks
+          @hash = [specs, platform, requires_frameworks].hash
+        end
+
+        # @note Test specs are intentionally not included as part of the equality for pod variants since a
+        #       pod variant should not be affected by the number of test specs included.
+        #
+        # @return [Bool] whether the {PodVariant} is equal to another taking all
+        #         all their attributes into account
+        #
+        def ==(other)
+          self.class == other.class &&
+            requires_frameworks == other.requires_frameworks &&
+            platform == other.platform &&
+            specs == other.specs
+        end
+        alias_method :eql?, :==
+
+        # Hashes the instance by all its attributes.
+        #
+        # This adds support to make instances usable as Hash keys.
+        #
+        # @!visibility private
+        attr_reader :hash
+      end
+    end
+  end
+end

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

@@ -0,0 +1,157 @@
+require 'set'
+
+module Pod
+  class Installer
+    class Analyzer
+      # Collects all {PodVariant}.
+      class PodVariantSet
+        # @return [Array<PodVariant>] the different variants within this set.
+        #
+        attr_reader :variants
+
+        # Initialize a new instance.
+        #
+        # @param [Array<PodVariant>] variants  @see #variants
+        #
+        def initialize(variants)
+          @variants = variants
+        end
+
+        # Describes what makes each {PodVariant} distinct among the others.
+        #
+        # @return [Hash<PodVariant, String>]
+        #
+        def scope_suffixes
+          return { variants.first => nil } if variants.count == 1
+          Hash[scope_by_specs.map do |variant, scope|
+            require 'digest'
+            scope = Digest::MD5.hexdigest(scope)[0..7] if !scope.nil? && scope.length >= 50
+            [variant, scope]
+          end]
+        end
+
+        # Groups the collection by result of the block.
+        #
+        # @param [Block<Variant, #hash>] block
+        # @return [Array<PodVariantSet>]
+        #
+        def group_by(&block)
+          variants.group_by(&block).map { |_, v| PodVariantSet.new(v) }
+        end
+
+        # @private
+        #
+        # Prepends the given scoped {PodVariant}s with another scoping label, if there
+        # was more than one group of {PodVariant}s given.
+        #
+        # @param [Array<Hash<PodVariant, String>>] scoped_variants
+        #        {PodVariant}s, which where grouped on base of a criteria, which is used
+        #        in the block argument to generate a descriptive label.
+        #
+        # @param [Block<PodVariant, String>] block
+        #        takes a {PodVariant} and returns a scope suffix which is prepended, if
+        #        necessary.
+        #
+        # @return [Hash<PodVariant, String>]
+        #
+        def scope_if_necessary(scoped_variants, &block)
+          if scoped_variants.count == 1
+            return scoped_variants.first
+          end
+          Hash[scoped_variants.flat_map do |variants|
+            variants.map do |variant, suffix|
+              prefix = block.call(variant)
+              scope = [prefix, suffix].compact.join('-')
+              [variant, !scope.empty? ? scope : nil]
+            end
+          end]
+        end
+
+        # @private
+        # @return [Hash<PodVariant, String>]
+        #
+        def scope_by_build_type
+          scope_if_necessary(group_by(&:requires_frameworks).map(&:scope_by_platform)) do |variant|
+            variant.requires_frameworks? ? 'framework' : 'library'
+          end
+        end
+
+        # @private
+        # @return [Hash<PodVariant, String>]
+        #
+        def scope_by_platform
+          grouped_variants = group_by { |v| v.platform.name }
+          if grouped_variants.all? { |set| set.variants.count == 1 }
+            # => Platform name
+            platform_name_proc = proc { |v| Platform.string_name(v.platform.symbolic_name).tr(' ', '') }
+          else
+            grouped_variants = group_by(&:platform)
+            # => Platform name + SDK version
+            platform_name_proc = proc { |v| v.platform.to_s.tr(' ', '') }
+          end
+          scope_if_necessary(grouped_variants.map(&:scope_without_suffix), &platform_name_proc)
+        end
+
+        # @private
+        # @return [Hash<PodVariant, String>]
+        #
+        def scope_by_specs
+          root_spec = variants.first.root_spec
+          specs = [root_spec]
+          specs += if root_spec.default_subspecs.empty?
+                     root_spec.subspecs.compact
+                   else
+                     root_spec.default_subspecs.map do |subspec_name|
+                       root_spec.subspec_by_name("#{root_spec.name}/#{subspec_name}")
+                     end
+          end
+          default_specs = Set.new(specs)
+          grouped_variants = group_by(&:specs)
+          all_spec_variants = grouped_variants.map { |set| set.variants.first.specs }
+          common_specs = all_spec_variants.map(&:to_set).flatten.inject(&:&)
+          omit_common_specs = common_specs.any? && common_specs.proper_superset?(default_specs)
+          scope_if_necessary(grouped_variants.map(&:scope_by_build_type)) do |variant|
+            specs = variant.specs.to_set
+
+            # The current variant contains all default specs
+            omit_default_specs = default_specs.any? && default_specs.subset?(specs)
+            if omit_default_specs
+              specs -= default_specs
+            end
+
+            # There are common specs, which are different from the default specs
+            if omit_common_specs
+              specs -= common_specs
+            end
+
+            spec_names = specs.map do |spec|
+              spec.root? ? '.root' : spec.name.split('/')[1..-1].join('_')
+            end.sort
+            if spec_names.empty?
+              omit_common_specs ? '.common' : nil
+            else
+              if omit_common_specs
+                spec_names.unshift('.common')
+              elsif omit_default_specs
+                spec_names.unshift('.default')
+              end
+              spec_names.reduce('') do |acc, name|
+                "#{acc}#{acc.empty? || name[0] == '.' ? '' : '-'}#{name}"
+              end
+            end
+          end
+        end
+
+        # @private
+        #
+        # Helps to define scope suffixes recursively.
+        #
+        # @return [Hash<PodVariant, String>]
+        #
+        def scope_without_suffix
+          Hash[variants.map { |v| [v, nil] }]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+module Pod
+  class Installer
+    class Analyzer
+      # Caches podfile & target definition dependencies, so they do not need to be re-computed
+      # from the internal hash on each access
+      #
+      class PodfileDependencyCache
+        # @return [Array<Pod::Dependency>]
+        #         All the dependencies in the podfile
+        #
+        attr_reader :podfile_dependencies
+
+        def initialize(podfile_dependencies, dependencies_by_target_definition)
+          @podfile_dependencies = podfile_dependencies
+          @dependencies_by_target_definition = dependencies_by_target_definition
+        end
+
+        # Returns the dependencies for the given target definition
+        #
+        def target_definition_dependencies(target_definition)
+          @dependencies_by_target_definition[target_definition] ||
+            raise(ArgumentError, "dependencies for #{target_definition.inspect} do not exist in the cache")
+        end
+
+        # Returns a list of all of the target definitions in the Podfile
+        #
+        def target_definition_list
+          @dependencies_by_target_definition.keys
+        end
+
+        # Creates a {PodfileDependencyCache} from the given {Podfile}
+        #
+        # @param [Podfile] podfile
+        #        The {Podfile} from which dependencies should be cached
+        #
+        # @return [PodfileDependencyCache]
+        #         A warmed, immutable cache of all the dependencies in the {Podfile}
+        #
+        def self.from_podfile(podfile)
+          podfile_dependencies = []
+          dependencies_by_target_definition = {}
+          podfile.target_definition_list.each do |target_definition|
+            deps = target_definition.dependencies.freeze
+            podfile_dependencies.concat deps
+            dependencies_by_target_definition[target_definition] = deps
+          end
+          podfile_dependencies.uniq!
+
+          new(podfile_dependencies.freeze, dependencies_by_target_definition.freeze)
+        end
+      end
+    end
+  end
+end