cocoapods 1.0.0 → 1.1.0

data/lib/cocoapods/downloader.rb

@@ -33,11 +33,16 @@ module Pod
       cache_path: Config.instance.cache_root + 'Pods'
     )
       can_cache &&= !Config.instance.skip_download_cache
+
+      request = preprocess_request(request)
+
       if can_cache
         raise ArgumentError, 'Must provide a `cache_path` when caching.' unless cache_path
         cache = Cache.new(cache_path)
         result = cache.download_pod(request)
       else
+        raise ArgumentError, 'Must provide a `target` when caching is disabled.' unless target
+
         require 'cocoapods/installer/pod_source_preparer'
         result, = download_request(request, target)
         Installer::PodSourcePreparer.new(result.spec, result.location).prepare!
@@ -110,6 +115,21 @@ module Pod
       end
     end
 
+    # Return a new request after preprocessing by the downloader
+    #
+    # @param  [Request] request
+    #         the request that needs preprocessing
+    #
+    # @return [Request] the preprocessed request
+    #
+    def self.preprocess_request(request)
+      Request.new(
+        :spec => request.spec,
+        :released => request.released_pod?,
+        :name => request.name,
+        :params => Downloader.preprocess_options(request.params))
+    end
+
     public
 
     class DownloaderError; include CLAide::InformativeError; end

data/lib/cocoapods/executable.rb

@@ -108,7 +108,7 @@ module Pod
     #
     def self.which!(program)
       which(program).tap do |bin|
-        raise Informative, "Unable to locate the executable `#{executable}`" unless bin
+        raise Informative, "Unable to locate the executable `#{program}`" unless bin
       end
     end
 

data/lib/cocoapods/gem_version.rb

@@ -1,5 +1,5 @@
 module Pod
   # The version of the CocoaPods command line tool.
   #
-  VERSION = '1.0.0'.freeze unless defined? Pod::VERSION
+  VERSION = '1.1.0'.freeze unless defined? Pod::VERSION
 end

data/lib/cocoapods/generator/acknowledgements/plist.rb

@@ -33,11 +33,14 @@ module Pod
 
       def hash_for_spec(spec)
         if (license = license_text(spec))
-          {
+          hash =  {
             :Type => 'PSGroupSpecifier',
             :Title => sanitize_encoding(spec.name),
             :FooterText => sanitize_encoding(license),
           }
+          hash[:License] = sanitize_encoding(spec.license[:type]) if spec.license[:type]
+
+          hash
         end
       end
 

data/lib/cocoapods/generator/copy_resources_script.rb

@@ -119,12 +119,6 @@ case "${TARGETED_DEVICE_FAMILY}" in
     ;;
 esac
 
-realpath() {
-  DIRECTORY="$(cd "${1%/*}" && pwd)"
-  FILENAME="${1##*/}"
-  echo "$DIRECTORY/$FILENAME"
-}
-
 install_resource()
 {
   if [[ "$1" = /* ]] ; then
@@ -144,8 +138,8 @@ EOM
       ibtool --reference-external-strings-file --errors --warnings --notices --minimum-deployment-target ${!DEPLOYMENT_TARGET_SETTING_NAME} --output-format human-readable-text --compile "${TARGET_BUILD_DIR}/${UNLOCALIZED_RESOURCES_FOLDER_PATH}/`basename \\"$RESOURCE_PATH\\" .storyboard`.storyboardc" "$RESOURCE_PATH" --sdk "${SDKROOT}" ${TARGET_DEVICE_ARGS}
       ;;
     *\.xib)
-      echo "ibtool --reference-external-strings-file --errors --warnings --notices --minimum-deployment-target ${!DEPLOYMENT_TARGET_SETTING_NAME} --output-format human-readable-text --compile ${TARGET_BUILD_DIR}/${UNLOCALIZED_RESOURCES_FOLDER_PATH}/`basename \\"$RESOURCE_PATH\\" .xib`.nib $RESOURCE_PATH --sdk ${SDKROOT}"
-      ibtool --reference-external-strings-file --errors --warnings --notices --minimum-deployment-target ${!DEPLOYMENT_TARGET_SETTING_NAME} --output-format human-readable-text --compile "${TARGET_BUILD_DIR}/${UNLOCALIZED_RESOURCES_FOLDER_PATH}/`basename \\"$RESOURCE_PATH\\" .xib`.nib" "$RESOURCE_PATH" --sdk "${SDKROOT}"
+      echo "ibtool --reference-external-strings-file --errors --warnings --notices --minimum-deployment-target ${!DEPLOYMENT_TARGET_SETTING_NAME} --output-format human-readable-text --compile ${TARGET_BUILD_DIR}/${UNLOCALIZED_RESOURCES_FOLDER_PATH}/`basename \\"$RESOURCE_PATH\\" .xib`.nib $RESOURCE_PATH --sdk ${SDKROOT} ${TARGET_DEVICE_ARGS}"
+      ibtool --reference-external-strings-file --errors --warnings --notices --minimum-deployment-target ${!DEPLOYMENT_TARGET_SETTING_NAME} --output-format human-readable-text --compile "${TARGET_BUILD_DIR}/${UNLOCALIZED_RESOURCES_FOLDER_PATH}/`basename \\"$RESOURCE_PATH\\" .xib`.nib" "$RESOURCE_PATH" --sdk "${SDKROOT}" ${TARGET_DEVICE_ARGS}
       ;;
     *.framework)
       echo "mkdir -p ${TARGET_BUILD_DIR}/${FRAMEWORKS_FOLDER_PATH}"
@@ -166,7 +160,7 @@ EOM
       xcrun mapc "$RESOURCE_PATH" "${TARGET_BUILD_DIR}/${UNLOCALIZED_RESOURCES_FOLDER_PATH}/`basename "$RESOURCE_PATH" .xcmappingmodel`.cdm"
       ;;
     *.xcassets)
-      ABSOLUTE_XCASSET_FILE=$(realpath "$RESOURCE_PATH")
+      ABSOLUTE_XCASSET_FILE="$RESOURCE_PATH"
       XCASSET_FILES+=("$ABSOLUTE_XCASSET_FILE")
       ;;
     *)
@@ -195,7 +189,7 @@ then
   # Find all other xcassets (this unfortunately includes those of path pods and other targets).
   OTHER_XCASSETS=$(find "$PWD" -iname "*.xcassets" -type d)
   while read line; do
-    if [[ $line != "`realpath $PODS_ROOT`*" ]]; then
+    if [[ $line != "${PODS_ROOT}*" ]]; then
       XCASSET_FILES+=("$line")
     fi
   done <<<"$OTHER_XCASSETS"

data/lib/cocoapods/generator/header.rb

@@ -40,8 +40,9 @@ module Pod
       #
       def generate
         result = ''
+        result << "#ifdef __OBJC__\n"
         result << generate_platform_import_header
-
+        result << "#endif\n"
         result << "\n"
 
         imports.each do |import|

data/lib/cocoapods/generator/prefix_header.rb

@@ -55,18 +55,6 @@ module Pod
 
         result
       end
-
-      protected
-
-      # Generates the contents of the header according to the platform.
-      #
-      # @return [String]
-      #
-      def generate_platform_import_header
-        result =  "#ifdef __OBJC__\n"
-        result << super
-        result << "#endif\n"
-      end
     end
   end
 end

data/lib/cocoapods/generator/xcconfig/aggregate_xcconfig.rb

@@ -4,7 +4,7 @@ module Pod
       # Generates the xcconfigs for the aggregate targets.
       #
       class AggregateXCConfig
-        # @return [Target] the target represented by this xcconfig.
+        # @return [AggregateTarget] the target represented by this xcconfig.
         #
         attr_reader :target
 
@@ -60,10 +60,8 @@ module Pod
             'GCC_PREPROCESSOR_DEFINITIONS' => '$(inherited) COCOAPODS=1',
             'FRAMEWORK_SEARCH_PATHS' => '$(inherited) ',
             'LIBRARY_SEARCH_PATHS' => '$(inherited) ',
-          }
-          if pod_targets.any?(&:uses_swift?)
-            config['EMBEDDED_CONTENT_CONTAINS_SWIFT'] = 'YES'
-          end
+          }.merge(embedded_content_settings)
+
           @xcconfig = Xcodeproj::Config.new(config)
 
           @xcconfig.merge!(merged_user_target_xcconfigs)
@@ -90,6 +88,41 @@ module Pod
 
         protected
 
+        def target_swift_version
+          settings = target.native_target.resolved_build_setting('SWIFT_VERSION') unless target.native_target.nil?
+          settings.values.compact.uniq.first unless settings.nil?
+        end
+
+        EMBED_STANDARD_LIBRARIES_MINIMUM_VERSION = Gem::Version.new('2.3')
+
+        # @return [Hash<String, String>] the build settings necessary for Swift
+        #  targets to be correctly embedded in their host.
+        #
+        def embedded_content_settings
+          # For embedded targets, which live in a host target, CocoaPods
+          # copies all of the embedded target's pod_targets its host
+          # target. Therefore, this check will properly require the Swift
+          # libs in the host target, if the embedded target has any pod targets
+          # that use Swift. Setting this for the embedded target would
+          # cause an App Store rejection because frameworks cannot be embedded
+          # in embedded targets.
+
+          swift_version = Gem::Version.new(target_swift_version)
+          should_embed = !target.requires_host_target? && pod_targets.any?(&:uses_swift?)
+          embed_value = should_embed ? 'YES' : 'NO'
+
+          config = {
+            'ALWAYS_EMBED_SWIFT_STANDARD_LIBRARIES' => embed_value,
+            'EMBEDDED_CONTENT_CONTAINS_SWIFT' => embed_value,
+          }
+
+          if swift_version >= EMBED_STANDARD_LIBRARIES_MINIMUM_VERSION || !should_embed
+            config.delete('EMBEDDED_CONTENT_CONTAINS_SWIFT')
+          end
+
+          config
+        end
+
         # @return [Hash<String, String>] the build settings necessary to import
         #         the pod targets.
         #

data/lib/cocoapods/generator/xcconfig/xcconfig_helper.rb

@@ -1,3 +1,5 @@
+require 'active_support/core_ext/object/try'
+
 module Pod
   module Generator
     module XCConfig
@@ -283,9 +285,9 @@ module Pod
         #
         def self.add_language_specific_settings(target, xcconfig)
           if target.uses_swift?
-            build_settings = {
-              'OTHER_SWIFT_FLAGS' => '$(inherited) ' + quote(%w(-D COCOAPODS)),
-            }
+            other_swift_flags = ['$(inherited)', quote(%w(-D COCOAPODS))]
+            other_swift_flags << quote(%w(-suppress-warnings)) if target.try(:inhibit_warnings?)
+            build_settings = { 'OTHER_SWIFT_FLAGS' => other_swift_flags.join(' ') }
             xcconfig.merge!(build_settings)
           end
         end
@@ -314,7 +316,6 @@ module Pod
                 search_paths << search_path
               end
             end
-            search_paths
           end
         end
 

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

@@ -23,7 +23,11 @@ module Pod
         #
         def scope_suffixes
           return { variants.first => nil } if variants.count == 1
-          scope_by_specs
+          Hash[scope_by_specs.map do |variant, scope|
+            require 'digest'
+            scope = Digest::MD5.hexdigest(scope)[0..7] if !scope.nil? && scope.length >= 50
+            [variant, scope]
+          end]
         end
 
         # Groups the collection by result of the block.

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

@@ -44,6 +44,7 @@ module Pod
           result.platform = compute_platform(targets)
           result.archs = compute_archs(targets)
           result.project = user_project
+          result.target_definition.swift_version = compute_swift_version_from_targets(targets)
           result
         end
 
@@ -72,7 +73,7 @@ module Pod
             else
               raise Informative, 'Could not automatically select an Xcode project. ' \
                 "Specify one in your Podfile like so:\n\n" \
-                "    xcodeproj 'path/to/Project.xcodeproj'\n"
+                "    project 'path/to/Project.xcodeproj'\n"
             end
           end
           path
@@ -205,6 +206,28 @@ module Pod
             end
           end
         end
+
+        # Compute the Swift version for the target build configurations. If more
+        # than one Swift version is defined for a given target, then it will raise.
+        #
+        # @param  [Array<PBXNativeTarget>] targets
+        #         the targets that are checked for Swift versions.
+        #
+        # @return [String] the targets Swift version or nil
+        #
+        def compute_swift_version_from_targets(targets)
+          versions = targets.flat_map do |target|
+            target.resolved_build_setting('SWIFT_VERSION').values
+          end.flatten.compact.uniq
+          case versions.count
+          when 0
+            nil
+          when 1
+            versions.first
+          else
+            raise Informative, 'There may only be up to 1 unique SWIFT_VERSION per target.'
+          end
+        end
       end
     end
   end

data/lib/cocoapods/installer/analyzer.rb

@@ -226,16 +226,142 @@ module Pod
 
       private
 
+      # Copies the pod_targets of any of the app embedded aggregate targets into
+      # their potential host aggregate target, if that potential host aggregate target's
+      # user_target hosts any of the app embedded aggregate targets' user_targets
+      #
+      # @param  [AggregateTarget] aggregate_target the aggregate target whose user_target
+      #         might host one or more of the embedded aggregate targets' user_targets
+      #
+      # @param  [Array<AggregateTarget>] embedded_aggregate_targets the aggregate targets
+      #         representing the embedded targets to be integrated
+      #
+      def copy_embedded_target_pod_targets_to_host(aggregate_target, embedded_aggregate_targets)
+        return if aggregate_target.requires_host_target?
+        # Get the uuids of the aggregate_target's user_targets' embedded targets if any
+        embedded_uuids = Set.new(aggregate_target.user_targets.map do |target|
+          aggregate_target.user_project.embedded_targets_in_native_target(target).map(&:uuid)
+        end.flatten)
+        return if embedded_uuids.empty?
+        embedded_aggregate_targets.each do |embedded_target|
+          next unless embedded_target.user_targets.map(&:uuid).any? do |embedded_uuid|
+            embedded_uuids.include? embedded_uuid
+          end
+          pod_target_names = aggregate_target.pod_targets.map(&:name)
+          # This embedded target is hosted by the aggregate target's user_target; copy over the non-duplicate pod_targets
+          aggregate_target.pod_targets = aggregate_target.pod_targets + embedded_target.pod_targets.select do |pod_target|
+            !pod_target_names.include? pod_target.name
+          end
+        end
+      end
+
+      # Raises an error if there are embedded targets in the Podfile, but
+      # their host targets have not been declared in the Podfile. As it
+      # finds host targets, it collection information on host target types.
+      #
+      # @param  [Array<AggregateTarget>] aggregate_targets the generated
+      #         aggregate targets
+      #
+      # @param  [Array<AggregateTarget>] embedded_aggregate_targets the aggregate targets
+      #         representing the embedded targets to be integrated
+      #
+      def analyze_host_targets_in_podfile(aggregate_targets, embedded_aggregate_targets)
+        target_definitions_by_uuid = {}
+        # Collect aggregate target definitions by uuid to later lookup host target
+        # definitions and verify their compatiblity with their embedded targets
+        aggregate_targets.each do |target|
+          target.user_targets.map(&:uuid).each do |uuid|
+            target_definitions_by_uuid[uuid] = target.target_definition
+          end
+        end
+        aggregate_target_user_projects = aggregate_targets.map(&:user_project)
+        embedded_targets_missing_hosts = []
+        host_uuid_to_embedded_target_definitions = {}
+        # Search all of the known user projects for each embedded target's hosts
+        embedded_aggregate_targets.each do |target|
+          host_uuids = []
+          aggregate_target_user_projects.product(target.user_targets).each do |user_project, user_target|
+            host_uuids += user_project.host_targets_for_embedded_target(user_target).map(&:uuid)
+          end
+          # For each host, keep track of its embedded target definitions
+          # to later verify each embedded target's compatiblity with its host,
+          # ignoring the hosts that aren't known to CocoaPods (no target
+          # definitions in the Podfile)
+          host_uuids.each do |uuid|
+            (host_uuid_to_embedded_target_definitions[uuid] ||= []) << target.target_definition if target_definitions_by_uuid.key? uuid
+          end
+          # If none of the hosts are known to CocoaPods (no target definitions
+          # in the Podfile), add it to the list of targets missing hosts
+          embedded_targets_missing_hosts << target unless host_uuids.any? do |uuid|
+            target_definitions_by_uuid.key? uuid
+          end
+        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
+          #  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).' \
+              "\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
+            target_names = embedded_targets_missing_hosts.map do |target|
+              target.name.sub('Pods-', '') # Make the target names more recognizable to the user
+            end.join ', '
+            raise Informative, "Unable to find host target(s) for #{target_names}. Please add the host targets for the embedded targets to the Podfile." \
+                                "\n" \
+                                'Certain kinds of targets require a host target. A host target is a "parent" target which embeds a "child" target. These are example types of targets that need a host target:' \
+                                "\n- Framework" \
+                                "\n- App Extension" \
+                                "\n- Watch OS 1 Extension" \
+                                "\n- Messages Extension (except when used with a Messages Application)"
+          end
+        end
+
+        target_mismatches = []
+        check_prop = lambda do |target_definition1, target_definition2, attr, msg|
+          attr1 = target_definition1.send(attr)
+          attr2 = target_definition2.send(attr)
+          if attr1 != attr2
+            target_mismatches << "- #{target_definition1.name} (#{attr1}) and #{target_definition2.name} (#{attr2}) #{msg}."
+          end
+        end
+        host_uuid_to_embedded_target_definitions.each do |uuid, target_definitions|
+          host_target_definition = target_definitions_by_uuid[uuid]
+          target_definitions.each do |target_definition|
+            check_prop.call(host_target_definition, target_definition, :platform, 'do not use the same platform')
+            check_prop.call(host_target_definition, target_definition, :uses_frameworks?, 'do not both set use_frameworks!')
+            check_prop.call(host_target_definition, target_definition, :swift_version, 'do not use the same Swift version')
+          end
+        end
+
+        unless target_mismatches.empty?
+          heading = 'Unable to integrate the following embedded targets with their respective host targets (a host target is a "parent" target which embeds a "child" target like a framework or extension):'
+          raise Informative, heading + "\n\n" + target_mismatches.sort.uniq.join("\n")
+        end
+      end
+
       # Creates the models that represent the targets generated by CocoaPods.
       #
       # @return [Array<AggregateTarget>]
       #
       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)
         end
+        if installation_options.integrate_targets?
+          # Copy embedded target pods that cannot have their pods embedded as frameworks to their host targets
+          embedded_targets = aggregate_targets.select(&:requires_host_target?).select(&:requires_frameworks?)
+          analyze_host_targets_in_podfile(aggregate_targets, embedded_targets)
+          aggregate_targets.each do |target|
+            copy_embedded_target_pod_targets_to_host(target, embedded_targets)
+          end
+        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)
@@ -277,11 +403,45 @@ module Pod
         target.pod_targets = pod_targets.select do |pod_target|
           pod_target.target_definitions.include?(target_definition)
         end
+
         target
       end
 
+      # Verify that targets using a pod have the same swift version
+      #
+      # @param  [Hash{Podfile::TargetDefinition => Array<Specification>}] specs_by_target
+      #         the resolved specifications grouped by target.
+      #
+      # @note raises Informative if targets using a pod do not have
+      #       the same swift version
+      #
+      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
+      end
+
       # Setup the pod targets for an aggregate target. Deduplicates resulting
-      # targets by grouping by grouping by platform and subspec by their root
+      # targets by grouping by platform and subspec by their root
       # to create a {PodTarget} for each spec.
       #
       # @param  [Hash{Podfile::TargetDefinition => Array<Specification>}] specs_by_target

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

@@ -11,7 +11,7 @@ module Pod
 
         # @return [String] the PACKAGE emoji to use as prefix for every build phase aded to the user project
         #
-        BUILD_PHASE_PREFIX = "\u{1F4E6} ".freeze
+        BUILD_PHASE_PREFIX = '[CP] '.freeze
 
         # @return [String] the name of the check manifest phase
         #
@@ -20,7 +20,12 @@ module Pod
         # @return [Array<Symbol>] the symbol types, which require that the pod
         # frameworks are embedded in the output directory / product bundle.
         #
-        EMBED_FRAMEWORK_TARGET_TYPES = [:application, :unit_test_bundle, :app_extension, :watch_extension, :watch2_extension].freeze
+        # @note This does not include :app_extension or :watch_extension because
+        # these types must have their frameworks embedded in their host targets.
+        # For messages extensions, this only applies if it's embedded in a messages
+        # application.
+        #
+        EMBED_FRAMEWORK_TARGET_TYPES = [:application, :unit_test_bundle, :ui_test_bundle, :watch2_extension, :messages_application].freeze
 
         # @return [String] the name of the embed frameworks phase
         #
@@ -54,6 +59,7 @@ module Pod
 
             add_pods_library
             add_embed_frameworks_script_phase
+            remove_embed_frameworks_script_phase_from_embedded_targets
             add_copy_resources_script_phase
             add_check_manifest_lock_script_phase
           end
@@ -110,6 +116,21 @@ module Pod
           end
         end
 
+        # Removes the embed frameworks build phase from embedded targets
+        #
+        # @note Older versions of CocoaPods would add this build phase to embedded
+        #       targets. They should be removed on upgrade because embedded targets
+        #       will have their frameworks embedded in their host targets.
+        #
+        def remove_embed_frameworks_script_phase_from_embedded_targets
+          return unless target.requires_host_target?
+          native_targets.each do |native_target|
+            if AggregateTarget::EMBED_FRAMEWORKS_IN_HOST_TARGET_TYPES.include? native_target.symbol_type
+              remove_embed_frameworks_script_phase(native_target)
+            end
+          end
+        end
+
         def add_embed_frameworks_script_phase_to_target(native_target)
           phase = create_or_update_build_phase(native_target, EMBED_FRAMEWORK_PHASE_NAME)
           script_path = target.embed_frameworks_script_relative_path
@@ -121,7 +142,7 @@ module Pod
         # @param [PBXNativeTarget] native_target
         #
         def remove_embed_frameworks_script_phase(native_target)
-          embed_build_phase = native_target.shell_script_build_phases.find { |bp| bp.name == EMBED_FRAMEWORK_PHASE_NAME }
+          embed_build_phase = native_target.shell_script_build_phases.find { |bp| bp.name && bp.name.end_with?(EMBED_FRAMEWORK_PHASE_NAME) }
           return unless embed_build_phase.present?
           native_target.build_phases.delete(embed_build_phase)
         end
@@ -157,10 +178,9 @@ module Pod
             native_target.build_phases.unshift(phase).uniq! unless native_target.build_phases.first == phase
             phase.shell_script = <<-SH.strip_heredoc
               diff "${PODS_ROOT}/../Podfile.lock" "${PODS_ROOT}/Manifest.lock" > /dev/null
-              if [[ $? != 0 ]] ; then
-                  cat << EOM
-              error: The sandbox is not in sync with the Podfile.lock. Run 'pod install' or update your CocoaPods installation.
-              EOM
+              if [ $? != 0 ] ; then
+                  # print error to STDERR
+                  echo "error: The sandbox is not in sync with the Podfile.lock. Run 'pod install' or update your CocoaPods installation." >&2
                   exit 1
               fi
             SH
@@ -184,6 +204,7 @@ module Pod
         #         directory / product bundle.
         #
         def native_targets_to_embed_in
+          return [] if target.requires_host_target?
           native_targets.select do |target|
             EMBED_FRAMEWORK_TARGET_TYPES.include?(target.symbol_type)
           end
@@ -215,8 +236,7 @@ module Pod
         def create_or_update_build_phase(target, phase_name, phase_class = Xcodeproj::Project::Object::PBXShellScriptBuildPhase)
           prefixed_phase_name = BUILD_PHASE_PREFIX + phase_name
           build_phases = target.build_phases.grep(phase_class)
-          build_phases.find { |phase| phase.name == prefixed_phase_name } ||
-            build_phases.find { |phase| phase.name == phase_name }.tap { |p| p.name = prefixed_phase_name if p } ||
+          build_phases.find { |phase| phase.name && phase.name.end_with?(phase_name) }.tap { |p| p.name = prefixed_phase_name if p } ||
             target.project.new(phase_class).tap do |phase|
               UI.message("Adding Build Phase '#{prefixed_phase_name}' to project.") do
                 phase.name = prefixed_phase_name