cocoapods 1.9.1 → 1.10.0.rc.1

data/lib/cocoapods/config.rb

@@ -60,6 +60,11 @@ module Pod
     attr_accessor :silent
     alias_method :silent?, :silent
 
+    # @return [Bool] Whether CocoaPods is allowed to run as root.
+    #
+    attr_accessor :allow_root
+    alias_method :allow_root?, :allow_root
+
     # @return [Bool] Whether a message should be printed when a new version of
     #         CocoaPods is available.
     #
@@ -314,6 +319,18 @@ module Pod
       nil
     end
 
+    # Excludes the given dir from Time Machine backups.
+    #
+    # @param  [Pathname] dir
+    #         The directory to exclude from Time Machine backups.
+    #
+    # @return [void]
+    #
+    def exclude_from_backup(dir)
+      return if Gem.win_platform?
+      system('tmutil', 'addexclusion', dir.to_s, %i(out err) => File::NULL)
+    end
+
     public
 
     #-------------------------------------------------------------------------#

data/lib/cocoapods/downloader/cache.rb

@@ -97,7 +97,7 @@ module Pod
       #         `request`.
       #
       def path_for_pod(request, slug_opts = {})
-        root + request.slug(slug_opts)
+        root + request.slug(**slug_opts)
       end
 
       # @param  [Request] request
@@ -111,7 +111,7 @@ module Pod
       #         `request`.
       #
       def path_for_spec(request, slug_opts = {})
-        path = root + 'Specs' + request.slug(slug_opts)
+        path = root + 'Specs' + request.slug(**slug_opts)
         path.sub_ext('.podspec.json')
       end
 

data/lib/cocoapods/gem_version.rb

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

data/lib/cocoapods/generator/app_target_helper.rb

@@ -127,9 +127,17 @@ module Pod
       # @return [void]
       #
       def self.add_xctest_search_paths(target)
+        requires_libs = target.platform_name == :ios &&
+          Version.new(target.deployment_target) < Version.new('12.2')
+
         target.build_configurations.each do |configuration|
-          search_paths = configuration.build_settings['FRAMEWORK_SEARCH_PATHS'] ||= '$(inherited)'
-          search_paths << ' "$(PLATFORM_DIR)/Developer/Library/Frameworks"'
+          framework_search_paths = configuration.build_settings['FRAMEWORK_SEARCH_PATHS'] ||= '$(inherited)'
+          framework_search_paths << ' "$(PLATFORM_DIR)/Developer/Library/Frameworks"'
+
+          if requires_libs
+            library_search_paths = configuration.build_settings['LIBRARY_SEARCH_PATHS'] ||= '$(inherited)'
+            library_search_paths << ' "$(PLATFORM_DIR)/Developer/usr/lib"'
+          end
         end
       end
 

data/lib/cocoapods/generator/copy_dsyms_script.rb

@@ -0,0 +1,56 @@
+module Pod
+  module Generator
+    class CopydSYMsScript
+      # @return [Array<Pathname>] dsym_paths the dSYM paths to include in the script contents.
+      #
+      attr_reader :dsym_paths
+
+      # @return [Array<Pathname>] bcsymbolmap_paths the bcsymbolmap paths to include in the script contents.
+      #
+      attr_reader :bcsymbolmap_paths
+
+      # Initialize a new instance
+      #
+      # @param  [Array<Pathname>] dsym_paths @see dsym_paths
+      # @param  [Array<Pathname>] bcsymbolmap_paths @see bcsymbolmap_paths
+      #
+      def initialize(dsym_paths, bcsymbolmap_paths)
+        @dsym_paths = Array(dsym_paths)
+        @bcsymbolmap_paths = Array(bcsymbolmap_paths)
+      end
+
+      # Saves the copy dSYMs script to the given pathname.
+      #
+      # @param  [Pathname] pathname
+      #         The path where the copy dSYMs script should be saved.
+      #
+      # @return [void]
+      #
+      def save_as(pathname)
+        pathname.open('w') do |file|
+          file.puts(generate)
+        end
+        File.chmod(0755, pathname.to_s)
+      end
+
+      # @return [String] The generated of the copy dSYMs script.
+      #
+      def generate
+        script = <<-SH.strip_heredoc
+#{Pod::Generator::ScriptPhaseConstants::DEFAULT_SCRIPT_PHASE_HEADER}
+#{Pod::Generator::ScriptPhaseConstants::STRIP_INVALID_ARCHITECTURES_METHOD}
+#{Pod::Generator::ScriptPhaseConstants::RSYNC_PROTECT_TMP_FILES}
+#{Pod::Generator::ScriptPhaseConstants::INSTALL_DSYM_METHOD}
+#{Pod::Generator::ScriptPhaseConstants::INSTALL_BCSYMBOLMAP_METHOD}
+        SH
+        dsym_paths.each do |dsym_path|
+          script << %(install_dsym "#{dsym_path}"\n)
+        end
+        bcsymbolmap_paths.each do |bcsymbolmap_path|
+          script << %(install_bcsymbolmap "#{bcsymbolmap_path}"\n)
+        end
+        script
+      end
+    end
+  end
+end

data/lib/cocoapods/generator/copy_resources_script.rb

@@ -100,16 +100,7 @@ module Pod
       end
 
       INSTALL_RESOURCES_FUNCTION = <<EOS
-#!/bin/sh
-set -e
-set -u
-set -o pipefail
-
-function on_error {
-  echo "$(realpath -mq "${0}"):$1: error: Unexpected failure"
-}
-trap 'on_error $LINENO' ERR
-
+#{Pod::Generator::ScriptPhaseConstants::DEFAULT_SCRIPT_PHASE_HEADER}
 if [ -z ${UNLOCALIZED_RESOURCES_FOLDER_PATH+x} ]; then
   # If UNLOCALIZED_RESOURCES_FOLDER_PATH is not set, then there's nowhere for us to copy
   # resources to, so exit 0 (signalling the script phase was successful).
@@ -123,10 +114,7 @@ RESOURCES_TO_COPY=${PODS_ROOT}/resources-to-copy-${TARGETNAME}.txt
 
 XCASSET_FILES=()
 
-# This protects against multiple targets copying the same framework dependency at the same time. The solution
-# was originally proposed here: https://lists.samba.org/archive/rsync/2008-February/020158.html
-RSYNC_PROTECT_TMP_FILES=(--filter "P .*.??????")
-
+#{Pod::Generator::ScriptPhaseConstants::RSYNC_PROTECT_TMP_FILES}
 case "${TARGETED_DEVICE_FAMILY:-}" in
   1,2)
     TARGET_DEVICE_ARGS="--target-device ipad --target-device iphone"

data/lib/cocoapods/generator/copy_xcframework_script.rb

@@ -0,0 +1,254 @@
+require 'cocoapods/xcode'
+
+module Pod
+  module Generator
+    class CopyXCFrameworksScript
+      # @return [Array<Pod::Xcode::XCFramework>] List of xcframeworks to copy
+      #
+      attr_reader :xcframeworks
+
+      # @return [Pathname] the root directory of the sandbox
+      #
+      attr_reader :sandbox_root
+
+      # @return [Platform] the platform of the target for which this script will run
+      #
+      attr_reader :platform
+
+      # Creates a script for copying XCFramework slcies into an intermediate build directory
+      #
+      # @param  [Array<Pod::Xcode::XCFramework>] xcframeworks
+      #         the list of xcframeworks to copy
+      #
+      # @param  [Pathname] sandbox_root
+      #         the root of the Sandbox into which this script will be installed
+      #
+      # @param  [Platform] platform
+      #         the platform of the target for which this script will be run
+      #
+      def initialize(xcframeworks, sandbox_root, platform)
+        @xcframeworks = xcframeworks
+        @sandbox_root = sandbox_root
+        @platform = platform
+      end
+
+      # Saves the resource script to the given pathname.
+      #
+      # @param  [Pathname] pathname
+      #         The path where the embed frameworks script should be saved.
+      #
+      # @return [void]
+      #
+      def save_as(pathname)
+        pathname.open('w') do |file|
+          file.puts(script)
+        end
+        File.chmod(0o755, pathname.to_s)
+      end
+
+      # @return [String] The contents of the embed frameworks script.
+      #
+      def generate
+        script
+      end
+
+      private
+
+      # @!group Private Helpers
+
+      # @return [String] The contents of the prepare artifacts script.
+      #
+      def script
+        script = <<-SH.strip_heredoc
+#{Pod::Generator::ScriptPhaseConstants::DEFAULT_SCRIPT_PHASE_HEADER}
+
+#{Pod::Generator::ScriptPhaseConstants::RSYNC_PROTECT_TMP_FILES}
+
+copy_dir()
+{
+  local source="$1"
+  local destination="$2"
+
+  # Use filter instead of exclude so missing patterns don't throw errors.
+  echo "rsync --delete -av "${RSYNC_PROTECT_TMP_FILES[@]}" --links --filter \\"- CVS/\\" --filter \\"- .svn/\\" --filter \\"- .git/\\" --filter \\"- .hg/\\" \\"${source}\\" \\"${destination}\\""
+  rsync --delete -av "${RSYNC_PROTECT_TMP_FILES[@]}" --links --filter "- CVS/" --filter "- .svn/" --filter "- .git/" --filter "- .hg/" "${source}" "${destination}"
+}
+
+SELECT_SLICE_RETVAL=""
+
+select_slice() {
+  local paths=("$@")
+  # Locate the correct slice of the .xcframework for the current architectures
+  local target_path=""
+
+  # Split archs on space so we can find a slice that has all the needed archs
+  local target_archs=$(echo $ARCHS | tr " " "\\n")
+
+  local target_variant=""
+  if [[ "$PLATFORM_NAME" == *"simulator" ]]; then
+    target_variant="simulator"
+  fi
+  if [[ ! -z ${EFFECTIVE_PLATFORM_NAME+x} && "$EFFECTIVE_PLATFORM_NAME" == *"maccatalyst" ]]; then
+    target_variant="maccatalyst"
+  fi
+  for i in ${!paths[@]}; do
+    local matched_all_archs="1"
+    for target_arch in $target_archs
+    do
+      if ! [[ "${paths[$i]}" == *"$target_variant"* ]]; then
+        matched_all_archs="0"
+        break
+      fi
+
+      # Verifies that the path contains the variant string (simulator or maccatalyst) if the variant is set.
+      if [[ -z "$target_variant" && ("${paths[$i]}" == *"simulator"* || "${paths[$i]}" == *"maccatalyst"*) ]]; then
+        matched_all_archs="0"
+        break
+      fi
+
+      # This regex matches all possible variants of the arch in the folder name:
+      # Let's say the folder name is: ios-armv7_armv7s_arm64_arm64e/CoconutLib.framework
+      # We match the following: -armv7_, _armv7s_, _arm64_ and _arm64e/.
+      # If we have a specific variant: ios-i386_x86_64-simulator/CoconutLib.framework
+      # We match the following: -i386_ and _x86_64-
+      # When the .xcframework wraps a static library, the folder name does not include
+      # any .framework. In that case, the folder name can be: ios-arm64_armv7
+      # We also match _armv7$ to handle that case.
+      local target_arch_regex="[_\\-]${target_arch}([\\/_\\-]|$)"
+      if ! [[ "${paths[$i]}" =~ $target_arch_regex ]]; then
+        matched_all_archs="0"
+        break
+      fi
+    done
+
+    if [[ "$matched_all_archs" == "1" ]]; then
+      # Found a matching slice
+      echo "Selected xcframework slice ${paths[$i]}"
+      SELECT_SLICE_RETVAL=${paths[$i]}
+      break
+    fi
+  done
+}
+
+install_library() {
+  local source="$1"
+  local name="$2"
+  local destination="#{Target::BuildSettings::XCFRAMEWORKS_BUILD_DIR_VARIABLE}/${name}"
+
+  # Libraries can contain headers, module maps, and a binary, so we'll copy everything in the folder over
+
+  local source="$binary"
+  echo "rsync --delete -av "${RSYNC_PROTECT_TMP_FILES[@]}" --links --filter \\"- CVS/\\" --filter \\"- .svn/\\" --filter \\"- .git/\\" --filter \\"- .hg/\\" \\"${source}/*\\" \\"${destination}\\""
+  rsync --delete -av "${RSYNC_PROTECT_TMP_FILES[@]}" --links --filter "- CVS/" --filter "- .svn/" --filter "- .git/" --filter "- .hg/" "${source}/*" "${destination}"
+}
+
+# Copies a framework to derived data for use in later build phases
+install_framework()
+{
+  local source="$1"
+  local name="$2"
+  local destination="#{Pod::Target::BuildSettings::XCFRAMEWORKS_BUILD_DIR_VARIABLE}/${name}"
+
+  if [ ! -d "$destination" ]; then
+    mkdir -p "$destination"
+  fi
+
+  copy_dir "$source" "$destination"
+  echo "Copied $source to $destination"
+}
+
+install_xcframework_library() {
+  local basepath="$1"
+  local name="$2"
+  local paths=("$@")
+
+  # Locate the correct slice of the .xcframework for the current architectures
+  select_slice "${paths[@]}"
+  local target_path="$SELECT_SLICE_RETVAL"
+  if [[ -z "$target_path" ]]; then
+    echo "warning: [CP] Unable to find matching .xcframework slice in '${paths[@]}' for the current build architectures ($ARCHS)."
+    return
+  fi
+
+  install_framework "$basepath/$target_path" "$name"
+}
+
+install_xcframework() {
+  local basepath="$1"
+  local name="$2"
+  local package_type="$3"
+  local paths=("$@")
+
+  # Locate the correct slice of the .xcframework for the current architectures
+  select_slice "${paths[@]}"
+  local target_path="$SELECT_SLICE_RETVAL"
+  if [[ -z "$target_path" ]]; then
+    echo "warning: [CP] Unable to find matching .xcframework slice in '${paths[@]}' for the current build architectures ($ARCHS)."
+    return
+  fi
+  local source="$basepath/$target_path"
+
+  local destination="#{Pod::Target::BuildSettings::XCFRAMEWORKS_BUILD_DIR_VARIABLE}/${name}"
+
+  if [ ! -d "$destination" ]; then
+    mkdir -p "$destination"
+  fi
+
+  if [[ "$package_type" == "library" ]]; then
+    # Libraries can contain headers, module maps, and a binary, so we'll copy everything in the folder over
+    copy_dir "$source/" "$destination"
+  elif [[ "$package_type" == "framework" ]]; then
+    copy_dir "$source" "$destination"
+  fi
+  echo "Copied $source to $destination"
+}
+
+        SH
+        xcframeworks.each do |xcframework|
+          slices = xcframework.slices.select { |f| f.platform.symbolic_name == platform.symbolic_name }
+          next if slices.empty?
+          args = install_xcframework_args(xcframework, slices)
+          script << "install_xcframework #{args}\n"
+        end
+
+        script << "\n" unless xcframeworks.empty?
+        script
+      end
+
+      def shell_escape(value)
+        "\"#{value}\""
+      end
+
+      def install_xcframework_args(xcframework, slices)
+        root = xcframework.path
+        args = [shell_escape("${PODS_ROOT}/#{root.relative_path_from(sandbox_root)}")]
+        args << shell_escape(xcframework.name)
+        is_framework = xcframework.build_type.framework?
+        args << shell_escape(is_framework ? 'framework' : 'library')
+        slices.each do |slice|
+          args << if is_framework
+                    shell_escape(slice.path.relative_path_from(root))
+                  else
+                    # We don't want the path to the library binary, we want the dir that contains it
+                    shell_escape(slice.path.dirname.relative_path_from(root))
+                  end
+        end
+        args.join(' ')
+      end
+
+      class << self
+        # @param  [Pathname] xcframework_path
+        #         the base path of the .xcframework bundle
+        #
+        # @return [Array<Pathname>] all found .dSYM paths
+        #
+        def dsym_folder(xcframework_path)
+          basename = File.basename(xcframework_path, '.xcframework')
+          dsym_basename = basename + '.dSYMs'
+          path = xcframework_path.dirname + dsym_basename
+          Pathname.new(path) if File.directory?(path)
+        end
+      end
+    end
+  end
+end

data/lib/cocoapods/generator/embed_frameworks_script.rb

@@ -8,11 +8,20 @@ module Pod
       #
       attr_reader :frameworks_by_config
 
+      # @return [Hash{String => Array<XCFrameworkPaths>}] Multiple lists of frameworks per
+      #         configuration.
+      #
+      attr_reader :xcframeworks_by_config
+
       # @param  [Hash{String => Array<FrameworkPaths>] frameworks_by_config
       #         @see #frameworks_by_config
       #
-      def initialize(frameworks_by_config)
+      # @param  [Hash{String => Array<XCFramework>] xcframeworks_by_config
+      #         @see #xcframeworks_by_config
+      #
+      def initialize(frameworks_by_config, xcframeworks_by_config)
         @frameworks_by_config = frameworks_by_config
+        @xcframeworks_by_config = xcframeworks_by_config
       end
 
       # Saves the resource script to the given pathname.
@@ -43,219 +52,123 @@ module Pod
       #
       def script
         script = <<-SH.strip_heredoc
-          #!/bin/sh
-          set -e
-          set -u
-          set -o pipefail
-
-          function on_error {
-            echo "$(realpath -mq "${0}"):$1: error: Unexpected failure"
-          }
-          trap 'on_error $LINENO' ERR
-
-          if [ -z ${FRAMEWORKS_FOLDER_PATH+x} ]; then
-            # If FRAMEWORKS_FOLDER_PATH is not set, then there's nowhere for us to copy
-            # frameworks to, so exit 0 (signalling the script phase was successful).
-            exit 0
-          fi
-
-          echo "mkdir -p ${CONFIGURATION_BUILD_DIR}/${FRAMEWORKS_FOLDER_PATH}"
-          mkdir -p "${CONFIGURATION_BUILD_DIR}/${FRAMEWORKS_FOLDER_PATH}"
-
-          COCOAPODS_PARALLEL_CODE_SIGN="${COCOAPODS_PARALLEL_CODE_SIGN:-false}"
-          SWIFT_STDLIB_PATH="${DT_TOOLCHAIN_DIR}/usr/lib/swift/${PLATFORM_NAME}"
-
-          # Used as a return value for each invocation of `strip_invalid_archs` function.
-          STRIP_BINARY_RETVAL=0
-
-          # This protects against multiple targets copying the same framework dependency at the same time. The solution
-          # was originally proposed here: https://lists.samba.org/archive/rsync/2008-February/020158.html
-          RSYNC_PROTECT_TMP_FILES=(--filter "P .*.??????")
-
-          # Copies and strips a vendored framework
-          install_framework()
-          {
-            if [ -r "${BUILT_PRODUCTS_DIR}/$1" ]; then
-              local source="${BUILT_PRODUCTS_DIR}/$1"
-            elif [ -r "${BUILT_PRODUCTS_DIR}/$(basename "$1")" ]; then
-              local source="${BUILT_PRODUCTS_DIR}/$(basename "$1")"
-            elif [ -r "$1" ]; then
-              local source="$1"
-            fi
-
-            local destination="${TARGET_BUILD_DIR}/${FRAMEWORKS_FOLDER_PATH}"
-
-            if [ -L "${source}" ]; then
-              echo "Symlinked..."
-              source="$(readlink "${source}")"
-            fi
-
-            # Use filter instead of exclude so missing patterns don't throw errors.
-            echo "rsync --delete -av "${RSYNC_PROTECT_TMP_FILES[@]}" --links --filter \\"- CVS/\\" --filter \\"- .svn/\\" --filter \\"- .git/\\" --filter \\"- .hg/\\" --filter \\"- Headers\\" --filter \\"- PrivateHeaders\\" --filter \\"- Modules\\" \\"${source}\\" \\"${destination}\\""
-            rsync --delete -av "${RSYNC_PROTECT_TMP_FILES[@]}" --links --filter "- CVS/" --filter "- .svn/" --filter "- .git/" --filter "- .hg/" --filter "- Headers" --filter "- PrivateHeaders" --filter "- Modules" "${source}" "${destination}"
-
-            local basename
-            basename="$(basename -s .framework "$1")"
-            binary="${destination}/${basename}.framework/${basename}"
-
-            if ! [ -r "$binary" ]; then
-              binary="${destination}/${basename}"
-            elif [ -L "${binary}" ]; then
-              echo "Destination binary is symlinked..."
-              dirname="$(dirname "${binary}")"
-              binary="${dirname}/$(readlink "${binary}")"
-            fi
-
-            # Strip invalid architectures so "fat" simulator / device frameworks work on device
-            if [[ "$(file "$binary")" == *"dynamically linked shared library"* ]]; then
-              strip_invalid_archs "$binary"
-            fi
-
-            # Resign the code if required by the build settings to avoid unstable apps
-            code_sign_if_enabled "${destination}/$(basename "$1")"
-
-            # Embed linked Swift runtime libraries. No longer necessary as of Xcode 7.
-            if [ "${XCODE_VERSION_MAJOR}" -lt 7 ]; then
-              local swift_runtime_libs
-              swift_runtime_libs=$(xcrun otool -LX "$binary" | grep --color=never @rpath/libswift | sed -E s/@rpath\\\\/\\(.+dylib\\).*/\\\\1/g | uniq -u)
-              for lib in $swift_runtime_libs; do
-                echo "rsync -auv \\"${SWIFT_STDLIB_PATH}/${lib}\\" \\"${destination}\\""
-                rsync -auv "${SWIFT_STDLIB_PATH}/${lib}" "${destination}"
-                code_sign_if_enabled "${destination}/${lib}"
-              done
-            fi
-          }
-
-          # Copies and strips a vendored dSYM
-          install_dsym() {
-            local source="$1"
-            warn_missing_arch=${2:-true}
-            if [ -r "$source" ]; then
-              # Copy the dSYM into the targets temp dir.
-              echo "rsync --delete -av "${RSYNC_PROTECT_TMP_FILES[@]}" --filter \\"- CVS/\\" --filter \\"- .svn/\\" --filter \\"- .git/\\" --filter \\"- .hg/\\" --filter \\"- Headers\\" --filter \\"- PrivateHeaders\\" --filter \\"- Modules\\" \\"${source}\\" \\"${DERIVED_FILES_DIR}\\""
-              rsync --delete -av "${RSYNC_PROTECT_TMP_FILES[@]}" --filter "- CVS/" --filter "- .svn/" --filter "- .git/" --filter "- .hg/" --filter "- Headers" --filter "- PrivateHeaders" --filter "- Modules" "${source}" "${DERIVED_FILES_DIR}"
-
-              local basename
-              basename="$(basename -s .dSYM "$source")"
-              binary_name="$(ls "$source/Contents/Resources/DWARF")"
-              binary="${DERIVED_FILES_DIR}/${basename}.dSYM/Contents/Resources/DWARF/${binary_name}"
-
-              # Strip invalid architectures so "fat" simulator / device frameworks work on device
-              if [[ "$(file "$binary")" == *"Mach-O "*"dSYM companion"* ]]; then
-                strip_invalid_archs "$binary" "$warn_missing_arch"
-              fi
-
-              if [[ $STRIP_BINARY_RETVAL == 1 ]]; then
-                # Move the stripped file into its final destination.
-                echo "rsync --delete -av "${RSYNC_PROTECT_TMP_FILES[@]}" --links --filter \\"- CVS/\\" --filter \\"- .svn/\\" --filter \\"- .git/\\" --filter \\"- .hg/\\" --filter \\"- Headers\\" --filter \\"- PrivateHeaders\\" --filter \\"- Modules\\" \\"${DERIVED_FILES_DIR}/${basename}.framework.dSYM\\" \\"${DWARF_DSYM_FOLDER_PATH}\\""
-                rsync --delete -av "${RSYNC_PROTECT_TMP_FILES[@]}" --links --filter "- CVS/" --filter "- .svn/" --filter "- .git/" --filter "- .hg/" --filter "- Headers" --filter "- PrivateHeaders" --filter "- Modules" "${DERIVED_FILES_DIR}/${basename}.dSYM" "${DWARF_DSYM_FOLDER_PATH}"
-              else
-                # The dSYM was not stripped at all, in this case touch a fake folder so the input/output paths from Xcode do not reexecute this script because the file is missing.
-                touch "${DWARF_DSYM_FOLDER_PATH}/${basename}.dSYM"
-              fi
-            fi
-          }
-
-          # Copies the bcsymbolmap files of a vendored framework
-          install_bcsymbolmap() {
-              local bcsymbolmap_path="$1"
-              local destination="${BUILT_PRODUCTS_DIR}"
-              echo "rsync --delete -av "${RSYNC_PROTECT_TMP_FILES[@]}" --filter \"- CVS/\" --filter \"- .svn/\" --filter \"- .git/\" --filter \"- .hg/\" --filter \"- Headers\" --filter \"- PrivateHeaders\" --filter \"- Modules\" \"${bcsymbolmap_path}\" \"${destination}\""
-              rsync --delete -av "${RSYNC_PROTECT_TMP_FILES[@]}" --filter "- CVS/" --filter "- .svn/" --filter "- .git/" --filter "- .hg/" --filter "- Headers" --filter "- PrivateHeaders" --filter "- Modules" "${bcsymbolmap_path}" "${destination}"
-          }
-
-          # Signs a framework with the provided identity
-          code_sign_if_enabled() {
-            if [ -n "${EXPANDED_CODE_SIGN_IDENTITY:-}" -a "${CODE_SIGNING_REQUIRED:-}" != "NO" -a "${CODE_SIGNING_ALLOWED}" != "NO" ]; then
-              # Use the current code_sign_identity
-              echo "Code Signing $1 with Identity ${EXPANDED_CODE_SIGN_IDENTITY_NAME}"
-              local code_sign_cmd="/usr/bin/codesign --force --sign ${EXPANDED_CODE_SIGN_IDENTITY} ${OTHER_CODE_SIGN_FLAGS:-} --preserve-metadata=identifier,entitlements '$1'"
-
-              if [ "${COCOAPODS_PARALLEL_CODE_SIGN}" == "true" ]; then
-                code_sign_cmd="$code_sign_cmd &"
-              fi
-              echo "$code_sign_cmd"
-              eval "$code_sign_cmd"
-            fi
-          }
-
-          # Strip invalid architectures
-          strip_invalid_archs() {
-            binary="$1"
-            warn_missing_arch=${2:-true}
-            # Get architectures for current target binary
-            binary_archs="$(lipo -info "$binary" | rev | cut -d ':' -f1 | awk '{$1=$1;print}' | rev)"
-            # Intersect them with the architectures we are building for
-            intersected_archs="$(echo ${ARCHS[@]} ${binary_archs[@]} | tr ' ' '\\n' | sort | uniq -d)"
-            # If there are no archs supported by this binary then warn the user
-            if [[ -z "$intersected_archs" ]]; then
-              if [[ "$warn_missing_arch" == "true" ]]; then
-                echo "warning: [CP] Vendored binary '$binary' contains architectures ($binary_archs) none of which match the current build architectures ($ARCHS)."
-              fi
-              STRIP_BINARY_RETVAL=0
-              return
-            fi
-            stripped=""
-            for arch in $binary_archs; do
-              if ! [[ "${ARCHS}" == *"$arch"* ]]; then
-                # Strip non-valid architectures in-place
-                lipo -remove "$arch" -output "$binary" "$binary"
-                stripped="$stripped $arch"
-              fi
-            done
-            if [[ "$stripped" ]]; then
-              echo "Stripped $binary of architectures:$stripped"
-            fi
-            STRIP_BINARY_RETVAL=1
-          }
-
-          install_artifact() {
-            artifact="$1"
-            base="$(basename "$artifact")"
-            case $base in
-            *.framework)
-              install_framework "$artifact"
-              ;;
-            *.dSYM)
-              # Suppress arch warnings since XCFrameworks will include many dSYM files
-              install_dsym "$artifact" "false"
-              ;;
-            *.bcsymbolmap)
-              install_bcsymbolmap "$artifact"
-              ;;
-            *)
-              echo "error: Unrecognized artifact "$artifact""
-              ;;
-            esac
-          }
-
-          copy_artifacts() {
-            file_list="$1"
-            while read artifact; do
-              install_artifact "$artifact"
-            done <$file_list
-          }
-
-          ARTIFACT_LIST_FILE="${BUILT_PRODUCTS_DIR}/cocoapods-artifacts-${CONFIGURATION}.txt"
-          if [ -r "${ARTIFACT_LIST_FILE}" ]; then
-            copy_artifacts "${ARTIFACT_LIST_FILE}"
-          fi
-
+#{Pod::Generator::ScriptPhaseConstants::DEFAULT_SCRIPT_PHASE_HEADER}
+if [ -z ${FRAMEWORKS_FOLDER_PATH+x} ]; then
+  # If FRAMEWORKS_FOLDER_PATH is not set, then there's nowhere for us to copy
+  # frameworks to, so exit 0 (signalling the script phase was successful).
+  exit 0
+fi
+
+echo "mkdir -p ${CONFIGURATION_BUILD_DIR}/${FRAMEWORKS_FOLDER_PATH}"
+mkdir -p "${CONFIGURATION_BUILD_DIR}/${FRAMEWORKS_FOLDER_PATH}"
+
+COCOAPODS_PARALLEL_CODE_SIGN="${COCOAPODS_PARALLEL_CODE_SIGN:-false}"
+SWIFT_STDLIB_PATH="${DT_TOOLCHAIN_DIR}/usr/lib/swift/${PLATFORM_NAME}"
+BCSYMBOLMAP_DIR="BCSymbolMaps"
+
+
+#{Pod::Generator::ScriptPhaseConstants::RSYNC_PROTECT_TMP_FILES}
+# Copies and strips a vendored framework
+install_framework()
+{
+  if [ -r "${BUILT_PRODUCTS_DIR}/$1" ]; then
+    local source="${BUILT_PRODUCTS_DIR}/$1"
+  elif [ -r "${BUILT_PRODUCTS_DIR}/$(basename "$1")" ]; then
+    local source="${BUILT_PRODUCTS_DIR}/$(basename "$1")"
+  elif [ -r "$1" ]; then
+    local source="$1"
+  fi
+
+  local destination="${TARGET_BUILD_DIR}/${FRAMEWORKS_FOLDER_PATH}"
+
+  if [ -L "${source}" ]; then
+    echo "Symlinked..."
+    source="$(readlink "${source}")"
+  fi
+
+  if [ -d "${source}/${BCSYMBOLMAP_DIR}" ]; then
+    # Locate and install any .bcsymbolmaps if present, and remove them from the .framework before the framework is copied
+    find "${source}/${BCSYMBOLMAP_DIR}" -name "*.bcsymbolmap"|while read f; do
+      echo "Installing $f"
+      install_bcsymbolmap "$f" "$destination"
+      rm "$f"
+    done
+    rmdir "${source}/${BCSYMBOLMAP_DIR}"
+  fi
+
+  # Use filter instead of exclude so missing patterns don't throw errors.
+  echo "rsync --delete -av "${RSYNC_PROTECT_TMP_FILES[@]}" --links --filter \\"- CVS/\\" --filter \\"- .svn/\\" --filter \\"- .git/\\" --filter \\"- .hg/\\" --filter \\"- Headers\\" --filter \\"- PrivateHeaders\\" --filter \\"- Modules\\" \\"${source}\\" \\"${destination}\\""
+  rsync --delete -av "${RSYNC_PROTECT_TMP_FILES[@]}" --links --filter "- CVS/" --filter "- .svn/" --filter "- .git/" --filter "- .hg/" --filter "- Headers" --filter "- PrivateHeaders" --filter "- Modules" "${source}" "${destination}"
+
+  local basename
+  basename="$(basename -s .framework "$1")"
+  binary="${destination}/${basename}.framework/${basename}"
+
+  if ! [ -r "$binary" ]; then
+    binary="${destination}/${basename}"
+  elif [ -L "${binary}" ]; then
+    echo "Destination binary is symlinked..."
+    dirname="$(dirname "${binary}")"
+    binary="${dirname}/$(readlink "${binary}")"
+  fi
+
+  # Strip invalid architectures so "fat" simulator / device frameworks work on device
+  if [[ "$(file "$binary")" == *"dynamically linked shared library"* ]]; then
+    strip_invalid_archs "$binary"
+  fi
+
+  # Resign the code if required by the build settings to avoid unstable apps
+  code_sign_if_enabled "${destination}/$(basename "$1")"
+
+  # Embed linked Swift runtime libraries. No longer necessary as of Xcode 7.
+  if [ "${XCODE_VERSION_MAJOR}" -lt 7 ]; then
+    local swift_runtime_libs
+    swift_runtime_libs=$(xcrun otool -LX "$binary" | grep --color=never @rpath/libswift | sed -E s/@rpath\\\\/\\(.+dylib\\).*/\\\\1/g | uniq -u)
+    for lib in $swift_runtime_libs; do
+      echo "rsync -auv \\"${SWIFT_STDLIB_PATH}/${lib}\\" \\"${destination}\\""
+      rsync -auv "${SWIFT_STDLIB_PATH}/${lib}" "${destination}"
+      code_sign_if_enabled "${destination}/${lib}"
+    done
+  fi
+}
+#{Pod::Generator::ScriptPhaseConstants::INSTALL_DSYM_METHOD}
+#{Pod::Generator::ScriptPhaseConstants::STRIP_INVALID_ARCHITECTURES_METHOD}
+#{Pod::Generator::ScriptPhaseConstants::INSTALL_BCSYMBOLMAP_METHOD}
+# Signs a framework with the provided identity
+code_sign_if_enabled() {
+  if [ -n "${EXPANDED_CODE_SIGN_IDENTITY:-}" -a "${CODE_SIGNING_REQUIRED:-}" != "NO" -a "${CODE_SIGNING_ALLOWED}" != "NO" ]; then
+    # Use the current code_sign_identity
+    echo "Code Signing $1 with Identity ${EXPANDED_CODE_SIGN_IDENTITY_NAME}"
+    local code_sign_cmd="/usr/bin/codesign --force --sign ${EXPANDED_CODE_SIGN_IDENTITY} ${OTHER_CODE_SIGN_FLAGS:-} --preserve-metadata=identifier,entitlements '$1'"
+
+    if [ "${COCOAPODS_PARALLEL_CODE_SIGN}" == "true" ]; then
+      code_sign_cmd="$code_sign_cmd &"
+    fi
+    echo "$code_sign_cmd"
+    eval "$code_sign_cmd"
+  fi
+}
         SH
-        frameworks_by_config.each do |config, frameworks_with_dsyms|
-          next if frameworks_with_dsyms.empty?
-          script << %(if [[ "$CONFIGURATION" == "#{config}" ]]; then\n)
-          frameworks_with_dsyms.each do |framework_with_dsym|
-            script << %(  install_framework "#{framework_with_dsym.source_path}"\n)
-            # Vendored frameworks might have a dSYM file next to them so ensure its copied. Frameworks built from
-            # sources will have their dSYM generated and copied by Xcode.
-            script << %(  install_dsym "#{framework_with_dsym.dsym_path}"\n) unless framework_with_dsym.dsym_path.nil?
-            unless framework_with_dsym.bcsymbolmap_paths.nil?
-              framework_with_dsym.bcsymbolmap_paths.each do |bcsymbolmap_path|
-                script << %(  install_bcsymbolmap "#{bcsymbolmap_path}"\n)
-              end
-            end
+        contents_by_config = Hash.new do |hash, key|
+          hash[key] = ''
+        end
+        frameworks_by_config.each do |config, frameworks|
+          frameworks.each do |framework|
+            contents_by_config[config] << %(  install_framework "#{framework.source_path}"\n)
           end
+        end
+        xcframeworks_by_config.each do |config, xcframeworks|
+          xcframeworks.select { |xcf| xcf.build_type.dynamic_framework? }.each do |xcframework|
+            name = xcframework.name
+            contents_by_config[config] << %(  install_framework "#{Target::BuildSettings::XCFRAMEWORKS_BUILD_DIR_VARIABLE}/#{name}/#{name}.framework"\n)
+          end
+        end
+        script << "\n" unless contents_by_config.empty?
+        contents_by_config.keys.sort.each do |config|
+          contents = contents_by_config[config]
+          next if contents.empty?
+          script << %(if [[ "$CONFIGURATION" == "#{config}" ]]; then\n)
+          script << contents
           script << "fi\n"
         end
         script << <<-SH.strip_heredoc