cocoapods 0.34.4 → 0.35.0.rc1

data/lib/cocoapods/installer/target_installer/pod_target_installer.rb

@@ -9,7 +9,7 @@ module Pod
       # @return [void]
       #
       def install!
-        UI.message "- Installing target `#{library.name}` #{library.platform}" do
+        UI.message "- Installing target `#{target.name}` #{target.platform}" do
           add_target
           create_support_files_dir
           add_files_to_build_phases
@@ -33,15 +33,15 @@ module Pod
       # @return [void]
       #
       def add_files_to_build_phases
-        library.file_accessors.each do |file_accessor|
+        target.file_accessors.each do |file_accessor|
           consumer = file_accessor.spec_consumer
           flags = compiler_flags_for_consumer(consumer)
           all_source_files = file_accessor.source_files
           regular_source_files = all_source_files.reject { |sf| sf.extname == '.d' }
           regular_file_refs = regular_source_files.map { |sf| project.reference_for_path(sf) }
-          target.add_file_references(regular_file_refs, flags)
+          native_target.add_file_references(regular_file_refs, flags)
           other_file_refs = (all_source_files - regular_source_files).map { |sf| project.reference_for_path(sf) }
-          target.add_file_references(other_file_refs, nil)
+          native_target.add_file_references(other_file_refs, nil)
         end
       end
 
@@ -53,22 +53,22 @@ module Pod
       # @return [void]
       #
       def add_resources_bundle_targets
-        library.file_accessors.each do |file_accessor|
+        target.file_accessors.each do |file_accessor|
           file_accessor.resource_bundles.each do |bundle_name, paths|
             # Add a dependency on an existing Resource Bundle target if possible
             if bundle_target = project.targets.find { |target| target.name == bundle_name }
-              target.add_dependency(bundle_target)
+              native_target.add_dependency(bundle_target)
               next
             end
             file_references = paths.map { |sf| project.reference_for_path(sf) }
             bundle_target = project.new_resources_bundle(bundle_name, file_accessor.spec_consumer.platform_name)
             bundle_target.add_resources(file_references)
 
-            library.user_build_configurations.each do |bc_name, type|
+            target.user_build_configurations.each do |bc_name, type|
               bundle_target.add_build_configuration(bc_name, type)
             end
 
-            target.add_dependency(bundle_target)
+            native_target.add_dependency(bundle_target)
           end
         end
       end
@@ -78,17 +78,17 @@ module Pod
       # @return [void]
       #
       def create_xcconfig_file
-        path = library.xcconfig_path
-        public_gen = Generator::XCConfig::PublicPodXCConfig.new(library)
+        path = target.xcconfig_path
+        public_gen = Generator::XCConfig::PublicPodXCConfig.new(target)
         public_gen.save_as(path)
         add_file_to_support_group(path)
 
-        path = library.xcconfig_private_path
-        private_gen = Generator::XCConfig::PrivatePodXCConfig.new(library, public_gen.xcconfig)
+        path = target.xcconfig_private_path
+        private_gen = Generator::XCConfig::PrivatePodXCConfig.new(target, public_gen.xcconfig)
         private_gen.save_as(path)
         xcconfig_file_ref = add_file_to_support_group(path)
 
-        target.build_configurations.each do |c|
+        native_target.build_configurations.each do |c|
           c.base_configuration_reference = xcconfig_file_ref
         end
       end
@@ -100,13 +100,13 @@ module Pod
       # @return [void]
       #
       def create_prefix_header
-        path = library.prefix_header_path
-        generator = Generator::PrefixHeader.new(library.file_accessors, library.platform)
-        generator.imports << library.target_environment_header_path.basename
+        path = target.prefix_header_path
+        generator = Generator::PrefixHeader.new(target.file_accessors, target.platform)
+        generator.imports << target.target_environment_header_path.basename
         generator.save_as(path)
         add_file_to_support_group(path)
 
-        target.build_configurations.each do |c|
+        native_target.build_configurations.each do |c|
           relative_path = path.relative_path_from(project.path.dirname)
           c.build_settings['GCC_PREFIX_HEADER'] = relative_path.to_s
         end
@@ -176,8 +176,8 @@ module Pod
       # @return [PBXFileReference] the file reference of the added file.
       #
       def add_file_to_support_group(path)
-        pod_name = library.pod_name
-        dir = library.support_files_dir
+        pod_name = target.pod_name
+        dir = target.support_files_dir
         group = project.pod_support_files_group(pod_name, dir)
         group.new_file(path)
       end

data/lib/cocoapods/installer/user_project_integrator/target_integrator/xcconfig_integrator.rb

@@ -83,22 +83,26 @@ module Pod
           # @param  [Xcodeproj::XCBuildConfiguration] config
           #         The build configuration.
           #
+          # @return [Boolean] Indicates whether or not any changes were made.
+          #
           def self.set_target_xcconfig(pod_bundle, target, config)
             path = pod_bundle.xcconfig_relative_path(config.name)
             group = config.project['Pods'] || config.project.new_group('Pods')
             file_ref = group.files.find { |f| f.path == path }
-            if config.base_configuration_reference != file_ref
+            if config.base_configuration_reference &&
+                config.base_configuration_reference != file_ref
               UI.warn 'CocoaPods did not set the base configuration of your ' \
               'project because your project already has a custom ' \
               'config set. In order for CocoaPods integration to work at ' \
               'all, please either set the base configurations of the target ' \
               "`#{target.name}` to `#{path}` or include the `#{path}` in your " \
               'build configuration.'
-              false
-            elsif !file_ref
+            elsif config.base_configuration_reference.nil? || file_ref.nil?
               file_ref ||= group.new_file(path)
               config.base_configuration_reference = file_ref
+              return true
             end
+            false
           end
 
           private

data/lib/cocoapods/project.rb

@@ -209,7 +209,7 @@ module Pod
     #
     def add_build_configuration(name, type)
       build_configuration = super
-      values = ["#{name.gsub(/[^a-zA-Z0-9_]/, '_').upcase}=1"]
+      values = ["#{name.gsub(/[^a-zA-Z0-9_]/, '_').sub(/(^[0-9])/, '_\1').upcase}=1"]
       settings = build_configuration.build_settings
       definitions = Array(settings['GCC_PREPROCESSOR_DEFINITIONS'])
       values.each do |value|

data/lib/cocoapods/resolver.rb

@@ -1,18 +1,10 @@
+require 'molinillo'
+require 'cocoapods/resolver/lazy_specification'
+
 module Pod
   # The resolver is responsible of generating a list of specifications grouped
   # by target for a given Podfile.
   #
-  # @todo Its current implementation is naive, in the sense that it can't do full
-  #   automatic resolves like Bundler:
-  #   [how-does-bundler-bundle](http://patshaughnessy.net/2011/9/24/how-does-bundler-bundle)
-  #
-  # @todo Another limitation is that the order of the dependencies matter. The
-  #   current implementation could create issues, for example, if a
-  #   specification is loaded for a target definition and later for another
-  #   target is set in head mode. The first specification will not be in head
-  #   mode.
-  #
-  #
   class Resolver
     # @return [Sandbox] the Sandbox used by the resolver to find external
     #         dependencies.
@@ -58,23 +50,12 @@ module Pod
     #         definition.
     #
     def resolve
-      @cached_sets     = {}
-      @cached_specs    = {}
-      @specs_by_target = {}
-
-      target_definitions = podfile.target_definition_list
-      target_definitions.each do |target|
-        title = "Resolving dependencies for target `#{target.name}' " \
-          "(#{target.platform})"
-        UI.section(title) do
-          @loaded_specs = []
-          find_dependency_specs(podfile, target.dependencies, target)
-          specs = cached_specs.values_at(*@loaded_specs).sort_by(&:name)
-          specs_by_target[target] = specs
-        end
-      end
-
+      dependencies = @podfile.target_definition_list.map(&:dependencies).flatten
+      @cached_sets = {}
+      @activated = Molinillo::Resolver.new(self, self).resolve(dependencies, locked_dependencies)
       specs_by_target
+    rescue Molinillo::ResolverError => e
+      raise Informative, e.message
     end
 
     # @return [Hash{Podfile::TargetDefinition => Array<Specification>}]
@@ -82,113 +63,237 @@ module Pod
     #
     # @note   The returned specifications can be subspecs.
     #
-    attr_reader :specs_by_target
+    def specs_by_target
+      @specs_by_target ||= begin
+        specs_by_target = {}
+        podfile.target_definition_list.each do |target|
+          specs = target.dependencies.map(&:name).map do |name|
+            node = @activated.vertex_named(name)
+            valid_dependencies_for_target_from_node(target, node) << node
+          end
+
+          specs_by_target[target] = specs.
+            flatten.
+            map(&:payload).
+            uniq.
+            sort_by(&:name).
+            each do |spec|
+              validate_platform(spec, target)
+              sandbox.store_head_pod(spec.name) if spec.version.head
+            end
+        end
+        specs_by_target
+      end
+    end
 
     #-------------------------------------------------------------------------#
 
-    private
+    public
 
-    # !@ Resolution context
+    # @!group Specification Provider
 
-    # @return [Hash<String => Set>] A cache that keeps tracks of the sets
-    #         loaded by the resolution process.
+    include Molinillo::SpecificationProvider
+
+    # Returns (and caches) the specification that satisfy the given dependency.
     #
-    # @note   Sets store the resolved dependencies and return the highest
-    #         available specification found in the sources. This is done
-    #         globally and not per target definition because there can be just
-    #         one Pod installation, so different version of the same Pods for
-    #         target definitions are not allowed.
+    # @return [Array<Specification>] the specifications that satisfy the given
+    #   `dependency`.
     #
-    attr_accessor :cached_sets
+    # @param  [Dependency] dependency the dependency that is being searched for.
+    #
+    def search_for(dependency)
+      @search ||= {}
+      @search[dependency] ||= begin
+        specs = find_cached_set(dependency).
+          all_specifications.
+          select { |s| dependency.requirement.satisfied_by? s.version }.
+          map { |s| s.subspec_by_name(dependency.name, false) }.
+          compact
+
+        specs.
+          reverse.
+          each { |s| s.version.head = dependency.head? }
+      end
+      @search[dependency].dup
+    end
 
-    # @return [Hash<String => Specification>] The loaded specifications grouped
-    #         by name.
+    # Returns the dependencies of `specification`.
     #
-    attr_accessor :cached_specs
+    # @return [Array<Specification>] all dependencies of `specification`.
+    #
+    # @param  [Specification] specification the specification whose own
+    #         dependencies are being asked for.
+    #
+    def dependencies_for(specification)
+      specification.all_dependencies.map do |dependency|
+        if dependency.root_name == Specification.root_name(specification.name)
+          dependency.dup.tap { |d| d.specific_version = specification.version }
+        else
+          dependency
+        end
+      end
+    end
 
-    #-------------------------------------------------------------------------#
+    # Returns the name for the given `dependency`.
+    #
+    # @return [String] the name for the given `dependency`.
+    #
+    # @param  [Dependency] dependency the dependency whose name is being
+    #         queried.
+    #
+    def name_for(dependency)
+      dependency.name
+    end
 
-    private
+    # @return [String] the user-facing name for a {Podfile}.
+    #
+    def name_for_explicit_dependency_source
+      'Podfile'
+    end
 
-    # @!group Private helpers
+    # @return [String] the user-facing name for a {Lockfile}.
+    #
+    def name_for_locking_dependency_source
+      'Podfile.lock'
+    end
 
-    # Resolves recursively the dependencies of a specification and stores them
-    # in the @cached_specs ivar.
+    # Determines whether the given `requirement` is satisfied by the given
+    # `spec`, in the context of the current `activated` dependency graph.
+    #
+    # @return [Boolean] whether `requirement` is satisfied by `spec` in the
+    #         context of the current `activated` dependency graph.
     #
-    # @param  [Podfile, Specification, #to_s] dependent_spec
-    #         the specification whose dependencies are being resolved. Used
-    #         only for UI purposes.
+    # @param  [Dependency] requirement the dependency in question.
     #
-    # @param  [Array<Dependency>] dependencies
-    #         the dependencies of the specification.
+    # @param  [Molinillo::DependencyGraph] activated the current dependency
+    #         graph in the resolution process.
     #
-    # @param  [TargetDefinition] target_definition
-    #         the target definition that owns the specification.
+    # @param  [Specification] spec the specification in question.
+    #
+    def requirement_satisfied_by?(requirement, activated, spec)
+      existing_vertices = activated.vertices.values.select do |v|
+        Specification.root_name(v.name) ==  requirement.root_name
+      end
+      existing = existing_vertices.map(&:payload).compact.first
+      requirement_satisfied =
+        if existing
+          existing.version == spec.version && requirement.requirement.satisfied_by?(spec.version)
+        else
+          requirement.requirement.satisfied_by? spec.version
+        end
+      requirement_satisfied && !(spec.version.prerelease? && existing_vertices.flat_map(&:requirements).none?(&:prerelease?))
+    end
+
+    # Sort dependencies so that the ones that are easiest to resolve are first.
+    # Easiest to resolve is (usually) defined by:
+    #   1) Is this dependency already activated?
+    #   2) How relaxed are the requirements?
+    #   3) Are there any conflicts for this dependency?
+    #   4) How many possibilities are there to satisfy this dependency?
     #
-    # @note   If there is a locked dependency with the same name of a
-    #         given dependency the locked one is used in place of the
-    #         dependency of the specification. In this way it is possible to
-    #         prevent the update of the version of installed pods not changed
-    #         in the Podfile.
+    # @return [Array<Dependency>] the sorted dependencies.
     #
-    # @note   The recursive process checks if a dependency has already been
-    #         loaded to prevent an infinite loop.
+    # @param  [Array<Dependency>] dependencies the unsorted dependencies.
     #
-    # @note   The set class merges all (of all the target definitions) the
-    #         dependencies and thus it keeps track of whether it is in head
-    #         mode or from an external source because {Dependency#merge}
-    #         preserves this information.
+    # @param  [Molinillo::DependencyGraph] activated the dependency graph of
+    #         currently activated specs.
     #
-    # @return [void]
+    # @param  [{String => Array<Conflict>}] conflicts the current conflicts.
     #
-    def find_dependency_specs(dependent_spec, dependencies, target_definition)
-      dependencies.each do |dependency|
-        locked_dep = locked_dependencies.find { |ld| ld.name == dependency.name }
-        dependency = locked_dep if locked_dep
+    def sort_dependencies(dependencies, activated, conflicts)
+      dependencies.sort_by do |dependency|
+        name = name_for(dependency)
+        [
+          activated.vertex_named(name).payload ? 0 : 1,
+          dependency.prerelease? ? 0 : 1,
+          conflicts[name] ? 0 : 1,
+          search_for(dependency).count,
+        ]
+      end
+    end
+
+    #-------------------------------------------------------------------------#
 
-        UI.message("- #{dependency}", '', 2) do
-          set = find_cached_set(dependency, dependent_spec)
-          set.required_by(dependency, dependent_spec.to_s)
+    public
 
-          if (paths = set.specification_paths_for_version(set.required_version)).length > 1
-            UI.warn "Found multiple specifications for #{dependency}:\n" \
-              "- #{paths.join("\n")}"
-          end
+    # @!group Resolver UI
 
-          unless @loaded_specs.include?(dependency.name)
-            spec = set.specification.subspec_by_name(dependency.name)
-            @loaded_specs << spec.name
-            cached_specs[spec.name] = spec
-            validate_platform(spec, target_definition)
-            if dependency.head? || sandbox.head_pod?(spec.name)
-              spec.version.head = true
-              sandbox.store_head_pod(spec.name)
-            end
+    include Molinillo::UI
 
-            spec_dependencies = spec.all_dependencies(target_definition.platform)
-            find_dependency_specs(spec, spec_dependencies, target_definition)
-          end
-        end
-      end
+    include Config::Mixin
+
+    # The UI object the resolver should use for displaying user-facing output.
+    #
+    # @return [UserInterface] the normal CocoaPods UI object.
+    #
+    def output
+      UI
     end
 
+    # Called before resolution starts. We print out `Resolving dependencies` in
+    # the analyzer, so here we just want to print out a starting `.` in verbose
+    # mode.
+    #
+    # @return [Void]
+    #
+    def before_resolution
+      UI.print '.' if config.verbose
+    end
+
+    # Called after resolution ends. We don't want to {#indicate_progress}
+    # unless in verbose mode, so we only use the default implementation then.
+    #
+    # @return [Void]
+    #
+    def after_resolution
+      super if config.verbose
+    end
+
+    # Called during resolution to indicate progress.
+    # We only use the default implementation in verbose mode.
+    #
+    # @return [Void]
+    #
+    def indicate_progress
+      super if config.verbose
+    end
+
+    #-------------------------------------------------------------------------#
+
+    private
+
+    # !@ Resolution context
+
+    # @return [Hash<String => Set>] A cache that keeps tracks of the sets
+    #         loaded by the resolution process.
+    #
+    # @note   Sets store the resolved dependencies and return the highest
+    #         available specification found in the sources. This is done
+    #         globally and not per target definition because there can be just
+    #         one Pod installation, so different version of the same Pods for
+    #         target definitions are not allowed.
+    #
+    attr_accessor :cached_sets
+
+    #-------------------------------------------------------------------------#
+
+    private
+
+    # @!group Private helpers
+
     # @return [Set] Loads or returns a previously initialized set for the Pod
     #               of the given dependency.
     #
     # @param  [Dependency] dependency
     #         The dependency for which the set is needed.
     #
-    # @param  [#to_s] dependent_spec
-    #         the specification whose dependencies are being resolved. Used
-    #         only for UI purposes.
-    #
     # @return [Set] the cached set for a given dependency.
     #
-    def find_cached_set(dependency, dependent_spec)
+    def find_cached_set(dependency)
       name = dependency.root_name
       unless cached_sets[name]
         if dependency.external_source
-          spec = sandbox.specification(dependency.root_name)
+          spec = sandbox.specification(name)
           unless spec
             raise StandardError, '[Bug] Unable to find the specification ' \
               "for `#{dependency}`."
@@ -199,8 +304,7 @@ module Pod
         end
         cached_sets[name] = set
         unless set
-          raise Informative, 'Unable to find a specification for ' \
-            "`#{dependency}` depended upon by #{dependent_spec}."
+          raise Molinillo::NoSuchDependencyError.new(dependency) # rubocop:disable Style/RaiseArgs
         end
       end
       cached_sets[name]
@@ -239,5 +343,38 @@ module Pod
           "a minimum requirement of #{spec.available_platforms.join(' - ')}."
       end
     end
+
+    # Returns the target-appropriate nodes that are `successors` of `node`,
+    # rejecting those that are {Dependency#from_subspec_dependency?} and have
+    # and incompatible platform.
+    #
+    # @return [Array<Molinillo::DependencyGraph::Vertex>]
+    #         An array of target-appropriate nodes whose `payload`s are
+    #         dependencies for `target`.
+    #
+    def valid_dependencies_for_target_from_node(target, node)
+      dependency_nodes = node.outgoing_edges.select do |edge|
+        edge_is_valid_for_target?(edge, target)
+      end.map(&:destination)
+
+      dependency_nodes + dependency_nodes.flat_map { |n| valid_dependencies_for_target_from_node(target, n) }
+    end
+
+    # Whether the given `edge` should be followed to find dependencies for the
+    # given `target`.
+    #
+    # @note At the moment, this method only checks whether the edge's
+    #       requirements are normal dependencies _or_ whether they are
+    #       dependencies that come from {Specification#subspec_dependencies}
+    #       and, if so, that their platforms are compatible with the target's.
+    #
+    # @return [Bool]
+    #
+    def edge_is_valid_for_target?(edge, target)
+      edge.requirements.any? do |dependency|
+        !dependency.from_subspec_dependency? ||
+          edge.destination.payload.available_platforms.any? { |p| target.platform.supports?(p) }
+      end
+    end
   end
 end