cocoapods-tt 0.0.1

data/lib/cocoapods-tt/native/installer/analyzer/locking_dependency_analyzer.rb

@@ -0,0 +1,103 @@
+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
+
+            dependency_graph.each do |vertex|
+              next unless dep = vertex.payload
+              dep.podspec_repo ||= lockfile.spec_repo(dep.root_name)
+            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-tt/native/installer/analyzer/pod_variant.rb

@@ -0,0 +1,87 @@
+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 [Array<Specification>] the app specs for the target
+        #
+        attr_reader :app_specs
+
+        # @return [Platform] the platform
+        #
+        attr_reader :platform
+
+        # @return [BuildType] the build type of the target
+        #
+        attr_reader :build_type
+
+        # @return [String] the Swift version of the target.
+        #
+        attr_reader :swift_version
+
+        # Initialize a new instance from its attributes.
+        #
+        # @param [Array<Specification>] specs      @see #specs
+        # @param [Array<Specification>] test_specs @see #test_specs
+        # @param [Array<Specification>] app_specs  @see #app_specs
+        # @param [Platform] platform               @see #platform
+        # @param [BuildType] build_type            @see #build_type
+        # @param [String] swift_version            @see #swift_version
+        #
+        def initialize(specs, test_specs, app_specs, platform, build_type = BuildType.static_library,
+                       swift_version = nil)
+          @specs = specs
+          @test_specs = test_specs
+          @app_specs = app_specs
+          @platform = platform
+          @build_type = build_type
+          @swift_version = swift_version
+          @hash = [specs, platform, build_type, swift_version].hash
+        end
+
+        # @return [Specification] the root specification
+        #
+        def root_spec
+          specs.first.root
+        end
+
+        # @note Non library 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 nor app specs included.
+        #
+        # @return [Bool] whether the {PodVariant} is equal to another taking all all their attributes into account
+        #
+        def ==(other)
+          self.class == other.class &&
+          build_type == other.build_type &&
+            swift_version == other.swift_version &&
+            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
+
+        # @param [String] swift_version The swift version to use for this variant.
+        #
+        # @return [PodVariant] A copy of this pod variant with the specified Swift version.
+        #
+        def scoped_with_swift_version(swift_version)
+          PodVariant.new(specs, test_specs, app_specs, platform, build_type, swift_version)
+        end
+      end
+    end
+  end
+end

data/lib/cocoapods-tt/native/installer/analyzer/pod_variant_set.rb

@@ -0,0 +1,175 @@
+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 { |v| v.build_type.packaging }.map(&:scope_by_linkage)) do |variant|
+            variant.build_type.packaging
+          end
+        end
+
+        # @private
+        # @return [Hash<PodVariant, String>]
+        #
+        def scope_by_linkage
+          scope_if_necessary(group_by { |v| v.build_type.linkage }.map(&:scope_by_platform)) do |variant|
+            variant.build_type.linkage
+          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_by_swift_version), &platform_name_proc)
+        end
+
+        # @private
+        # @return [Hash<PodVariant, String>]
+        #
+        def scope_by_swift_version
+          scope_if_necessary(group_by(&:swift_version).map(&:scope_without_suffix)) do |variant|
+            variant.swift_version ? "Swift#{variant.swift_version}" : ''
+          end
+        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-tt/native/installer/analyzer/podfile_dependency_cache.rb

@@ -0,0 +1,55 @@
+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)
+          raise ArgumentError, 'Must be initialized with a podfile' unless 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/cocoapods-tt/native/installer/analyzer/sandbox_analyzer.rb

@@ -0,0 +1,268 @@
+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 [Podfile] The Podfile to analyze dependencies.
+        #
+        attr_reader :podfile
+
+        # @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 [Podfile] podfile @see podfile
+        # @param [Array<Specifications>] specs @see specs
+        # @param [Bool] update_mode @see update_mode
+        #
+        def initialize(sandbox, podfile, specs, update_mode)
+          @sandbox = sandbox
+          @podfile = podfile
+          @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 !sandbox.local?(pod) && !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)
+          podfile_dep = podfile_dependency(pod)&.tap { |dep| dep.podspec_repo = nil }
+          return true if podfile_dep != sandbox_dependency(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
+          @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_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
+
+        # @return [Dependency, nil] The dependency with the given name stored in the sandbox.
+        #
+        # @param  [String] pod
+        #         the name of the Pod.
+        #
+        def sandbox_dependency(pod)
+          sandbox_manifest.dependencies.find { |d| d.name == pod }
+        end
+
+        #--------------------------------------#
+
+        # @return [Dependency, nil] The dependency with the given name from the podfile.
+        #
+        # @param  [String] pod
+        #         the name of the Pod.
+        #
+        def podfile_dependency(pod)
+          podfile.dependencies.find { |d| d.name == 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