xcframework_converter 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 261230f022e462a9840a009590e212c543833902b44795f80476971ff828dae7
+  data.tar.gz: 5a383fe7e654d79ea3d292a6369e4ba1d1b177c03f8967c9d6ec4fca2d942563
+SHA512:
+  metadata.gz: c284b721156bc30b0e818d8048513c023c2e931cb659d7211959f356c08f36f133a61494078edb35b24b490ccd6b15b5c71d7c61b1a42b6da14adab664517700
+  data.tar.gz: 2be83f317ea5fa0e2e108ac81cbfbfaf1095c5738559555fafabcf0f215efaf1c08308f6f01b6fd337b1a190bc319367c7634e6a00a73a0ccbf029edd7471683

data/README.md

@@ -0,0 +1,43 @@
+# XcframeworkConverter
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/xcframework_converter`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'xcframework_converter'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install xcframework_converter
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/xcframework_converter. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/[USERNAME]/xcframework_converter/blob/master/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the XcframeworkConverter project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/xcframework_converter/blob/master/CODE_OF_CONDUCT.md).

data/bin/xcfconvert

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'xcframework_converter'
+
+if ARGV.empty?
+  warn 'Usage: xcfconvert <path/to/Framework.framework>'
+  exit 1
+end
+
+XCFrameworkConverter.convert_framework_to_xcframework(Pathname.new(ARGV[0]).realpath)

data/lib/arm2sim.swift

@@ -0,0 +1,166 @@
+import Foundation
+import MachO
+
+// support checking for Mach-O `cmd` and `cmdsize` properties
+extension Data {
+    var loadCommand: UInt32 {
+        let lc: load_command = withUnsafeBytes { $0.load(as: load_command.self) }
+        return lc.cmd
+    }
+    
+    var commandSize: Int {
+        let lc: load_command = withUnsafeBytes { $0.load(as: load_command.self) }
+        return Int(lc.cmdsize)
+    }
+    
+    func asStruct<T>(fromByteOffset offset: Int = 0) -> T {
+        return withUnsafeBytes { $0.load(fromByteOffset: offset, as: T.self) }
+    }
+}
+
+extension Array where Element == Data {
+    func merge() -> Data {
+        return reduce(into: Data()) { $0.append($1) }
+    }
+}
+
+// support peeking at Data contents
+extension FileHandle {
+    func peek(upToCount count: Int) throws -> Data? {
+        // persist the current offset, since `upToCount` doesn't guarantee all bytes will be read
+        let originalOffset = offsetInFile
+        let data = try read(upToCount: count)
+        try seek(toOffset: originalOffset)
+        return data
+    }
+}
+
+enum Transmogrifier {
+    private static func readBinary(atPath path: String) -> (Data, [Data], Data) {
+        guard let handle = FileHandle(forReadingAtPath: path) else {
+            fatalError("Cannot open a handle for the file at \(path). Aborting.")
+        }
+        
+        // chop up the file into a relevant number of segments
+        let headerData = try! handle.read(upToCount: MemoryLayout<mach_header_64>.stride)!
+        
+        let header: mach_header_64 = headerData.asStruct()
+        if header.magic != MH_MAGIC_64 || header.cputype != CPU_TYPE_ARM64 {
+            fatalError("The file is not a correct arm64 binary. Try thinning (via lipo) or unarchiving (via ar) first.")
+        }
+        
+        let loadCommandsData: [Data] = (0..<header.ncmds).map { _ in
+            let loadCommandPeekData = try! handle.peek(upToCount: MemoryLayout<load_command>.stride)
+            return try! handle.read(upToCount: Int(loadCommandPeekData!.commandSize))!
+        }
+        
+        let programData = try! handle.readToEnd()!
+        
+        try! handle.close()
+        
+        return (headerData, loadCommandsData, programData)
+    }
+    
+    private static func updateSegment64(_ data: Data, _ offset: UInt32) -> Data {
+        // decode both the segment_command_64 and the subsequent section_64s
+        var segment: segment_command_64 = data.asStruct()
+        
+        let sections: [section_64] = (0..<Int(segment.nsects)).map { index in
+            let offset = MemoryLayout<segment_command_64>.stride + index * MemoryLayout<section_64>.stride
+            return data.asStruct(fromByteOffset: offset)
+        }
+        
+        // shift segment information by the offset
+        segment.fileoff += UInt64(offset)
+        segment.filesize += UInt64(offset)
+        segment.vmsize += UInt64(offset)
+        
+        let offsetSections = sections.map { section -> section_64 in
+            var section = section
+            section.offset += UInt32(offset)
+            section.reloff += section.reloff > 0 ? UInt32(offset) : 0
+            return section
+        }
+        
+        var datas = [Data]()
+        datas.append(Data(bytes: &segment, count: MemoryLayout<segment_command_64>.stride))
+        datas.append(contentsOf: offsetSections.map { section in
+            var section = section
+            return Data(bytes: &section, count: MemoryLayout<section_64>.stride)
+        })
+        
+        return datas.merge()
+    }
+    
+    private static func updateVersionMin(_ data: Data, _ offset: UInt32, minos: UInt32, sdk: UInt32) -> Data {
+        var command = build_version_command(cmd: UInt32(LC_BUILD_VERSION),
+                                            cmdsize: UInt32(MemoryLayout<build_version_command>.stride),
+                                            platform: UInt32(PLATFORM_IOSSIMULATOR),
+                                            minos: minos << 16 | 0 << 8 | 0,
+                                            sdk: sdk << 16 | 0 << 8 | 0,
+                                            ntools: 0)
+        
+        return Data(bytes: &command, count: MemoryLayout<build_version_command>.stride)
+    }
+    
+    private static func updateDataInCode(_ data: Data, _ offset: UInt32) -> Data {
+        var command: linkedit_data_command = data.asStruct()
+        command.dataoff += offset
+        return Data(bytes: &command, count: data.commandSize)
+    }
+    
+    private static func updateSymTab(_ data: Data, _ offset: UInt32) -> Data {
+        var command: symtab_command = data.asStruct()
+        command.stroff += offset
+        command.symoff += offset
+        return Data(bytes: &command, count: data.commandSize)
+    }
+    
+    static func processBinary(atPath path: String, minos: UInt32 = 13, sdk: UInt32 = 13) {
+        guard CommandLine.arguments.count > 1 else {
+            fatalError("Please add a path to command!")
+        }
+        let (headerData, loadCommandsData, programData) = readBinary(atPath: path)
+        
+        // `offset` is kind of a magic number here, since we know that's the only meaningful change to binary size
+        // having a dynamic `offset` requires two passes over the load commands and is left as an exercise to the reader
+        let offset = UInt32(abs(MemoryLayout<build_version_command>.stride - MemoryLayout<version_min_command>.stride))
+        
+        let editedCommandsData = loadCommandsData
+            .map { (lc) -> Data in
+                switch Int32(lc.loadCommand) {
+                case LC_SEGMENT_64:
+                    return updateSegment64(lc, offset)
+                case LC_VERSION_MIN_IPHONEOS:
+                    return updateVersionMin(lc, offset, minos: minos, sdk: sdk)
+                case LC_DATA_IN_CODE, LC_LINKER_OPTIMIZATION_HINT:
+                    return updateDataInCode(lc, offset)
+                case LC_SYMTAB:
+                    return updateSymTab(lc, offset)
+                case LC_BUILD_VERSION:
+                    fatalError("This arm64 binary already contains an LC_BUILD_VERSION load command!")
+                default:
+                    return lc
+                }
+            }
+            .merge()
+        
+        var header: mach_header_64 = headerData.asStruct()
+        header.sizeofcmds = UInt32(editedCommandsData.count)
+        
+        // reassemble the binary
+        let reworkedData = [
+            Data(bytes: &header, count: MemoryLayout<mach_header_64>.stride),
+            editedCommandsData,
+            programData
+        ].merge()
+        
+        // save back to disk
+        try! reworkedData.write(to: URL(fileURLWithPath: path))
+    }
+}
+
+let binaryPath = CommandLine.arguments[1]
+let minos = UInt32(CommandLine.arguments[2]) ?? 13
+let sdk = UInt32(CommandLine.arguments[3]) ?? 13
+Transmogrifier.processBinary(atPath: binaryPath, minos: minos, sdk: sdk)

data/lib/xcframework_converter.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require_relative 'xcframework_converter/version'
+
+require 'cocoapods'
+require 'cocoapods/xcode/xcframework'
+require 'fileutils'
+require 'xcodeproj'
+
+# rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+# Converts a framework (static or dynamic) to XCFrameworks, adding an arm64 simulator patch.
+# For more info:
+# static libs: https://bogo.wtf/arm64-to-sim.html
+# dylibs: https://bogo.wtf/arm64-to-sim-dylibs.html
+module XCFrameworkConverter
+  class << self
+    def convert_frameworks_to_xcframeworks!(installer)
+      installer.analysis_result.specifications.each do |spec|
+        next unless spec.attributes_hash['vendored_frameworks']
+
+        frameworks = Array(spec.attributes_hash['vendored_frameworks'])
+        unconverted_frameworks = frameworks.select { |f| File.extname(f) == '.framework' }
+        next if unconverted_frameworks.empty?
+        next if spec.local?
+
+        pod_path = installer.sandbox.pod_dir(Pod::Specification.root_name(spec.name))
+        convert_xcframeworks_if_present(pod_path)
+
+        converted_frameworks = unconverted_frameworks.map do |path|
+          Pathname.new(path).sub_ext('.xcframework').to_s
+        end
+        spec.attributes_hash['vendored_frameworks'] = frameworks - unconverted_frameworks + converted_frameworks
+        # some pods put these as a way to NOT support arm64 sim
+        spec.attributes_hash['pod_target_xcconfig']&.delete('EXCLUDED_ARCHS[sdk=iphonesimulator*]')
+        spec.attributes_hash['user_target_xcconfig']&.delete('EXCLUDED_ARCHS[sdk=iphonesimulator*]')
+      end
+    end
+
+    def convert_xcframeworks_if_present(pod_path)
+      unconverted_paths = Dir[pod_path.join('**/*.framework')] - Dir[pod_path.join('**/*.xcframework/**/*')]
+      unconverted_paths.each do |path|
+        convert_framework_to_xcframework(path)
+      end
+    end
+
+    def plist_template_path
+      Pathname.new(__FILE__).dirname.join('xcframework_template.plist')
+    end
+
+    def convert_framework_to_xcframework(path)
+      plist = Xcodeproj::Plist.read_from_path(plist_template_path)
+      xcframework_path = Pathname.new(path).sub_ext('.xcframework')
+      xcframework_path.mkdir
+      plist['AvailableLibraries'].each do |slice|
+        slice_path = xcframework_path.join(slice['LibraryIdentifier'])
+        slice_path.mkdir
+        slice['LibraryPath'] = File.basename(path)
+        FileUtils.cp_r(path, slice_path)
+      end
+      Xcodeproj::Plist.write_to_path(plist, xcframework_path.join('Info.plist'))
+      FileUtils.rm_rf(path)
+      final_framework = Pod::Xcode::XCFramework.new(xcframework_path.realpath)
+      final_framework.slices.each do |slice|
+        patch_arm_binary(slice) if slice.platform == :ios && slice.platform_variant == :simulator
+        cleanup_unused_archs(slice)
+      end
+    end
+
+    def patch_arm_binary(slice)
+      require 'macho'
+
+      case slice.build_type.linkage
+      when :dynamic
+        patch_arm_binary_dynamic(slice)
+      when :static
+        patch_arm_binary_static(slice)
+      end
+    end
+
+    def patch_arm_binary_dynamic(slice)
+      extracted_path = slice.path.join('arm64.dylib')
+      `xcrun lipo \"#{slice.binary_path}\" -thin arm64 -output \"#{extracted_path}\"`
+
+      file = MachO::MachOFile.new(extracted_path)
+      sdk_version = file[:LC_VERSION_MIN_IPHONEOS].first.version_string
+      `xcrun vtool -arch arm64 -set-build-version 7 #{sdk_version} #{sdk_version} -replace -output \"#{extracted_path}\" \"#{extracted_path}\"`
+      `xcrun lipo \"#{slice.binary_path}\" -replace arm64 \"#{extracted_path}\" -output \"#{slice.binary_path}\"`
+      extracted_path.rmtree
+    end
+
+    def arm2sim_path
+      Pathname.new(__FILE__).dirname.join('arm2sim.swift')
+    end
+
+    def patch_arm_binary_static(slice)
+      extracted_path = slice.path.join('arm64.a')
+      `xcrun lipo \"#{slice.binary_path}\" -thin arm64 -output \"#{extracted_path}\"`
+      extracted_path_dir = slice.path.join('arm64-objects')
+      extracted_path_dir.mkdir
+      `cd \"#{extracted_path_dir}\" ; ar x \"#{extracted_path}\"`
+      Dir[extracted_path_dir.join('*.o')].each do |object_file|
+        file = MachO::MachOFile.new(object_file)
+        sdk_version = file[:LC_VERSION_MIN_IPHONEOS].first.version_string.to_i
+        `xcrun swift \"#{arm2sim_path}\" \"#{object_file}\" \"#{sdk_version}\" \"#{sdk_version}\"`
+      end
+      `cd \"#{extracted_path_dir}\" ; ar crv \"#{extracted_path}\" *.o`
+
+      `xcrun lipo \"#{slice.binary_path}\" -replace arm64 \"#{extracted_path}\" -output \"#{slice.binary_path}\"`
+      extracted_path_dir.rmtree
+      extracted_path.rmtree
+    end
+
+    def cleanup_unused_archs(slice)
+      supported_archs = slice.supported_archs
+      unsupported_archs = `xcrun lipo \"#{slice.binary_path}\" -archs`.split - supported_archs
+      unsupported_archs.each do |arch|
+        `xcrun lipo \"#{slice.binary_path}\" -remove \"#{arch}\" -output \"#{slice.binary_path}\"`
+      end
+    end
+  end
+end
+
+# rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity

data/lib/xcframework_converter/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module XCFrameworkConverter
+  VERSION = '0.1.0'
+end

data/lib/xcframework_template.plist

@@ -0,0 +1,41 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>AvailableLibraries</key>
+	<array>
+		<dict>
+			<key>LibraryIdentifier</key>
+			<string>ios-arm64_x86_64-simulator</string>
+			<key>LibraryPath</key>
+			<string>Placeholder.framework</string>
+			<key>SupportedArchitectures</key>
+			<array>
+				<string>arm64</string>
+				<string>x86_64</string>
+			</array>
+			<key>SupportedPlatform</key>
+			<string>ios</string>
+			<key>SupportedPlatformVariant</key>
+			<string>simulator</string>
+		</dict>
+		<dict>
+			<key>LibraryIdentifier</key>
+			<string>ios-arm64_armv7</string>
+			<key>LibraryPath</key>
+			<string>Placeholder.framework</string>
+			<key>SupportedArchitectures</key>
+			<array>
+				<string>arm64</string>
+				<string>armv7</string>
+			</array>
+			<key>SupportedPlatform</key>
+			<string>ios</string>
+		</dict>
+	</array>
+	<key>CFBundlePackageType</key>
+	<string>XFWK</string>
+	<key>XCFrameworkFormatVersion</key>
+	<string>1.0</string>
+</dict>
+</plist>

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: xcframework_converter
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Igor Makarov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-07-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: cocoapods
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.10.0
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.10.0
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: xcodeproj
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.20.0
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.20.0
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+description: Convert an ancient .framework (dynamic or static) to an .xcframework.
+  Add an arm64 Simulator patch.
+email:
+- igormaka@gmail.com
+executables:
+- xcfconvert
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- bin/xcfconvert
+- lib/arm2sim.swift
+- lib/xcframework_converter.rb
+- lib/xcframework_converter/version.rb
+- lib/xcframework_template.plist
+homepage: https://github.com/igor-makarov/XCFrameworkConverter
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/igor-makarov/XCFrameworkConverter
+  source_code_uri: https://github.com/igor-makarov/XCFrameworkConverter
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.4
+signing_key: 
+specification_version: 4
+summary: Convert an ancient .framework to an .xcframework.
+test_files: []