cocoapods-tt 0.0.1

data/lib/cocoapods-tt/native/generator/copy_xcframework_script.rb

@@ -0,0 +1,227 @@
+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}
+
+#{variant_for_slice}
+
+#{archs_for_slice}
+
+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 xcframework_name="$1"
+  xcframework_name="${xcframework_name##*/}"
+  local paths=("${@:2}")
+  # 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"
+    local slice_archs="$(archs_for_slice "${xcframework_name}/${paths[$i]}")"
+    local slice_variant="$(variant_for_slice "${xcframework_name}/${paths[$i]}")"
+    for target_arch in $target_archs; do
+      if ! [[ "${slice_variant}" == "$target_variant" ]]; then
+        matched_all_archs="0"
+        break
+      fi
+
+      if ! echo "${slice_archs}" | tr " " "\\n" | grep -F -q -x "$target_arch"; 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_xcframework() {
+  local basepath="$1"
+  local name="$2"
+  local package_type="$3"
+  local paths=("${@:4}")
+
+  # Locate the correct slice of the .xcframework for the current architectures
+  select_slice "${basepath}" "${paths[@]}"
+  local target_path="$SELECT_SLICE_RETVAL"
+  if [[ -z "$target_path" ]]; then
+    echo "warning: [CP] $(basename ${basepath}): Unable to find matching slice in '${paths[@]}' for the current build architectures ($ARCHS) and platform (${EFFECTIVE_PLATFORM_NAME-${PLATFORM_NAME}})."
+    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
+
+  copy_dir "$source/" "$destination"
+  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.target_name)
+        is_framework = xcframework.build_type.framework?
+        args << shell_escape(is_framework ? 'framework' : 'library')
+        slices.each do |slice|
+          args << shell_escape(slice.path.dirname.relative_path_from(root))
+        end
+        args.join(' ')
+      end
+
+      def variant_for_slice
+        script = ''
+        script << "variant_for_slice()\n"
+        script << "{\n"
+        script << "  case \"$1\" in\n"
+        xcframeworks.each do |xcframework|
+          root = xcframework.path
+          xcframework.slices.each do |slice|
+            script << "  #{shell_escape(root.basename.join(slice.path.dirname.relative_path_from(root)))})\n"
+            script << "    echo \"#{slice.platform_variant}\"\n"
+            script << "    ;;\n"
+          end
+        end
+        script << "  esac\n"
+        script << '}'
+      end
+
+      def archs_for_slice
+        script = ''
+        script << "archs_for_slice()\n"
+        script << "{\n"
+        script << "  case \"$1\" in\n"
+        xcframeworks.each do |xcframework|
+          root = xcframework.path
+          xcframework.slices.each do |slice|
+            script << "  #{shell_escape(root.basename.join(slice.path.dirname.relative_path_from(root)))})\n"
+            script << "    echo \"#{slice.supported_archs.sort.join(' ')}\"\n"
+            script << "    ;;\n"
+          end
+        end
+        script << "  esac\n"
+        script << '}'
+      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-tt/native/generator/dummy_source.rb

@@ -0,0 +1,31 @@
+module Pod
+  module Generator
+    class DummySource
+      attr_reader :class_name
+
+      def initialize(class_name_identifier)
+        validated_class_name_identifier = class_name_identifier.gsub(/[^0-9a-z_]/i, '_')
+        @class_name = "PodsDummy_#{validated_class_name_identifier}"
+      end
+
+      # @return [String] the string contents of the dummy source file.
+      #
+      def generate
+        result = <<-source.strip_heredoc
+          #import <Foundation/Foundation.h>
+          @interface #{class_name} : NSObject
+          @end
+          @implementation #{class_name}
+          @end
+        source
+        result
+      end
+
+      def save_as(pathname)
+        pathname.open('w') do |source|
+          source.write(generate)
+        end
+      end
+    end
+  end
+end

data/lib/cocoapods-tt/native/generator/embed_frameworks_script.rb

@@ -0,0 +1,196 @@
+require 'cocoapods/xcode'
+
+module Pod
+  module Generator
+    class EmbedFrameworksScript
+      # @return [Hash{String => Array<FrameworkPaths>}] Multiple lists of frameworks per
+      #         configuration.
+      #
+      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
+      #
+      # @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.
+      #
+      # @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(0755, 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 embed frameworks script.
+      #
+      def script
+        script = <<-SH.strip_heredoc
+#{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
+        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|
+            target_name = xcframework.target_name
+            name = xcframework.name
+            contents_by_config[config] << %(  install_framework "#{Target::BuildSettings::XCFRAMEWORKS_BUILD_DIR_VARIABLE}/#{target_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
+        if [ "${COCOAPODS_PARALLEL_CODE_SIGN}" == "true" ]; then
+          wait
+        fi
+        SH
+        script
+      end
+
+      # @param  [Xcode::FrameworkPaths] framework_path
+      #         the framework path containing the dSYM
+      #
+      # @return [String, Nil] the name of the dSYM binary, if found
+      #
+      def dsym_binary_name(framework_path)
+        return nil if framework_path.dsym_path.nil?
+        if (path = Pathname.glob(framework_path.dsym_path.join('Contents/Resources/DWARF', '**/*')).first)
+          File.basename(path)
+        end
+      end
+    end
+  end
+end

data/lib/cocoapods-tt/native/generator/file_list.rb

@@ -0,0 +1,39 @@
+module Pod
+  module Generator
+    # Generates an xcfilelist file.
+    #
+    class FileList
+      # @return [Array<String>] The paths of the files in the file list.
+      #
+      attr_reader :paths
+
+      # Initialize a new instance
+      #
+      # @param  [Array<String>] paths
+      #         @see paths
+      #
+      def initialize(paths)
+        @paths = paths
+      end
+
+      # Generates the contents of the file list.
+      #
+      # @return [String]
+      #
+      def generate
+        paths.join("\n")
+      end
+
+      # Generates and saves the file list to the given path.
+      #
+      # @param  [Pathname] path
+      #         The path where the file list should be stored.
+      #
+      # @return [void]
+      #
+      def save_as(path)
+        path.open('w') { |file_list| file_list.write(generate) }
+      end
+    end
+  end
+end

data/lib/cocoapods-tt/native/generator/header.rb

@@ -0,0 +1,103 @@
+module Pod
+  module Generator
+    # Generates a header file.
+    #
+    # According to the platform the header imports `UIKit/UIKit.h` or
+    # `Cocoa/Cocoa.h`.
+    #
+    class Header
+      # @return [Symbol] the platform for which the prefix header will be
+      #         generated.
+      #
+      attr_reader :platform
+
+      # @return [Array<String>] The list of the headers to import.
+      #
+      attr_accessor :imports
+
+      # @return [Array<String>] The list of the modules to import.
+      #
+      attr_reader :module_imports
+
+      # Initialize a new instance
+      #
+      # @param  [Symbol] platform
+      #         @see platform
+      #
+      def initialize(platform)
+        @platform = platform
+        @imports = []
+        @module_imports = []
+      end
+
+      # Generates the contents of the header according to the platform.
+      #
+      # @note   If the platform is iOS an import call to `UIKit/UIKit.h` is
+      #         added to the top of the prefix header. For OS X `Cocoa/Cocoa.h`
+      #         is imported.
+      #
+      # @return [String]
+      #
+      def generate
+        result = ''
+        result << "#ifdef __OBJC__\n"
+        result << generate_platform_import_header
+        result << "#else\n"
+        result << "#ifndef FOUNDATION_EXPORT\n"
+        result << "#if defined(__cplusplus)\n"
+        result << "#define FOUNDATION_EXPORT extern \"C\"\n"
+        result << "#else\n"
+        result << "#define FOUNDATION_EXPORT extern\n"
+        result << "#endif\n"
+        result << "#endif\n"
+        result << "#endif\n"
+        result << "\n"
+
+        imports.each do |import|
+          result << %(#import "#{import}"\n)
+        end
+
+        unless module_imports.empty?
+          module_imports.each do |import|
+            result << %(\n@import #{import})
+          end
+          result << "\n"
+        end
+
+        result
+      end
+
+      # Generates and saves the header to the given path.
+      #
+      # @param  [Pathname] path
+      #         The path where the header should be stored.
+      #
+      # @return [void]
+      #
+      def save_as(path)
+        path.open('w') { |header| header.write(generate) }
+      end
+
+      #-----------------------------------------------------------------------#
+
+      protected
+
+      # Generates the contents of the header according to the platform.
+      #
+      # @note   If the platform is iOS an import call to `UIKit/UIKit.h` is
+      #         added to the top of the header. For OS X `Cocoa/Cocoa.h` is
+      #         imported.
+      #
+      # @return [String]
+      #
+      def generate_platform_import_header
+        case platform.name
+        when :ios then "#import <UIKit/UIKit.h>\n"
+        when :tvos then "#import <UIKit/UIKit.h>\n"
+        when :osx then "#import <Cocoa/Cocoa.h>\n"
+        else "#import <Foundation/Foundation.h>\n"
+        end
+      end
+    end
+  end
+end