cocoapods 1.4.0 → 1.5.0.beta.1

data/lib/cocoapods/sandbox.rb

@@ -57,7 +57,7 @@ module Pod
     def initialize(root)
       FileUtils.mkdir_p(root)
       @root = Pathname.new(root).realpath
-      @public_headers = HeadersStore.new(self, 'Public')
+      @public_headers = HeadersStore.new(self, 'Public', :public)
       @predownloaded_pods = []
       @checkout_sources = {}
       @development_pods = {}
@@ -389,9 +389,7 @@ module Pod
     #
     def local_podspec(name)
       root_name = Specification.root_name(name)
-      if path = development_pods[root_name]
-        Pathname.new(path)
-      end
+      development_pods[root_name]
     end
 
     #-------------------------------------------------------------------------#

data/lib/cocoapods/sandbox/file_accessor.rb

@@ -196,9 +196,9 @@ module Pod
       #         shipped with the Pod.
       #
       def vendored_frameworks_headers
-        vendored_frameworks.map do |framework|
+        vendored_frameworks.flat_map do |framework|
           self.class.vendored_frameworks_headers(framework)
-        end.flatten.uniq
+        end.uniq
       end
 
       # @return [Array<Pathname>] The paths of the library bundles that come
@@ -278,11 +278,7 @@ module Pod
       #         specification or auto-detected.
       #
       def license
-        if file = spec_consumer.license[:file]
-          path_list.root + file
-        else
-          path_list.glob([GLOB_PATTERNS[:license]]).first
-        end
+        spec_license || path_list.glob([GLOB_PATTERNS[:license]]).first
       end
 
       # @return [Pathname, Nil] The path of the custom module map file of the
@@ -305,17 +301,37 @@ module Pod
         path_list.glob([GLOB_PATTERNS[:docs]])
       end
 
+      # @return [Pathname] The path of the license file specified in the
+      #         specification, if it exists
+      #
+      def spec_license
+        if file = spec_consumer.license[:file]
+          absolute_path = root + file
+          absolute_path if File.exist?(absolute_path)
+        end
+      end
+
       # @return [Array<Pathname>] Paths to include for local pods to assist in development
       #
       def developer_files
         podspecs = specs
         result = [module_map, prefix_header]
+
+        if license_path = spec_consumer.license[:file]
+          license_path = root + license_path
+          unless File.exist?(license_path)
+            UI.warn "A license was specified in podspec `#{spec.name}` but the file does not exist - #{license_path}"
+          end
+        end
+
         if podspecs.size <= 1
           result += [license, readme, podspecs, docs]
         else
+          # Manually add non-globbing files since there are multiple podspecs in the same folder
           result << podspec_file
-          if file = spec_consumer.license[:file]
-            result << root + file
+          if license_file = spec_license
+            absolute_path = root + license_file
+            result << absolute_path if File.exist?(absolute_path)
           end
         end
         result.compact.flatten.sort

data/lib/cocoapods/sandbox/headers_store.rb

@@ -4,6 +4,8 @@ module Pod
     # the header search paths.
     #
     class HeadersStore
+      SEARCH_PATHS_KEY = Struct.new(:platform_name, :target_name, :use_modular_headers)
+
       # @return [Pathname] the absolute path of this header directory.
       #
       def root
@@ -20,25 +22,48 @@ module Pod
       #         the relative path to the sandbox root and hence to the Pods
       #         project.
       #
-      def initialize(sandbox, relative_path)
+      # @param  [Symbol] visibility_scope
+      #         the header visibility scope to use in this store. Can be `:private` or `:public`.
+      #
+      def initialize(sandbox, relative_path, visibility_scope)
         @sandbox       = sandbox
         @relative_path = relative_path
         @search_paths  = []
+        @search_paths_cache = {}
+        @visibility_scope = visibility_scope
       end
 
       # @param  [Platform] platform
       #         the platform for which the header search paths should be
-      #         returned
+      #         returned.
+      #
+      # @param  [String] target_name
+      #         the target for which the header search paths should be
+      #         returned. Can be `nil` in which case all headers that match the platform
+      #         will be returned.
+      #
+      # @param  [Boolean] use_modular_headers
+      #         whether the search paths generated should use modular (stricter) style.
       #
       # @return [Array<String>] All the search paths of the header directory in
       #         xcconfig format. The paths are specified relative to the pods
       #         root with the `${PODS_ROOT}` variable.
       #
-      def search_paths(platform)
-        platform_search_paths = @search_paths.select { |entry| entry[:platform] == platform.name }
-
+      def search_paths(platform, target_name = nil, use_modular_headers = false)
+        key = SEARCH_PATHS_KEY.new(platform.name, target_name, use_modular_headers)
+        return @search_paths_cache[key] if @search_paths_cache.key?(key)
+        search_paths = @search_paths.select do |entry|
+          matches_platform = entry[:platform] == platform.name
+          matches_target = target_name.nil? || (entry[:path].basename.to_s == target_name)
+          matches_platform && matches_target
+        end
         headers_dir = root.relative_path_from(sandbox.root).dirname
-        ["${PODS_ROOT}/#{headers_dir}/#{@relative_path}"] + platform_search_paths.uniq.map { |entry| "${PODS_ROOT}/#{headers_dir}/#{entry[:path]}" }
+        @search_paths_cache[key] = search_paths.flat_map do |entry|
+          paths = []
+          paths << "${PODS_ROOT}/#{headers_dir}/#{@relative_path}" if !use_modular_headers || @visibility_scope == :public
+          paths << "${PODS_ROOT}/#{headers_dir}/#{entry[:path]}" if !use_modular_headers || @visibility_scope == :private
+          paths
+        end.uniq
       end
 
       # Removes the directory as it is regenerated from scratch during each

data/lib/cocoapods/sandbox/path_list.rb

@@ -1,4 +1,5 @@
 require 'active_support/multibyte/unicode'
+require 'find'
 
 module Pod
   class Sandbox
@@ -50,23 +51,23 @@ module Pod
         unless root.exist?
           raise Informative, "Attempt to read non existent folder `#{root}`."
         end
-        escaped_root = escape_path_for_glob(root)
-
-        absolute_paths = Pathname.glob(escaped_root + '**/*', File::FNM_DOTMATCH).lazy
-        dirs_and_files = absolute_paths.reject { |path| path.basename.to_s =~ /^\.\.?$/ }
-        dirs, files = dirs_and_files.partition { |path| File.directory?(path) }
 
+        dirs = []
+        files = []
         root_length = root.cleanpath.to_s.length + File::SEPARATOR.length
-        sorted_relative_paths_from_full_paths = lambda do |paths|
-          relative_paths = paths.lazy.map do |path|
-            path_string = path.to_s
-            path_string.slice(root_length, path_string.length - root_length)
-          end
-          relative_paths.sort_by(&:upcase)
+        Find.find(root.to_s) do |f|
+          directory = File.directory?(f)
+          f = f.slice(root_length, f.length - root_length)
+          next if f.nil?
+
+          (directory ? dirs : files) << f
         end
 
-        @dirs = sorted_relative_paths_from_full_paths.call(dirs)
-        @files = sorted_relative_paths_from_full_paths.call(files)
+        dirs.sort_by!(&:upcase)
+        files.sort_by!(&:upcase)
+
+        @dirs = dirs
+        @files = files
         @glob_cache = {}
       end
 
@@ -87,7 +88,7 @@ module Pod
       # @return [Array<Pathname>]
       #
       def glob(patterns, options = {})
-        relative_glob(patterns, options).map { |p| root + p }
+        relative_glob(patterns, options).map { |p| root.join(p) }
       end
 
       # The list of relative paths that are case insensitively matched by a
@@ -127,19 +128,27 @@ module Pod
         else
           full_list = files
         end
-
-        list = Array(patterns).map do |pattern|
-          if directory?(pattern) && dir_pattern
-            pattern += '/' unless pattern.end_with?('/')
-            pattern += dir_pattern
-          end
-          expanded_patterns = dir_glob_equivalent_patterns(pattern)
-          full_list.select do |path|
-            expanded_patterns.any? do |p|
-              File.fnmatch(p, path, File::FNM_CASEFOLD | File::FNM_PATHNAME)
+        patterns_array = Array(patterns)
+        exact_matches = (full_list & patterns_array).to_set
+
+        unless patterns_array.empty?
+          list = patterns_array.flat_map do |pattern|
+            if exact_matches.include?(pattern)
+              pattern
+            else
+              if directory?(pattern) && dir_pattern
+                pattern += '/' unless pattern.end_with?('/')
+                pattern += dir_pattern
+              end
+              expanded_patterns = dir_glob_equivalent_patterns(pattern)
+              full_list.select do |path|
+                expanded_patterns.any? do |p|
+                  File.fnmatch(p, path, File::FNM_CASEFOLD | File::FNM_PATHNAME)
+                end
+              end
             end
           end
-        end.flatten
+        end
 
         list = list.map { |path| Pathname.new(path) }
         if exclude_patterns
@@ -198,35 +207,16 @@ module Pod
         else
           patterns = [pattern]
           values_by_set.each do |set, values|
-            patterns = patterns.map do |old_pattern|
+            patterns = patterns.flat_map do |old_pattern|
               values.map do |value|
                 old_pattern.gsub(set, value)
               end
-            end.flatten
+            end
           end
           patterns
         end
       end
 
-      # Escapes the glob metacharacters from a given path so it can used in
-      # Dir#glob and similar methods.
-      #
-      # @note   See CocoaPods/CocoaPods#862.
-      #
-      # @param  [String, Pathname] path
-      #         The path to escape.
-      #
-      # @return [Pathname] The escaped path.
-      #
-      def escape_path_for_glob(path)
-        result = path.to_s
-        characters_to_escape = ['[', ']', '{', '}', '?', '*']
-        characters_to_escape.each do |character|
-          result.gsub!(character, "\\#{character}")
-        end
-        Pathname.new(result)
-      end
-
       #-----------------------------------------------------------------------#
     end
   end

data/lib/cocoapods/target.rb

@@ -74,7 +74,7 @@ module Pod
     #         #requires_frameworks?.
     #
     def product_type
-      requires_frameworks? && !static_framework? ? :framework : :static_library
+      requires_frameworks? ? :framework : :static_library
     end
 
     # @return [String] A string suitable for debugging.
@@ -95,7 +95,9 @@ module Pod
     # @return [Boolean] Whether the target should build a static framework.
     #
     def static_framework?
-      !is_a?(Pod::AggregateTarget) && specs.any? && specs.flat_map(&:root).all?(&:static_framework)
+      return if is_a?(Pod::AggregateTarget)
+      return if specs.empty?
+      specs.all? { |spec| spec.root.static_framework }
     end
 
     #-------------------------------------------------------------------------#
@@ -148,14 +150,15 @@ module Pod
     #         module map.
     #
     def umbrella_header_path
-      support_files_dir + "#{label}-umbrella.h"
+      module_map_path.parent + "#{label}-umbrella.h"
     end
 
     # @return [Pathname] the absolute path of the LLVM module map file that
     #         defines the module structure for the compiler.
     #
     def module_map_path
-      support_files_dir + "#{label}.modulemap"
+      basename = "#{label}.modulemap"
+      support_files_dir + basename
     end
 
     # @return [Pathname] the absolute path of the bridge support file.

data/lib/cocoapods/target/aggregate_target.rb

@@ -140,7 +140,7 @@ module Pod
     # @return [Array<AggregateTarget>] The aggregate targets whose pods this
     #         target must be able to import, but will not directly link against.
     #
-    attr_accessor :search_paths_aggregate_targets
+    attr_reader :search_paths_aggregate_targets
 
     # @param  [String] build_configuration The build configuration for which the
     #         the pod targets should be returned.
@@ -149,15 +149,20 @@ module Pod
     #         configuration.
     #
     def pod_targets_for_build_configuration(build_configuration)
-      pod_targets.select do |pod_target|
+      @pod_targets_for_build_configuration ||= {}
+      @pod_targets_for_build_configuration[build_configuration] ||= pod_targets.select do |pod_target|
         pod_target.include_in_build_config?(target_definition, build_configuration)
       end
     end
 
+    def pod_targets_to_link
+      @pod_targets_to_link ||= pod_targets.to_set - search_paths_aggregate_targets.flat_map(&:pod_targets)
+    end
+
     # @return [Array<Specification>] The specifications used by this aggregate target.
     #
     def specs
-      pod_targets.map(&:specs).flatten
+      pod_targets.flat_map(&:specs)
     end
 
     # @return [Hash{Symbol => Array<Specification>}] The pod targets for each
@@ -191,9 +196,7 @@ module Pod
       @framework_paths_by_config ||= begin
         framework_paths_by_config = {}
         user_build_configurations.keys.each do |config|
-          relevant_pod_targets = pod_targets.select do |pod_target|
-            pod_target.include_in_build_config?(target_definition, config)
-          end
+          relevant_pod_targets = pod_targets_for_build_configuration(config)
           framework_paths_by_config[config] = relevant_pod_targets.flat_map { |pt| pt.framework_paths(false) }
         end
         framework_paths_by_config
@@ -208,8 +211,7 @@ module Pod
           pod_target.should_build? && pod_target.requires_frameworks? && !pod_target.static_framework?
         end
         user_build_configurations.keys.each_with_object({}) do |config, resources_by_config|
-          resources_by_config[config] = relevant_pod_targets.flat_map do |pod_target|
-            next [] unless pod_target.include_in_build_config?(target_definition, config)
+          resources_by_config[config] = (relevant_pod_targets & pod_targets_for_build_configuration(config)).flat_map do |pod_target|
             (pod_target.resource_paths(false) + [bridge_support_file].compact).uniq
           end
         end

data/lib/cocoapods/target/pod_target.rb

@@ -49,11 +49,12 @@ module Pod
       raise "Can't initialize a PodTarget with only abstract TargetDefinitions" if target_definitions.all?(&:abstract?)
       raise "Can't initialize a PodTarget with an empty string scope suffix!" if scope_suffix == ''
       super()
-      @specs = specs
+      @specs = specs.dup.freeze
+      @test_specs, @non_test_specs = @specs.partition(&:test_specification?)
       @target_definitions = target_definitions
       @sandbox = sandbox
       @scope_suffix = scope_suffix
-      @build_headers  = Sandbox::HeadersStore.new(sandbox, 'Private')
+      @build_headers  = Sandbox::HeadersStore.new(sandbox, 'Private', :private)
       @file_accessors = []
       @resource_bundle_targets = []
       @test_resource_bundle_targets = []
@@ -162,17 +163,18 @@ module Pod
     #         to this target.
     attr_reader :test_resource_bundle_targets
 
-    # @return [Bool] Whether or not this target should be build.
+    # @return [Bool] Whether or not this target should be built.
     #
-    # A target should not be build if it has no source files.
+    # A target should not be built if it has no source files.
     #
     def should_build?
       return @should_build if defined? @should_build
-      @should_build = begin
-        source_files = file_accessors.flat_map(&:source_files)
-        source_files -= file_accessors.flat_map(&:headers)
-        !source_files.empty? || contains_script_phases?
-      end
+
+      return @should_build = true if contains_script_phases?
+
+      source_files = file_accessors.flat_map(&:source_files)
+      source_files -= file_accessors.flat_map(&:headers)
+      @should_build = !source_files.empty?
     end
 
     # @return [Array<Specification::Consumer>] the specification consumers for
@@ -193,10 +195,24 @@ module Pod
       end
     end
 
+    # @return [Boolean] Whether the target defines a "module"
+    #         (and thus will need a module map and umbrella header).
+    #
+    # @note   Static library targets can temporarily opt in to this behavior by setting
+    #         `DEFINES_MODULE = YES` in their specification's `pod_target_xcconfig`.
+    #
+    def defines_module?
+      return @defines_module if defined?(@defines_module)
+      return @defines_module = true if uses_swift? || requires_frameworks?
+      return @defines_module = true if target_definitions.any? { |td| td.build_pod_as_module?(pod_name) }
+
+      @defines_module = non_test_specs.any? { |s| s.consumer(platform).pod_target_xcconfig['DEFINES_MODULE'] == 'YES' }
+    end
+
     # @return [Array<Hash{Symbol=>String}>] An array of hashes where each hash represents a single script phase.
     #
     def script_phases
-      spec_consumers.map(&:script_phases).flatten
+      spec_consumers.flat_map(&:script_phases)
     end
 
     # @return [Boolean] Whether the target contains any script phases.
@@ -215,20 +231,16 @@ module Pod
     # @return [Boolean] Whether the target has any tests specifications.
     #
     def contains_test_specifications?
-      specs.any?(&:test_specification?)
+      !test_specs.empty?
     end
 
     # @return [Array<Specification>] All of the test specs within this target.
     #
-    def test_specs
-      specs.select(&:test_specification?)
-    end
+    attr_reader :test_specs
 
-    # @return [Array<Specification>] All of the non test specs within this target.
+    # @return [Array<Specification>] All of the specs within this target that are not test specs.
     #
-    def non_test_specs
-      specs.reject(&:test_specification?)
-    end
+    attr_reader :non_test_specs
 
     # @return [Array<Symbol>] All of the test supported types within this target.
     #
@@ -365,6 +377,20 @@ module Pod
       root_spec.name
     end
 
+    # @return [Pathname] the absolute path of the LLVM module map file that
+    #         defines the module structure for the compiler.
+    #
+    def module_map_path
+      basename = "#{label}.modulemap"
+      if requires_frameworks?
+        super
+      elsif file_accessors.any?(&:module_map)
+        build_headers.root + product_module_name + basename
+      else
+        sandbox.public_headers.root + product_module_name + basename
+      end
+    end
+
     # @param  [String] bundle_name
     #         The name of the bundle product, which is given by the +spec+.
     #
@@ -410,6 +436,15 @@ module Pod
       support_files_dir + "#{test_target_label(test_type)}-frameworks.sh"
     end
 
+    # @param  [Symbol] test_type
+    #         The test type this Info.plist path is for.
+    #
+    # @return [Pathname] The absolute path of the Info.plist for the given test type.
+    #
+    def info_plist_path_for_test_type(test_type)
+      support_files_dir + "#{test_target_label(test_type)}-Info.plist"
+    end
+
     # @return [Pathname] the absolute path of the prefix header file.
     #
     def prefix_header_path
@@ -496,10 +531,8 @@ module Pod
 
       if whitelists.empty?
         @build_config_cache[key] = true
-        true
       elsif whitelists.count == 1
         @build_config_cache[key] = whitelists.first
-        whitelists.first
       else
         raise Informative, "The subspecs of `#{pod_name}` are linked to " \
           "different build configurations for the `#{target_definition}` " \
@@ -567,6 +600,40 @@ module Pod
       [version.major, version.minor, version.patch].join('.')
     end
 
+    # @param [Boolean] include_test_dependent_targets
+    #        whether to include header search paths for test dependent targets
+    #
+    # @return [Array<String>] The set of header search paths this target uses.
+    #
+    def header_search_paths(include_test_dependent_targets = false)
+      header_search_paths = []
+      header_search_paths.concat(build_headers.search_paths(platform, nil, uses_modular_headers?))
+      header_search_paths.concat(sandbox.public_headers.search_paths(platform, pod_name, uses_modular_headers?))
+      dependent_targets = recursive_dependent_targets
+      dependent_targets += recursive_test_dependent_targets if include_test_dependent_targets
+      dependent_targets.each do |dependent_target|
+        header_search_paths.concat(sandbox.public_headers.search_paths(platform, dependent_target.pod_name, defines_module? && dependent_target.uses_modular_headers?(false)))
+      end
+      header_search_paths.uniq
+    end
+
+    protected
+
+    # Returns whether the pod target should use modular headers.
+    #
+    # @param  [Boolean] only_if_defines_modules
+    #         whether the use of modular headers should require the target to define a module
+    #
+    # @note  This must return false when a pod has a `header_mappings_dir`,
+    #        as that allows the spec to completely customize the header structure, and
+    #        therefore it might not be expecting the module name to be prepended
+    #        to imports at all.
+    #
+    def uses_modular_headers?(only_if_defines_modules = true)
+      return false if only_if_defines_modules && !defines_module?
+      spec_consumers.none?(&:header_mappings_dir)
+    end
+
     private
 
     # @param  [TargetDefinition] target_definition