cocoapods-dykit 0.5.2 → 0.5.3

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

@@ -0,0 +1,57 @@
+module Pod
+  class DyInstaller
+    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 [Hash{Source => Array<Specification>}] the
+        #         specifications grouped by spec repo source.
+        #
+        attr_accessor :specs_by_source
+
+        # @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<AggregateTarget>] The aggregate targets created for each
+        #         {TargetDefinition} from the {Podfile}.
+        #
+        attr_accessor :targets
+
+        # @return [Hash{TargetDefinition => Array<TargetInspectionResult>}] the
+        #         results of inspecting the user targets
+        #
+        attr_accessor :target_inspections
+
+        # @return [PodfileDependencyCache] the cache of all dependencies in the
+        #         podfile.
+        #
+        attr_accessor :podfile_dependency_cache
+
+        # @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/pod/installer/analyzer/locking_dependency_analyzer.rb

@@ -0,0 +1,95 @@
+require 'molinillo/dependency_graph'
+
+module Pod
+  class DyInstaller
+    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
+            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)
+            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)
+          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)
+          case object
+          when String
+            add_child_vertex_to_graph(object, parents, dependency_graph, pods_to_unlock)
+          when Hash
+            object.each do |key, value|
+              dependency = add_child_vertex_to_graph(key, parents, dependency_graph, pods_to_unlock)
+              value.each { |v| add_to_dependency_graph(v, [dependency.name], dependency_graph, pods_to_unlock) }
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+module Pod
+  class DyInstaller
+    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
+        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 &&
+            specs == other.specs &&
+            platform == other.platform &&
+            requires_frameworks == other.requires_frameworks
+        end
+        alias_method :eql?, :==
+
+        # Hashes the instance by all its attributes.
+        #
+        # This adds support to make instances usable as Hash keys.
+        #
+        # @!visibility private
+        def hash
+          [specs, platform, requires_frameworks].hash
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,157 @@
+require 'set'
+
+module Pod
+  class DyInstaller
+    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/pod/installer/analyzer/podfile_dependency_cache.rb

@@ -0,0 +1,54 @@
+module Pod
+  class DyInstaller
+    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

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

@@ -0,0 +1,251 @@
+module Pod
+  class DyInstaller
+    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
+
+        # @return [Lockfile] The lockfile of the installation as a fall-back if
+        #         there is no sandbox manifest. This is indented as a temporary
+        #         solution to prevent the full re-installation from users which
+        #         are upgrading from CP < 0.17.
+        #
+        # @todo   Remove for CP 0.18.
+        #
+        attr_reader :lockfile
+
+        # Init a new SandboxAnalyzer
+        #
+        # @param [Sandbox] sandbox @see sandbox
+        # @param [Array<Specifications>] specs @see specs
+        # @param [Bool] update_mode @see update_mode
+        # @param [Lockfile] lockfile @see lockfile
+        #
+        def initialize(sandbox, specs, update_mode, lockfile = nil)
+          @sandbox = sandbox
+          @specs = specs
+          @update_mode = update_mode
+          @lockfile = lockfile
+        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 unless folder_exist?(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 || lockfile
+        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