cocoapods 0.39.0 → 1.0.0.beta.1

data/lib/cocoapods/installer/analyzer.rb

@@ -5,6 +5,9 @@ module Pod
     #
     class Analyzer
       include Config::Mixin
+      include InstallationOptions::Mixin
+
+      delegate_installation_options { podfile }
 
       autoload :AnalysisResult,            'cocoapods/installer/analyzer/analysis_result'
       autoload :SandboxAnalyzer,           'cocoapods/installer/analyzer/sandbox_analyzer'
@@ -57,7 +60,7 @@ module Pod
         validate_podfile!
         validate_lockfile_version!
         @result = AnalysisResult.new
-        if config.integrate_targets?
+        if installation_options.integrate_targets?
           @result.target_inspections = inspect_targets_to_integrate
         else
           verify_platforms_specified!
@@ -157,6 +160,7 @@ module Pod
         unless validator.valid?
           raise Informative, validator.message
         end
+        validator.warnings.uniq.each { |w| UI.warn(w) }
       end
 
       # @!group Analysis steps
@@ -225,9 +229,14 @@ module Pod
       #
       def generate_targets
         pod_targets = generate_pod_targets(result.specs_by_target)
-        result.specs_by_target.map do |target_definition, _|
+        aggregate_targets = result.specs_by_target.keys.reject(&:abstract?).map do |target_definition|
           generate_target(target_definition, pod_targets)
         end
+        aggregate_targets.each do |target|
+          target.search_paths_aggregate_targets = aggregate_targets.select do |aggregate_target|
+            target.target_definition.targets_to_inherit_search_paths.include?(aggregate_target.target_definition)
+          end
+        end
       end
 
       # Setup the aggregate target for a single user target
@@ -244,15 +253,16 @@ module Pod
         target = AggregateTarget.new(target_definition, sandbox)
         target.host_requires_frameworks |= target_definition.uses_frameworks?
 
-        if config.integrate_targets?
+        if installation_options.integrate_targets?
           target_inspection = result.target_inspections[target_definition]
-          target.user_project_path = target_inspection.project_path
-          target.client_root = target.user_project_path.dirname
+          raise "missing inspection: #{target_definition.name}" unless target_inspection
+          target.user_project = target_inspection.project
+          target.client_root = target.user_project_path.dirname.realpath
           target.user_target_uuids = target_inspection.project_target_uuids
           target.user_build_configurations = target_inspection.build_configurations
           target.archs = target_inspection.archs
         else
-          target.client_root = config.installation_root
+          target.client_root = config.installation_root.realpath
           target.user_target_uuids = []
           target.user_build_configurations = target_definition.build_configurations || { 'Release' => :release, 'Debug' => :debug }
           if target_definition.platform && target_definition.platform.name == :osx
@@ -276,7 +286,9 @@ module Pod
       # @return [Array<PodTarget>]
       #
       def generate_pod_targets(specs_by_target)
-        if config.deduplicate_targets?
+        if installation_options.deduplicate_targets?
+          dedupe_cache = {}
+
           all_specs = specs_by_target.flat_map do |target_definition, dependent_specs|
             dependent_specs.group_by(&:root).map do |root_spec, specs|
               [root_spec, specs, target_definition]
@@ -294,7 +306,7 @@ module Pod
               # There are different sets of subspecs or the spec is used across different platforms
               targets_by_distinctors.flat_map do |distinctor, target_definitions|
                 specs, = *distinctor
-                generate_pod_target(target_definitions, specs).scoped
+                generate_pod_target(target_definitions, specs).scoped(dedupe_cache)
               end
             else
               (specs, _), target_definitions = targets_by_distinctors.first
@@ -308,7 +320,7 @@ module Pod
             dependent_targets = transitive_dependencies_for_pod_target(target, pod_targets)
             target.dependent_targets = dependent_targets
             if dependent_targets.any?(&:scoped?)
-              target.scoped
+              target.scoped(dedupe_cache)
             else
               target
             end
@@ -317,7 +329,7 @@ module Pod
           pod_targets = specs_by_target.flat_map do |target_definition, specs|
             grouped_specs = specs.group_by.group_by(&:root).values.uniq
             grouped_specs.flat_map do |pod_specs|
-              generate_pod_target([target_definition], pod_specs).scoped
+              generate_pod_target([target_definition], pod_specs).scoped(dedupe_cache)
             end
           end
           pod_targets.each do |target|
@@ -369,7 +381,7 @@ module Pod
       def generate_pod_target(target_definitions, pod_specs)
         pod_target = PodTarget.new(pod_specs, target_definitions, sandbox)
 
-        if config.integrate_targets?
+        if installation_options.integrate_targets?
           target_inspections = result.target_inspections.select { |t, _| target_definitions.include?(t) }.values
           pod_target.user_build_configurations = target_inspections.map(&:build_configurations).reduce({}, &:merge)
           pod_target.archs = target_inspections.flat_map(&:archs).compact.uniq.sort
@@ -454,6 +466,7 @@ module Pod
         else
           source = ExternalSources.from_dependency(dependency, podfile.defined_in_file)
         end
+        source.can_cache = installation_options.clean?
         source.fetch(sandbox)
       end
 
@@ -469,7 +482,6 @@ module Pod
             deps_to_fetch_if_needed = deps_with_external_source.select { |dep| result.podfile_state.unchanged.include?(dep.name) }
             deps_to_fetch += deps_to_fetch_if_needed.select do |dep|
               sandbox.specification(dep.name).nil? ||
-                !dep.external_source[:local].nil? ||
                 !dep.external_source[:path].nil? ||
                 !sandbox.pod_dir(dep.root_name).directory? ||
                 checkout_requires_update?(dep)
@@ -612,13 +624,21 @@ module Pod
       def sources
         @sources ||= begin
           sources = podfile.sources
-          if sources.empty?
-            url = 'https://github.com/CocoaPods/Specs.git'
-            [SourcesManager.find_or_create_source_with_url(url)]
+
+          # Add any sources specified using the :source flag on individual dependencies.
+          dependency_sources = podfile.dependencies.map(&:podspec_repo).compact
+
+          all_dependencies_have_sources = dependency_sources.count == podfile.dependencies.count
+          if all_dependencies_have_sources
+            sources = dependency_sources
+          elsif sources.empty?
+            sources = ['https://github.com/CocoaPods/Specs.git']
           else
-            sources.map do |source_url|
-              SourcesManager.find_or_create_source_with_url(source_url)
-            end
+            sources += dependency_sources
+          end
+
+          sources.uniq.map do |source_url|
+            SourcesManager.find_or_create_source_with_url(source_url)
           end
         end
       end
@@ -634,7 +654,7 @@ module Pod
       # @return [void]
       #
       def verify_platforms_specified!
-        unless config.integrate_targets?
+        unless installation_options.integrate_targets?
           podfile.target_definition_list.each do |target_definition|
             if !target_definition.empty? && target_definition.platform.nil?
               raise Informative, 'It is necessary to specify the platform in the Podfile if not integrating.'
@@ -654,12 +674,20 @@ module Pod
       def inspect_targets_to_integrate
         inspection_result = {}
         UI.section 'Inspecting targets to integrate' do
-          podfile.target_definition_list.each do |target_definition|
-            inspector = TargetInspector.new(target_definition, config.installation_root)
-            results = inspector.compute_results
-            inspection_result[target_definition] = results
-            UI.message('Using `ARCHS` setting to build architectures of ' \
-              "target `#{target_definition.label}`: (`#{results.archs.join('`, `')}`)")
+          inspectors = podfile.target_definition_list.map do |target_definition|
+            next if target_definition.abstract?
+            TargetInspector.new(target_definition, config.installation_root)
+          end.compact
+          inspectors.group_by(&:compute_project_path).each do |project_path, target_inspectors|
+            project = Xcodeproj::Project.open(project_path)
+            target_inspectors.each do |inspector|
+              target_definition = inspector.target_definition
+              inspector.user_project = project
+              results = inspector.compute_results
+              inspection_result[target_definition] = results
+              UI.message('Using `ARCHS` setting to build architectures of ' \
+                "target `#{target_definition.label}`: (`#{results.archs.join('`, `')}`)")
+            end
           end
         end
         inspection_result

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

@@ -14,7 +14,7 @@ module Pod
       # - 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 in head mode or from an external source and the
+      # - 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.
@@ -135,7 +135,7 @@ module Pod
         # 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 in head mode and the ones from external
+        #         hash changed the Pods from external
         #         sources are always marked as changed.
         #
         # @note   A Pod whose folder is empty is considered changed.
@@ -152,10 +152,6 @@ module Pod
           return true if resolved_spec_names(pod) != sandbox_spec_names(pod)
           return true if sandbox.predownloaded?(pod)
           return true if folder_empty?(pod)
-          return true if sandbox.head_pod?(pod) != sandbox_head_version?(pod)
-          if update_mode
-            return true if sandbox.head_pod?(pod)
-          end
           false
         end
 
@@ -238,13 +234,6 @@ module Pod
           sandbox_manifest.checksum(pod)
         end
 
-        # @return [Bool] Wether the Pod is installed in the sandbox is in head
-        #         mode.
-        #
-        def sandbox_head_version?(pod)
-          sandbox_version(pod).head? == true
-        end
-
         #--------------------------------------#
 
         def folder_exist?(pod)

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

@@ -35,6 +35,10 @@ module Pod
         #         due to the presence of Swift source in the user's targets
         #
         attr_accessor :recommends_frameworks
+
+        # @return [Xcodeproj::Project] the user's Xcode project
+        #
+        attr_accessor :project
       end
     end
   end

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

@@ -1,3 +1,5 @@
+require 'active_support/core_ext/array/conversions'
+
 module Pod
   class Installer
     class Analyzer
@@ -25,27 +27,26 @@ module Pod
 
         # Inspect the #target_definition
         #
+        # @raise If no `user_project` is set
+        #
         # @return [TargetInspectionResult]
         #
         def compute_results
-          project_path = compute_project_path
-          user_project = Xcodeproj::Project.open(project_path)
+          raise ArgumentError, 'Cannot compute results without a user project set' unless user_project
+
           targets = compute_targets(user_project)
 
           result = TargetInspectionResult.new
           result.target_definition = target_definition
-          result.project_path = project_path
+          result.project_path = user_project.path
           result.project_target_uuids = targets.map(&:uuid)
           result.build_configurations = compute_build_configurations(targets)
           result.platform = compute_platform(targets)
           result.archs = compute_archs(targets)
+          result.project = user_project
           result
         end
 
-        #-----------------------------------------------------------------------#
-
-        private
-
         # Returns the path of the user project that the #target_definition
         # should integrate.
         #
@@ -77,6 +78,15 @@ module Pod
           path
         end
 
+        # @return [Xcodeproj::Project] the user's Xcode project, used for target
+        #         inspection
+        #
+        attr_accessor :user_project
+
+        #-----------------------------------------------------------------------#
+
+        private
+
         # Returns a list of the targets from the project of #target_definition
         # that needs to be integrated.
         #
@@ -94,19 +104,12 @@ module Pod
         #
         def compute_targets(user_project)
           native_targets = user_project.native_targets
-          if link_with = target_definition.link_with
-            targets = native_targets.select { |t| link_with.include?(t.name) }
-            raise Informative, "Unable to find the targets named #{link_with.map { |x| "`#{x}`" }.to_sentence}" \
-              "to link with target definition `#{target_definition.name}`" if targets.empty?
-          elsif target_definition.link_with_first_target?
-            targets = [native_targets.first].compact
-            raise Informative, 'Unable to find a target' if targets.empty?
-          else
-            target = native_targets.find { |t| t.name == target_definition.name.to_s }
-            targets = [target].compact
-            raise Informative, "Unable to find a target named `#{target_definition.name}`" if targets.empty?
+          target = native_targets.find { |t| t.name == target_definition.name.to_s }
+          unless target
+            found = native_targets.map { |t| "`#{t.name}`" }.to_sentence
+            raise Informative, "Unable to find a target named `#{target_definition.name}`, did find #{found}."
           end
-          targets
+          [target]
         end
 
         # @param  [Array<PBXNativeTarget] the user's targets of the project of

data/lib/cocoapods/installer/file_references_installer.rb

@@ -117,21 +117,19 @@ module Pod
             pod_target.file_accessors.each do |file_accessor|
               framework_exp = /\.framework\//
               headers_sandbox = Pathname.new(file_accessor.spec.root.name)
-              pod_target.build_headers.add_search_path(headers_sandbox, pod_target.platform)
 
               # When integrating Pod as frameworks, built Pods are built into
               # frameworks, whose headers are included inside the built
               # framework. Those headers do not need to be linked from the
               # sandbox.
               unless pod_target.requires_frameworks? && pod_target.should_build?
+                pod_target.build_headers.add_search_path(headers_sandbox, pod_target.platform)
                 sandbox.public_headers.add_search_path(headers_sandbox, pod_target.platform)
-              end
 
-              header_mappings(headers_sandbox, file_accessor, file_accessor.headers).each do |namespaced_path, files|
-                pod_target.build_headers.add_files(namespaced_path, files.reject { |f| f.to_path =~ framework_exp })
-              end
+                header_mappings(headers_sandbox, file_accessor, file_accessor.headers).each do |namespaced_path, files|
+                  pod_target.build_headers.add_files(namespaced_path, files.reject { |f| f.to_path =~ framework_exp })
+                end
 
-              unless pod_target.requires_frameworks? && pod_target.should_build?
                 header_mappings(headers_sandbox, file_accessor, file_accessor.public_headers).each do |namespaced_path, files|
                   sandbox.public_headers.add_files(namespaced_path, files.reject { |f| f.to_path =~ framework_exp })
                 end
@@ -179,6 +177,7 @@ module Pod
           pod_name = file_accessor.spec.name
           local = sandbox.local?(pod_name)
           paths = file_accessor.send(file_accessor_key)
+          paths = allowable_project_paths(paths)
           paths.each do |path|
             group = pods_project.group_for_spec(file_accessor.spec.name, group_key)
             pods_project.add_file_reference(path, group, local && reflect_file_system_structure_for_development)
@@ -186,6 +185,54 @@ module Pod
         end
       end
 
+      # Filters a list of paths down to those paths which can be added to
+      # the Xcode project. Some paths are intermediates and only their children
+      # should be added, while some paths are treated as bundles and their
+      # children should not be added directly.
+      #
+      # @param  [Array<Pathname>] paths
+      #         The paths to files or directories on disk.
+      #
+      # @return [Array<Pathname>] The paths which can be added to the Xcode project
+      #
+      def allowable_project_paths(paths)
+        lproj_paths = Set.new
+        lproj_paths_with_files = Set.new
+        allowable_paths = paths.select do |path|
+          path_str = path.to_s.downcase
+
+          # We add the directory for a Core Data model, but not the items in it.
+          next if path_str =~ /.*\.xcdatamodeld\/.+/
+
+          # We add the directory for an asset catalog, but not the items in it.
+          next if path_str =~ /.*\.xcassets\/.+/
+
+          if path_str =~ /\.lproj(\/|$)/
+            # If the element is an .lproj directory then save it and potentially
+            # add it later if we don't find any contained items.
+            if path_str.end_with?('.lproj') && path.directory?
+              lproj_paths << path_str
+              next
+            end
+
+            # Collect the paths for the .lproj directories that contain files.
+            lproj_path = /(^.*\.lproj)\/.*/.match(path_str)[1]
+            lproj_paths_with_files << lproj_path
+
+            # Directories nested within an .lproj directory are added as file
+            # system references so their contained items are not added directly.
+            next if path.dirname.dirname.to_s.downcase == lproj_path
+          end
+
+          true
+        end
+
+        # Only add the path for the .lproj directories that do not have anything
+        # within them added as well. This generally happens if the glob within the
+        # resources directory was not a recursive glob.
+        allowable_paths + lproj_paths.subtract(lproj_paths_with_files).to_a
+      end
+
       # Computes the destination sub-directory in the sandbox
       #
       # @param  [Pathname] headers_sandbox

data/lib/cocoapods/installer/installation_options.rb

@@ -0,0 +1,156 @@
+require 'active_support/hash_with_indifferent_access'
+
+module Pod
+  class Installer
+    # Represents the installation options the user can customize via a
+    # `Podfile`.
+    #
+    class InstallationOptions
+      # Parses installation options from a podfile.
+      #
+      # @param  [Podfile] podfile the podfile to parse installation options
+      #         from.
+      #
+      # @raise  [Informative] if `podfile` does not specify a `CocoaPods`
+      #         install.
+      #
+      # @return [Self]
+      #
+      def self.from_podfile(podfile)
+        name, options = podfile.installation_method
+        unless name.downcase == 'cocoapods'
+          raise Informative, "Currently need to specify a `cocoapods` install, you chose `#{name}`."
+        end
+        new(options)
+      end
+
+      # Defines a new installation option.
+      #
+      # @param  [#to_s] name the name of the option.
+      #
+      # @param  default the default value for the option.
+      #
+      # @param [Boolean] boolean whether the option has a boolean value.
+      #
+      # @return [void]
+      #
+      # @!macro [attach] option
+      #
+      #   @note this option defaults to $2.
+      #
+      #   @return the $1 $0 for installation.
+      #
+      def self.option(name, default, boolean: true)
+        name = name.to_s
+        raise ArgumentError, "The `#{name}` option is already defined" if defaults.key?(name)
+        defaults[name] = default
+        attr_accessor name
+        alias_method "#{name}?", name if boolean
+      end
+
+      # @return [Hash<Symbol,Object>] all known installation options and their
+      #         default values.
+      #
+      def self.defaults
+        @defaults ||= {}
+      end
+
+      # @return [Array<Symbol>] the names of all known installation options.
+      #
+      def self.all_options
+        defaults.keys
+      end
+
+      # Initializes the installation options with a hash of options from a
+      # Podfile.
+      #
+      # @param  [Hash] options the options to parse.
+      #
+      # @raise  [Informative] if `options` contains any unknown keys.
+      #
+      def initialize(options = {})
+        options = ActiveSupport::HashWithIndifferentAccess.new(options)
+        unknown_keys = options.keys - self.class.all_options.map(&:to_s)
+        raise Informative, "Unknown installation options: #{unknown_keys.to_sentence}." unless unknown_keys.empty?
+        self.class.defaults.each do |key, default|
+          value = options.fetch(key, default)
+          send("#{key}=", value)
+        end
+      end
+
+      # @param  [Boolean] include_defaults whether values that match the default
+      #         for their option should be included. Defaults to `true`.
+      #
+      # @return [Hash] the options, keyed by option name.
+      #
+      def to_h(include_defaults: true)
+        self.class.defaults.reduce(ActiveSupport::HashWithIndifferentAccess.new) do |hash, (option, default)|
+          value = send(option)
+          hash[option] = value if include_defaults || value != default
+          hash
+        end
+      end
+
+      def ==(other)
+        other.is_a?(self.class) && to_h == other.to_h
+      end
+
+      alias_method :eql, :==
+
+      def hash
+        to_h.hash
+      end
+
+      option :clean, true
+      option :deduplicate_targets, true
+      option :deterministic_uuids, true
+      option :integrate_targets, true
+      option :lock_pod_sources, true
+
+      module Mixin
+        module ClassMethods
+          # Delegates the creation of {#installation_options} to the `Podfile`
+          # returned by the given block.
+          #
+          # @param  blk a block that returns the `Podfile` to create
+          #         installation options from.
+          #
+          # @return [Void]
+          #
+          def delegate_installation_options(&blk)
+            define_method(:installation_options) do
+              @installation_options ||= InstallationOptions.from_podfile(instance_eval(&blk))
+            end
+          end
+
+          # Delegates the installation options attributes directly to
+          # {#installation_options}.
+          #
+          # @return [Void]
+          #
+          def delegate_installation_option_attributes!
+            define_method(:respond_to_missing?) do |name, *args|
+              installation_options.respond_to?(name, *args) || super
+            end
+
+            define_method(:method_missing) do |name, *args, &blk|
+              if installation_options.respond_to?(name)
+                installation_options.send(name, *args, &blk)
+              else
+                super
+              end
+            end
+          end
+        end
+
+        # @return [InstallationOptions] The installation options.
+        #
+        attr_accessor :installation_options
+
+        def self.included(mod)
+          mod.extend(ClassMethods)
+        end
+      end
+    end
+  end
+end