cocoapods 0.13.0 → 0.14.0.rc1

data/lib/cocoapods/lockfile.rb

@@ -0,0 +1,267 @@
+module Pod
+  class Lockfile
+
+    # @return [Lockfile] Returns the Lockfile saved in path.
+    #   Returns {nil} If the file can't be loaded.
+    #
+    def self.from_file(path)
+      return nil unless path.exist?
+      hash = YAML.load(File.open(path))
+      lockfile = Lockfile.new(hash)
+      lockfile.defined_in_file = path
+      lockfile
+    end
+
+    # @return [Lockfile] Generates a lockfile from a {Podfile} and the
+    #   list of {Specifications} that were installed.
+    #
+    def self.generate(podfile, specs)
+      Lockfile.new(generate_hash_from_podfile(podfile, specs))
+    end
+
+    # @return [String] The file where this Lockfile is defined.
+    #
+    attr_accessor :defined_in_file
+
+    # @return [String] The hash used to initialize the Lockfile.
+    #
+    attr_reader :to_hash
+
+    # @param [Hash] hash A Hash representation of a Lockfile.
+    #
+    def initialize(hash)
+      @to_hash = hash
+    end
+
+    # @return [Array<String, Hash{String => Array[String]}>] The pods installed
+    #   and their dependencies.
+    #
+    def pods
+      @pods ||= to_hash['PODS'] || []
+    end
+
+    # @return [Array<Dependency>] The Podfile dependencies used during the last
+    #   install.
+    #
+    def dependencies
+      @dependencies ||= to_hash['DEPENDENCIES'].map { |dep| dependency_from_string(dep) } || []
+    end
+
+    # @return [Hash{String => Hash}] A hash where the name of the pods are
+    #   the keys and the values are the parameters of an {AbstractExternalSource}
+    #   of the dependency that required the pod.
+    #
+    def external_sources
+      @external_sources ||= to_hash["EXTERNAL SOURCES"] || {}
+    end
+
+    # @return [Array<String>] The names of the installed Pods.
+    #
+    def pods_names
+      @pods_names ||= pods.map do |pod|
+        pod = pod.keys.first unless pod.is_a?(String)
+        name_and_version_for_pod(pod)[0]
+      end
+    end
+
+    # @return [Hash{String => Version}] A Hash containing the name
+    #   of the installed Pods as the keys and their corresponding {Version}
+    #   as the values.
+    #
+    def pods_versions
+      unless @pods_versions
+        @pods_versions = {}
+        pods.each do |pod|
+          pod = pod.keys.first unless pod.is_a?(String)
+          name, version = name_and_version_for_pod(pod)
+          @pods_versions[name] = version
+        end
+      end
+      @pods_versions
+    end
+
+    # @return [Dependency] A dependency that describes the exact installed version
+    #   of a Pod.
+    #
+    def dependency_for_installed_pod_named(name)
+      version = pods_versions[name]
+      raise Informative, "Attempt to lock a Pod without an known version." unless version
+      dependency = Dependency.new(name, version)
+      if external_source = external_sources[name]
+        dependency.external_source = Dependency::ExternalSources.from_params(dependency.name, external_source)
+      end
+      dependency
+    end
+
+    # @param [String] The string that describes a {Specification} generated
+    #   from {Specification#to_s}.
+    #
+    #   @example Strings examples
+    #       "libPusher"
+    #       "libPusher (1.0)"
+    #       "libPusher (HEAD based on 1.0)"
+    #       "RestKit/JSON"
+    #
+    # @return [String, Version] The name and the version of a
+    # pod.
+    #
+    def name_and_version_for_pod(string)
+      match_data = string.match(/(\S*) \((.*)\)/)
+      name = match_data[1]
+      vers = Version.from_string(match_data[2])
+      [name, vers]
+    end
+
+    # @param [String] The string that describes a {Dependency} generated
+    #   from {Dependency#to_s}.
+    #
+    #   @example Strings examples
+    #       "libPusher"
+    #       "libPusher (= 1.0)"
+    #       "libPusher (~> 1.0.1)"
+    #       "libPusher (> 1.0, < 2.0)"
+    #       "libPusher (HEAD)"
+    #       "libPusher (from `www.example.com')"
+    #       "libPusher (defined in Podfile)"
+    #       "RestKit/JSON"
+    #
+    # @return [Dependency] The dependency described by the string.
+    #
+    def dependency_from_string(string)
+      match_data = string.match(/(\S*)( (.*))?/)
+      name = match_data[1]
+      version = match_data[2]
+      version = version.gsub(/[()]/,'') if version
+      case version
+      when nil
+        Dependency.new(name)
+      when /defined in Podfile/
+        # @TODO: store the whole spec?, the version?
+        Dependency.new(name)
+      when /from `(.*)'/
+        external_source_info = external_sources[name]
+        Dependency.new(name, external_source_info)
+      when /HEAD/
+        # @TODO: find a way to serialize from the Downloader the information
+        #   necessary to restore a head version.
+        Dependency.new(name, :head)
+      else
+        Dependency.new(name, version)
+      end
+    end
+
+    # Analyzes the {Lockfile} and detects any changes applied to the {Podfile}
+    # since the last installation.
+    #
+    # For each Pod, it detects one state among the following:
+    #
+    # - added: Pods that weren't present in the Podfile.
+    # - changed: Pods that were present in the Podfile but changed:
+    #   - Pods whose version is not compatible anymore with Podfile,
+    #   - Pods that changed their head or external options.
+    # - removed: Pods that were removed form the Podfile.
+    # - unchanged: Pods that are still compatible with Podfile.
+    #
+    # @TODO: detect changes for inline dependencies?
+    #
+    # @return [Hash{Symbol=>Array[Strings]}] A hash where pods are grouped
+    # by the state in which they are.
+    #
+    def detect_changes_with_podfile(podfile)
+      previous_podfile_deps = dependencies.map(&:name)
+      user_installed_pods   = pods_names.reject { |name| !previous_podfile_deps.include?(name) }
+      deps_to_install       = podfile.dependencies.dup
+
+      result = {}
+      result[:added]      = []
+      result[:changed]    = []
+      result[:removed]    = []
+      result[:unchanged]  = []
+
+      user_installed_pods.each do |pod_name|
+        dependency = deps_to_install.find { |d| d.name == pod_name }
+        deps_to_install.delete(dependency)
+        version = pods_versions[pod_name]
+        external_source = Dependency::ExternalSources.from_params(pod_name, external_sources[pod_name])
+
+        if dependency.nil?
+          result[:removed] << pod_name
+        elsif !dependency.match_version?(version) || dependency.external_source != external_source
+          result[:changed] << pod_name
+        else
+          result[:unchanged] << pod_name
+        end
+      end
+
+      deps_to_install.each do |dependency|
+        result[:added] << dependency.name
+      end
+      result
+    end
+
+    # @return [void] Writes the Lockfile to {#path}.
+    #
+    def write_to_disk(path)
+      File.open(path, 'w') {|f| f.write(to_yaml) }
+      defined_in_file = path
+    end
+
+    # @return [String] A string useful to represent the Lockfile in a message
+    #   presented to the user.
+    #
+    def to_s
+      "Podfile.lock"
+    end
+
+    # @return [String] The YAML representation of the Lockfile, used for
+    #   serialization.
+    #
+    def to_yaml
+      to_hash.to_yaml.gsub(/^--- ?\n/,"").gsub(/^([A-Z])/,"\n\\1")
+    end
+
+    # @return [Hash] The Hash representation of the Lockfile generated from
+    #   a given Podfile and the list of resolved Specifications.
+    #
+    def self.generate_hash_from_podfile(podfile, specs)
+      hash = {}
+
+      # Get list of [name, dependencies] pairs.
+      pod_and_deps = specs.map do |spec|
+        [spec.to_s, spec.dependencies.map(&:to_s).sort]
+      end.uniq
+
+      # Merge dependencies of iOS and OS X version of the same pod.
+      tmp = {}
+      pod_and_deps.each do |name, deps|
+        if tmp[name]
+          tmp[name].concat(deps).uniq!
+        else
+          tmp[name] = deps
+        end
+      end
+      pod_and_deps = tmp.sort_by(&:first).map do |name, deps|
+        deps.empty? ? name : { name => deps }
+      end
+      hash["PODS"] = pod_and_deps
+
+      hash["DEPENDENCIES"] = podfile.dependencies.map{ |d| d.to_s }.sort
+
+      external_sources = {}
+      deps = podfile.dependencies.select(&:external?).sort{ |d, other| d.name <=> other.name}
+      deps.each{ |d| external_sources[d.name] = d.external_source.params }
+      hash["EXTERNAL SOURCES"] = external_sources unless external_sources.empty?
+
+      checksums = {}
+      specs.select { |spec| !spec.defined_in_file.nil? }.each do |spec|
+        checksum = Digest::SHA1.hexdigest(File.read(spec.defined_in_file))
+        checksum = checksum.encode('UTF-8') if checksum.respond_to?(:encode)
+        checksums[spec.name] = checksum
+      end
+      hash["SPEC CHECKSUMS"] = checksums unless checksums.empty?
+      hash["COCOAPODS"] = VERSION
+      hash
+    end
+  end
+end
+

data/lib/cocoapods/podfile.rb

@@ -538,5 +538,9 @@ module Pod
 
     def validate!
     end
+
+    def to_s
+      "Podfile"
+    end
   end
 end

data/lib/cocoapods/project.rb

@@ -31,15 +31,20 @@ module Pod
 
     # Shortcut access to the `Pods' PBXGroup.
     def pods
-      groups.find { |g| g.name == 'Pods' } || groups.new({ 'name' => 'Pods' })
+      @pods ||= groups.where(:name => 'Pods') || groups.new('name' => 'Pods')
+    end
+
+    # Shortcut access to the `Local Pods' PBXGroup.
+    def local_pods
+      @local_pods ||= groups.where(:name => 'Local Pods') || groups.new('name' => 'Local Pods')
     end
 
     # Adds a group as child to the `Pods' group namespacing subspecs.
-    def add_spec_group(name)
-      groups = pods.groups
+    def add_spec_group(name, parent_group)
+      groups = parent_group.groups
       group = nil
       name.split('/').each do |name|
-        group = groups.find { |g| g.name == name } || groups.new({ 'name' => name })
+        group = groups.where(:name => name) || groups.new('name' => name)
         groups = group.groups
       end
       group

data/lib/cocoapods/resolver.rb

@@ -4,44 +4,169 @@ module Pod
   class Resolver
     include Config::Mixin
 
-    attr_reader :podfile, :sandbox
-    attr_accessor :cached_sets, :cached_sources
+    # @return [Bool] Whether the resolver should find the pods to install or
+    #   the pods to update.
+    #
+    attr_accessor :update_mode
+
+    # @return [Bool] Whether the resolver should update the external specs
+    #   in the resolution process.
+    #
+    attr_accessor :update_external_specs
+
+    # @return [Podfile] The Podfile used by the resolver.
+    #
+    attr_reader :podfile
+
+    # @return [Lockfile] The Lockfile used by the resolver.
+    #
+    attr_reader :lockfile
+
+    # @return [Sandbox] The Sandbox used by the resolver to find external
+    #   dependencies.
+    #
+    attr_reader :sandbox
+
+    # @return [Array<Strings>] The name of the pods that have an
+    #   external source.
+    #
+    attr_reader :pods_from_external_sources
+
+    # @return [Array<Set>] A cache of the sets used to resolve the dependencies.
+    #
+    attr_reader :cached_sets
+
+    # @return [Source::Aggregate] A cache of the sources needed to find the
+    #   podspecs.
+    #
+    attr_reader :cached_sources
+
+    # @return [Hash{Podfile::TargetDefinition => Array<Specification>}]
+    #   Returns the resolved specifications grouped by target.
+    #
+    attr_reader :specs_by_target
+
+    def initialize(podfile, lockfile, sandbox)
+      @podfile  = podfile
+      @lockfile = lockfile
+      @sandbox  = sandbox
+      @update_external_specs = true
 
-    def initialize(podfile, sandbox)
-      @podfile = podfile
-      @sandbox = sandbox
       @cached_sets = {}
       @cached_sources = Source::Aggregate.new
-      @log_indent = 0;
     end
 
+    # Identifies the specifications that should be installed according whether
+    #   the resolver is in update mode or not.
+    #
+    # @return [Hash{Podfile::TargetDefinition => Array<Specification>}] specs_by_target
+    #
     def resolve
-      @specs = {}
-      targets_and_specs = {}
+      @cached_specs = {}
+      @specs_by_target = {}
+      @pods_from_external_sources = []
+      @pods_to_lock = []
+      @log_indent = 0
+
+      if @lockfile
+        puts "\nFinding added, modified or removed dependencies:".green if config.verbose?
+        @pods_by_state = @lockfile.detect_changes_with_podfile(podfile)
+        if config.verbose?
+          @pods_by_state.each do |symbol, pod_names|
+            case symbol
+            when :added
+              mark = "A".green
+            when :changed
+              mark = "M".yellow
+            when :removed
+              mark = "R".red
+            when :unchanged
+              mark = "-"
+            end
+            pod_names.each do |pod_name|
+              puts "  #{mark} " << pod_name
+            end
+          end
+        end
+        @pods_to_lock = (lockfile.pods_names - @pods_by_state[:added] - @pods_by_state[:changed] - @pods_by_state[:removed]).uniq
+      end
 
       @podfile.target_definitions.values.each do |target_definition|
-        puts "\nResolving dependencies for target `#{target_definition.name}' (#{target_definition.platform})".green if config.verbose?
+        puts "\nResolving dependencies for target `#{target_definition.name}' (#{target_definition.platform}):".green if config.verbose?
         @loaded_specs = []
         find_dependency_specs(@podfile, target_definition.dependencies, target_definition)
-        targets_and_specs[target_definition] = @specs.values_at(*@loaded_specs).sort_by(&:name)
+        @specs_by_target[target_definition] = @cached_specs.values_at(*@loaded_specs).sort_by(&:name)
+      end
+
+      @cached_specs.values.sort_by(&:name)
+      @specs_by_target
+    end
+
+    # @return [Array<Specification>] The specifications loaded by the resolver.
+    #
+    def specs
+      @cached_specs.values.uniq
+    end
+
+    # @return [Bool] Whether a pod should be installed/reinstalled.
+    #
+    def should_install?(name)
+      pods_to_install.include? name
+    end
+
+    # @return [Array<Strings>] The name of the pods that should be
+    #   installed/reinstalled.
+    #
+    def pods_to_install
+      unless @pods_to_install
+        if lockfile
+          @pods_to_install = specs.select do |spec|
+            spec.version != lockfile.pods_versions[spec.pod_name]
+          end.map(&:name)
+          if update_mode
+            @pods_to_install += specs.select do |spec|
+              spec.version.head? || pods_from_external_sources.include?(spec.pod_name)
+            end.map(&:name)
+          end
+          @pods_to_install += @pods_by_state[:added] + @pods_by_state[:changed]
+        else
+          @pods_to_install = specs.map(&:name)
+        end
       end
+      @pods_to_install
+    end
 
-      @specs.values.sort_by(&:name)
-      targets_and_specs
+    # @return [Array<Strings>] The name of the pods that were installed
+    #   but don't have any dependency anymore. The name of the Pods are
+    #   stripped from subspecs.
+    #
+    def removed_pods
+      return [] unless lockfile
+      unless @removed_pods
+        previusly_installed = lockfile.pods_names.map { |pod_name| pod_name.split('/').first }
+        installed = specs.map { |spec| spec.name.split('/').first }
+        @removed_pods = previusly_installed - installed
+      end
+      @removed_pods
     end
 
     private
 
+    # @return [Set] The cached set for a given dependency.
+    #
     def find_cached_set(dependency, platform)
       set_name = dependency.name.split('/').first
       @cached_sets[set_name] ||= begin
         if dependency.specification
           Specification::Set::External.new(dependency.specification)
         elsif external_source = dependency.external_source
-          # The platform isn't actually being used by the LocalPod instance
-          # that's being used behind the scenes, but passing it anyways for
-          # completeness sake.
-          specification = external_source.specification_from_sandbox(@sandbox, platform)
+          if update_mode && update_external_specs
+            # Always update external sources in update mode.
+            specification = external_source.specification_from_external(@sandbox, platform)
+          else
+            # Don't update external sources in install mode if not needed.
+            specification = external_source.specification_from_sandbox(@sandbox, platform)
+          end
           set = Specification::Set::External.new(specification)
           if dependency.subspec_dependency?
             @cached_sets[dependency.top_level_spec_name] ||= set
@@ -53,29 +178,48 @@ module Pod
       end
     end
 
+    # Resolves the dependencies of a specification and stores them in @cached_specs
+    #
+    # @param [Specification] dependent_specification
+    # @param [Array<Dependency>] dependencies
+    # @param [TargetDefinition] target_definition
+    #
+    # @return [void]
+    #
     def find_dependency_specs(dependent_specification, dependencies, target_definition)
       @log_indent += 1
       dependencies.each do |dependency|
+        # Replace the dependency with a more specific one if the pod is already installed.
+        if !update_mode && @pods_to_lock.include?(dependency.name)
+          dependency = lockfile.dependency_for_installed_pod_named(dependency.name)
+        end
+
         puts '  ' * @log_indent + "- #{dependency}" if config.verbose?
         set = find_cached_set(dependency, target_definition.platform)
-        set.required_by(dependent_specification)
+        set.required_by(dependency, dependent_specification.to_s)
+
         # Ensure we don't resolve the same spec twice for one target
         unless @loaded_specs.include?(dependency.name)
           spec = set.specification_by_name(dependency.name)
+          @pods_from_external_sources << spec.pod_name if dependency.external?
           @loaded_specs << spec.name
-          @specs[spec.name] = spec
+          @cached_specs[spec.name] = spec
           # Configure the specification
           spec.activate_platform(target_definition.platform)
           spec.version.head = dependency.head?
           # And recursively load the dependencies of the spec.
           find_dependency_specs(spec, spec.dependencies, target_definition) if spec.dependencies
         end
-        validate_platform!(spec || @specs[dependency.name], target_definition)
+        validate_platform(spec || @cached_specs[dependency.name], target_definition)
       end
       @log_indent -= 1
     end
 
-    def validate_platform!(spec, target)
+    # Ensures that a spec is compatible with platform of a target.
+    #
+    # @raises If the spec is not supported by the target.
+    #
+    def validate_platform(spec, target)
       unless spec.available_platforms.any? { |platform| target.platform.supports?(platform) }
         raise Informative, "[!] The platform of the target `#{target.name}' (#{target.platform}) is not compatible with `#{spec}' which has a minimun requirement of #{spec.available_platforms.join(' - ')}.".red
       end