cocoapods 1.2.1 → 1.3.0.beta.1

data/lib/cocoapods/installer.rb

@@ -71,6 +71,7 @@ module Pod
       @lockfile = lockfile
 
       @use_default_plugins = true
+      @has_dependencies = true
     end
 
     # @return [Hash, Boolean, nil] Pods that have been requested to be
@@ -80,6 +81,11 @@ module Pod
     #
     attr_accessor :update
 
+    # @return [Boolean] Whether it has dependencies. Defaults to true.
+    #
+    attr_accessor :has_dependencies
+    alias_method :has_dependencies?, :has_dependencies
+
     # @return [Boolean] Whether the spec repos should be updated.
     #
     attr_accessor :repo_update
@@ -109,9 +115,7 @@ module Pod
       prepare
       resolve_dependencies
       download_dependencies
-      verify_no_duplicate_framework_and_library_names
-      verify_no_static_framework_transitive_dependencies
-      verify_framework_usage
+      validate_targets
       generate_pods_project
       if installation_options.integrate_targets?
         integrate_user_project
@@ -214,7 +218,9 @@ module Pod
     #         generated as result of the analyzer.
     #
     def pod_targets
-      aggregate_targets.map(&:pod_targets).flatten.uniq
+      aggregate_target_pod_targets = aggregate_targets.map(&:pod_targets).flatten
+      test_dependent_targets = aggregate_target_pod_targets.map(&:test_dependent_targets).flatten
+      (aggregate_target_pod_targets + test_dependent_targets).uniq
     end
 
     # @return [Array<Specification>] The specifications that where installed.
@@ -240,6 +246,7 @@ module Pod
     def create_analyzer
       Analyzer.new(sandbox, podfile, lockfile).tap do |analyzer|
         analyzer.installation_options = installation_options
+        analyzer.has_dependencies = has_dependencies?
       end
     end
 
@@ -286,19 +293,11 @@ module Pod
       end
     end
 
-    # TODO: the file accessor should be initialized by the sandbox as they
-    #       created by the Pod source installer as well.
+    # @return [void] In this step we create the file accessors for the pod
+    #                targets.
     #
     def create_file_accessors
-      pod_targets.each do |pod_target|
-        pod_root = sandbox.pod_dir(pod_target.root_spec.name)
-        path_list = Sandbox::PathList.new(pod_root)
-        file_accessors = pod_target.specs.map do |spec|
-          Sandbox::FileAccessor.new(path_list, spec.consumer(pod_target.platform))
-        end
-        pod_target.file_accessors ||= []
-        pod_target.file_accessors.concat(file_accessors)
-      end
+      sandbox.create_file_accessors(pod_targets)
     end
 
     # Downloads, installs the documentation and cleans the sources of the Pods
@@ -393,67 +392,9 @@ module Pod
       end
     end
 
-    def verify_no_duplicate_framework_and_library_names
-      aggregate_targets.each do |aggregate_target|
-        aggregate_target.user_build_configurations.keys.each do |config|
-          pod_targets = aggregate_target.pod_targets_for_build_configuration(config)
-          file_accessors = pod_targets.flat_map(&:file_accessors)
-
-          frameworks = file_accessors.flat_map(&:vendored_frameworks).uniq.map(&:basename)
-          frameworks += pod_targets.select { |pt| pt.should_build? && pt.requires_frameworks? }.map(&:product_module_name)
-          verify_no_duplicate_names(frameworks, aggregate_target.label, 'frameworks')
-
-          libraries = file_accessors.flat_map(&:vendored_libraries).uniq.map(&:basename)
-          libraries += pod_targets.select { |pt| pt.should_build? && !pt.requires_frameworks? }.map(&:product_name)
-          verify_no_duplicate_names(libraries, aggregate_target.label, 'libraries')
-        end
-      end
-    end
-
-    def verify_no_duplicate_names(names, label, type)
-      duplicates = names.map { |n| n.to_s.downcase }.group_by { |f| f }.select { |_, v| v.size > 1 }.keys
-
-      unless duplicates.empty?
-        raise Informative, "The '#{label}' target has " \
-          "#{type} with conflicting names: #{duplicates.to_sentence}."
-      end
-    end
-
-    def verify_no_static_framework_transitive_dependencies
-      aggregate_targets.each do |aggregate_target|
-        next unless aggregate_target.requires_frameworks?
-
-        aggregate_target.user_build_configurations.keys.each do |config|
-          pod_targets = aggregate_target.pod_targets_for_build_configuration(config)
-
-          dependencies = pod_targets.select(&:should_build?).flat_map(&:dependencies)
-          dependended_upon_targets = pod_targets.select { |t| dependencies.include?(t.pod_name) && !t.should_build? }
-
-          static_libs = dependended_upon_targets.flat_map(&:file_accessors).flat_map(&:vendored_static_artifacts)
-          unless static_libs.empty?
-            raise Informative, "The '#{aggregate_target.label}' target has " \
-              "transitive dependencies that include static binaries: (#{static_libs.to_sentence})"
-          end
-        end
-      end
-    end
-
-    def verify_framework_usage
-      aggregate_targets.each do |aggregate_target|
-        next if aggregate_target.requires_frameworks?
-
-        aggregate_target.user_build_configurations.keys.each do |config|
-          pod_targets = aggregate_target.pod_targets_for_build_configuration(config)
-
-          swift_pods = pod_targets.select(&:uses_swift?)
-          unless swift_pods.empty?
-            raise Informative, 'Pods written in Swift can only be integrated as frameworks; ' \
-              'add `use_frameworks!` to your Podfile or target to opt into using it. ' \
-              "The Swift #{swift_pods.size == 1 ? 'Pod being used is' : 'Pods being used are'}: " +
-              swift_pods.map(&:name).to_sentence
-          end
-        end
-      end
+    def validate_targets
+      validator = Xcode::TargetValidator.new(aggregate_targets, pod_targets)
+      validator.validate!
     end
 
     # Runs the registered callbacks for the plugins pre install hooks.

data/lib/cocoapods/installer/analyzer.rb

@@ -45,6 +45,7 @@ module Pod
 
         @update = false
         @allow_pre_downloads = true
+        @has_dependencies = true
       end
 
       # Performs the analysis.
@@ -152,6 +153,15 @@ module Pod
       attr_accessor :allow_pre_downloads
       alias_method :allow_pre_downloads?, :allow_pre_downloads
 
+      # @return [Bool] Whether the analysis has dependencies and thus
+      #         sources must be configured.
+      #
+      # @note   This is used by the `pod lib lint` command to prevent
+      #         update of specs when not needed.
+      #
+      attr_accessor :has_dependencies
+      alias_method :has_dependencies?, :has_dependencies
+
       #-----------------------------------------------------------------------#
 
       private
@@ -313,12 +323,12 @@ module Pod
         end
 
         unless embedded_targets_missing_hosts.empty?
-          embedded_targets_missing_hosts_product_types = embedded_targets_missing_hosts.map(&:user_targets).flatten.map(&:symbol_type).uniq
+          embedded_targets_missing_hosts_product_types = Set.new embedded_targets_missing_hosts.map(&:user_targets).flatten.map(&:symbol_type)
           #  If the targets missing hosts are only frameworks, then this is likely
           #  a project for doing framework development. In that case, just warn that
           #  the frameworks that these targets depend on won't be integrated anywhere
-          if embedded_targets_missing_hosts_product_types == [:framework]
-            UI.warn 'The Podfile contains framework targets, for which the Podfile does not contain host targets (targets which embed the framework).' \
+          if embedded_targets_missing_hosts_product_types.subset?(Set.new([:framework, :static_library]))
+            UI.warn 'The Podfile contains framework or static library targets, for which the Podfile does not contain host targets (targets which embed the framework).' \
               "\n" \
               'If this project is for doing framework development, you can ignore this message. Otherwise, add a target to the Podfile that embeds these frameworks to make this message go away (e.g. a test target).'
           else
@@ -357,7 +367,6 @@ module Pod
       #
       def generate_targets
         specs_by_target = result.specs_by_target.reject { |td, _| td.abstract? }
-        check_pod_target_swift_versions(specs_by_target)
         pod_targets = generate_pod_targets(specs_by_target)
         aggregate_targets = specs_by_target.keys.map do |target_definition|
           generate_target(target_definition, pod_targets)
@@ -419,43 +428,30 @@ module Pod
         end
 
         target.pod_targets = pod_targets.select do |pod_target|
-          pod_target.target_definitions.include?(target_definition)
+          target_definition_included = pod_target.target_definitions.include?(target_definition)
+          explicitly_defined_in_target_definition = target_definition.non_inherited_dependencies.map(&:name).include?(pod_target.name)
+          test_pod_target_only = pod_target_test_only?(pod_target, pod_targets)
+          target_definition_included && (explicitly_defined_in_target_definition || !test_pod_target_only)
         end
 
         target
       end
 
-      # Verify that targets using a pod have the same swift version
+      # Returns true if a pod target is only used by other pod targets as a test dependency and therefore should
+      # not be included as part of the aggregate target.
       #
-      # @param  [Hash{Podfile::TargetDefinition => Array<Specification>}] specs_by_target
-      #         the resolved specifications grouped by target.
+      # @param [PodTarget] pod_target
+      #        the pod target being queried
       #
-      # @note raises Informative if targets using a pod do not have
-      #       the same swift version
+      # @param [Array<PodTarget>] pod_targets
+      #        the array of pod targets to check against
       #
-      def check_pod_target_swift_versions(specs_by_target)
-        targets_by_spec = {}
-        specs_by_target.each do |target, specs|
-          specs.each do |spec|
-            (targets_by_spec[spec] ||= []) << target
-          end
-        end
-
-        error_message_for_target = lambda do |target|
-          "#{target.name} (Swift #{target.swift_version})"
-        end
-
-        error_messages = targets_by_spec.map do |spec, targets|
-          swift_targets = targets.reject { |target| target.swift_version.blank? }
-          next if swift_targets.empty? || swift_targets.uniq(&:swift_version).count == 1
-          target_errors = swift_targets.map(&error_message_for_target).join(', ')
-          "- #{spec.name} required by #{target_errors}"
-        end.compact
-
-        unless error_messages.empty?
-          raise Informative, 'The following pods are integrated into targets ' \
-            "that do not have the same Swift version:\n\n#{error_messages.join("\n")}"
-        end
+      # @return [Boolean] if the pod target is only referenced from test dependencies.
+      #
+      def pod_target_test_only?(pod_target, pod_targets)
+        source = pod_targets.any? { |pt| pt.dependent_targets.map(&:name).include?(pod_target.name) }
+        test = pod_targets.any? { |pt| pt.test_dependent_targets.map(&:name).include?(pod_target.name) }
+        !source && test
       end
 
       # Setup the pod targets for an aggregate target. Deduplicates resulting
@@ -492,15 +488,10 @@ module Pod
             hash[name] = values.sort_by { |pt| pt.specs.count }
           end
           pod_targets.each do |target|
-            dependencies = transitive_dependencies_for_specs(target.specs, target.platform, all_specs).group_by(&:root)
-            target.dependent_targets = dependencies.map do |root_spec, deps|
-              pod_targets_by_name[root_spec.name].find do |t|
-                next false if t.platform.symbolic_name != target.platform.symbolic_name ||
-                    t.requires_frameworks? != target.requires_frameworks?
-                spec_names = t.specs.map(&:name)
-                deps.all? { |dep| spec_names.include?(dep.name) }
-              end
-            end
+            dependencies = transitive_dependencies_for_specs(target.specs.reject(&:test_specification?), target.platform, all_specs).group_by(&:root)
+            test_dependencies = transitive_dependencies_for_specs(target.specs.select(&:test_specification?), target.platform, all_specs).group_by(&:root)
+            target.dependent_targets = filter_dependencies(dependencies, pod_targets_by_name, target)
+            target.test_dependent_targets = filter_dependencies(test_dependencies, pod_targets_by_name, target)
           end
         else
           dedupe_cache = {}
@@ -512,12 +503,25 @@ module Pod
 
             pod_targets.each do |target|
               dependencies = transitive_dependencies_for_specs(target.specs, target.platform, specs).group_by(&:root)
+              test_dependencies = transitive_dependencies_for_specs(target.specs.select(&:test_specification?), target.platform, all_specs).group_by(&:root)
               target.dependent_targets = pod_targets.reject { |t| dependencies[t.root_spec].nil? }
+              target.test_dependent_targets = pod_targets.reject { |t| test_dependencies[t.root_spec].nil? }
             end
           end
         end
       end
 
+      def filter_dependencies(dependencies, pod_targets_by_name, target)
+        dependencies.map do |root_spec, deps|
+          pod_targets_by_name[root_spec.name].find do |t|
+            next false if t.platform.symbolic_name != target.platform.symbolic_name ||
+                t.requires_frameworks? != target.requires_frameworks?
+            spec_names = t.specs.map(&:name)
+            deps.all? { |dep| spec_names.include?(dep.name) }
+          end
+        end
+      end
+
       # Returns the specs upon which the given specs _transitively_ depend.
       #
       # @note: This is implemented in the analyzer, because we don't have to
@@ -819,11 +823,11 @@ module Pod
 
           # 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?
+          elsif has_dependencies? && sources.empty?
             sources = ['https://github.com/CocoaPods/Specs.git']
           else
             sources += dependency_sources

data/lib/cocoapods/installer/xcode.rb

@@ -2,6 +2,7 @@ module Pod
   class Installer
     class Xcode
       autoload :PodsProjectGenerator, 'cocoapods/installer/xcode/pods_project_generator'
+      autoload :TargetValidator, 'cocoapods/installer/xcode/target_validator'
     end
   end
 end

data/lib/cocoapods/installer/xcode/pods_project_generator.rb

@@ -86,6 +86,11 @@ module Pod
           development_pod_targets.select(&:should_build?).each do |pod_target|
             next unless share_scheme_for_development_pod?(pod_target.pod_name)
             Xcodeproj::XCScheme.share_scheme(project.path, pod_target.label)
+            if pod_target.contains_test_specifications?
+              pod_target.supported_test_types.each do |test_type|
+                Xcodeproj::XCScheme.share_scheme(project.path, pod_target.test_target_label(test_type))
+              end
+            end
           end
         end
 
@@ -203,16 +208,10 @@ module Pod
               aggregate_target.native_target.add_dependency(pod_target.native_target)
               configure_app_extension_api_only_for_target(pod_target) if is_app_extension
 
-              pod_target.dependent_targets.each do |pod_dependency_target|
-                next unless pod_dependency_target.should_build?
-                pod_target.native_target.add_dependency(pod_dependency_target.native_target)
-                configure_app_extension_api_only_for_target(pod_dependency_target) if is_app_extension
+              add_dependent_targets_to_native_target(pod_target.dependent_targets, pod_target.native_target, is_app_extension, pod_target.requires_frameworks?, frameworks_group)
 
-                if pod_target.requires_frameworks?
-                  product_ref = frameworks_group.files.find { |f| f.path == pod_dependency_target.product_name } ||
-                    frameworks_group.new_product_ref_for_target(pod_dependency_target.product_basename, pod_dependency_target.product_type)
-                  pod_target.native_target.frameworks_build_phase.add_file_reference(product_ref, true)
-                end
+              pod_target.test_native_targets.each do |test_native_target|
+                add_dependent_targets_to_native_target([pod_target, *pod_target.test_dependent_targets], test_native_target, false, pod_target.requires_frameworks?, frameworks_group)
               end
             end
           end
@@ -251,6 +250,20 @@ module Pod
 
         private
 
+        def add_dependent_targets_to_native_target(dependent_targets, native_target, is_app_extension, requires_frameworks, frameworks_group)
+          dependent_targets.each do |pod_dependency_target|
+            next unless pod_dependency_target.should_build?
+            native_target.add_dependency(pod_dependency_target.native_target)
+            configure_app_extension_api_only_for_target(pod_dependency_target) if is_app_extension
+
+            if requires_frameworks
+              product_ref = frameworks_group.files.find { |f| f.path == pod_dependency_target.product_name } ||
+                  frameworks_group.new_product_ref_for_target(pod_dependency_target.product_basename, pod_dependency_target.product_type)
+              native_target.frameworks_build_phase.add_file_reference(product_ref, true)
+            end
+          end
+        end
+
         # Sets the APPLICATION_EXTENSION_API_ONLY build setting to YES for all
         # configurations of the given target
         #

data/lib/cocoapods/installer/xcode/pods_project_generator/aggregate_target_installer.rb

@@ -158,18 +158,24 @@ module Pod
           #
           def create_embed_frameworks_script
             path = target.embed_frameworks_script_path
-            frameworks_by_config = {}
+            frameworks_and_dsyms_by_config = {}
             target.user_build_configurations.keys.each do |config|
               relevant_pod_targets = target.pod_targets.select do |pod_target|
                 pod_target.include_in_build_config?(target_definition, config)
               end
-              frameworks_by_config[config] = relevant_pod_targets.flat_map do |pod_target|
-                frameworks = pod_target.file_accessors.flat_map(&:vendored_dynamic_artifacts).map { |fw| "${PODS_ROOT}/#{fw.relative_path_from(sandbox.root)}" }
-                frameworks << pod_target.build_product_path('$BUILT_PRODUCTS_DIR') if pod_target.should_build? && pod_target.requires_frameworks?
+              frameworks_and_dsyms_by_config[config] = relevant_pod_targets.flat_map do |pod_target|
+                frameworks = pod_target.file_accessors.flat_map(&:vendored_dynamic_artifacts).map do |fw|
+                  path_to_framework = "${PODS_ROOT}/#{fw.relative_path_from(sandbox.root)}"
+                  # Until this can be configured, assume the dSYM file uses the file name as the framework.
+                  # See https://github.com/CocoaPods/CocoaPods/issues/1698
+                  { :framework => path_to_framework, :dSYM => "#{path_to_framework}.dSYM" }
+                end
+                # For non vendored frameworks Xcode will generate the dSYM and copy it instead.
+                frameworks << { :framework => pod_target.build_product_path('$BUILT_PRODUCTS_DIR'), :dSYM => nil } if pod_target.should_build? && pod_target.requires_frameworks?
                 frameworks
               end
             end
-            generator = Generator::EmbedFrameworksScript.new(frameworks_by_config)
+            generator = Generator::EmbedFrameworksScript.new(frameworks_and_dsyms_by_config)
             generator.save_as(path)
             add_file_to_support_group(path)
           end

data/lib/cocoapods/installer/xcode/pods_project_generator/pod_target_installer.rb

@@ -18,20 +18,24 @@ module Pod
 
             UI.message "- Installing target `#{target.name}` #{target.platform}" do
               add_target
+              add_test_targets if target.contains_test_specifications?
               create_support_files_dir
               add_resources_bundle_targets
               add_files_to_build_phases
               create_xcconfig_file
+              create_test_xcconfig_files if target.contains_test_specifications?
               if target.requires_frameworks?
                 create_info_plist_file
                 create_module_map
                 create_umbrella_header do |generator|
+                  file_accessors = target.file_accessors
+                  file_accessors = file_accessors.reject { |f| f.spec.test_specification? } if target.contains_test_specifications?
                   generator.imports += if header_mappings_dir
-                                         target.file_accessors.flat_map(&:public_headers).map do |pathname|
+                                         file_accessors.flat_map(&:public_headers).map do |pathname|
                                            pathname.relative_path_from(header_mappings_dir)
                                          end
                                        else
-                                         target.file_accessors.flat_map(&:public_headers).map(&:basename)
+                                         file_accessors.flat_map(&:public_headers).map(&:basename)
                                        end
                 end
                 create_build_phase_to_symlink_header_folders
@@ -59,6 +63,8 @@ module Pod
             settings['CODE_SIGN_IDENTITY[sdk=iphoneos*]'] = ''
             settings['CODE_SIGN_IDENTITY[sdk=watchos*]'] = ''
 
+            settings['SWIFT_ACTIVE_COMPILATION_CONDITIONS'] = '$(inherited) '
+
             if target.swift_version
               settings['SWIFT_VERSION'] = target.swift_version
             end
@@ -128,6 +134,7 @@ module Pod
             target.file_accessors.each do |file_accessor|
               consumer = file_accessor.spec_consumer
 
+              native_target = target.native_target_for_spec(consumer.spec)
               headers = file_accessor.headers
               public_headers = file_accessor.public_headers
               private_headers = file_accessor.private_headers
@@ -145,7 +152,7 @@ module Pod
 
               header_file_refs = project_file_references_array(headers, 'header')
               native_target.add_file_references(header_file_refs) do |build_file|
-                add_header(build_file, public_headers, private_headers)
+                add_header(build_file, public_headers, private_headers, native_target)
               end
 
               other_file_refs = other_source_files.map { |sf| project.reference_for_path(sf) }
@@ -160,6 +167,39 @@ module Pod
             end
           end
 
+          # Adds the test targets for the library to the Pods project with the
+          # appropriate build configurations.
+          #
+          # @return [void]
+          #
+          def add_test_targets
+            target.supported_test_types.each do |test_type|
+              product_type = target.product_type_for_test_type(test_type)
+              name = target.test_target_label(test_type)
+              platform = target.platform.name
+              language = target.uses_swift? ? :swift : :objc
+              native_test_target = project.new_target(product_type, name, platform, deployment_target, nil, language)
+              native_test_target.product_reference.name = name
+
+              target.user_build_configurations.each do |bc_name, type|
+                native_test_target.add_build_configuration(bc_name, type)
+              end
+
+              native_test_target.build_configurations.each do |configuration|
+                configuration.build_settings.merge!(custom_build_settings)
+                # target_installer will automatically add an empty `OTHER_LDFLAGS`. For test
+                # targets those are set via a test xcconfig file instead.
+                configuration.build_settings.delete('OTHER_LDFLAGS')
+                # target_installer will automatically set the product name to the module name if the target
+                # requires frameworks. For tests we always use the test target name as the product name
+                # irrelevant to whether we use frameworks or not.
+                configuration.build_settings['PRODUCT_NAME'] = name
+              end
+
+              target.test_native_targets << native_test_target
+            end
+          end
+
           # Adds the resources of the Pods to the Pods project.
           #
           # @note   The source files are grouped by Pod and in turn by subspec
@@ -184,6 +224,7 @@ module Pod
                   bundle_target.add_resources(resource_phase_refs + compile_phase_refs)
                 end
 
+                native_target = target.native_target_for_spec(file_accessor.spec_consumer.spec)
                 target.user_build_configurations.each do |bc_name, type|
                   bundle_target.add_build_configuration(bc_name, type)
                 end
@@ -219,7 +260,7 @@ module Pod
                     :watchos => '1,2' # The device family for watchOS is 4, but Xcode creates watchkit-compatible bundles as 1,2
                   }
 
-                  if family = device_family_by_platform[target.platform.name]
+                  if (family = device_family_by_platform[target.platform.name])
                     c.build_settings['TARGETED_DEVICE_FAMILY'] = family
                   end
                 end
@@ -249,6 +290,38 @@ module Pod
             end
           end
 
+          # Generates the contents of the xcconfig file used for each test target type and saves it to disk.
+          #
+          # @return [void]
+          #
+          def create_test_xcconfig_files
+            target.supported_test_types.each do |test_type|
+              path = target.xcconfig_path(test_type.to_s)
+              xcconfig_gen = Generator::XCConfig::PodXCConfig.new(target, true)
+              xcconfig_gen.save_as(path)
+              xcconfig_file_ref = add_file_to_support_group(path)
+
+              target.test_native_targets.each do |test_target|
+                test_target.build_configurations.each do |test_target_bc|
+                  test_target_swift_debug_hack(test_target_bc)
+                  test_target_bc.base_configuration_reference = xcconfig_file_ref
+                end
+              end
+            end
+          end
+
+          # Manually add `libswiftSwiftOnoneSupport.dylib` as it seems there is an issue with tests that do not include it for Debug configurations.
+          # Possibly related to Swift module optimization.
+          #
+          # @return [void]
+          #
+          def test_target_swift_debug_hack(test_target_bc)
+            return unless test_target_bc.debug?
+            return unless [target, *target.recursive_dependent_targets].any?(&:uses_swift?)
+            ldflags = test_target_bc.build_settings['OTHER_LDFLAGS'] ||= '$(inherited)'
+            ldflags << ' -lswiftSwiftOnoneSupport'
+          end
+
           # Creates a build phase which links the versioned header folders
           # of the OS X into the framework bundle's root root directory.
           # This is only necessary because the way how headers are copied
@@ -398,7 +471,7 @@ module Pod
                                    end
           end
 
-          def add_header(build_file, public_headers, private_headers)
+          def add_header(build_file, public_headers, private_headers, native_target)
             file_ref = build_file.file_ref
             acl = if public_headers.include?(file_ref.real_path)
                     'Public'