DYXCFrameworkBuilder 0.1.0

data/lib/DYXCFrameworkBuilder/podspec_parser.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module DYXCFrameworkBuilder
+  class PodspecParser
+    attr_reader :name, :version, :deployment_target, :podspec_path, :podspec_dir
+
+    def initialize(podspec_path)
+      @podspec_path = File.expand_path(podspec_path)
+      @podspec_dir = File.dirname(@podspec_path)
+
+      unless File.exist?(@podspec_path)
+        raise DYXCFrameworkBuilder::Error, "Podspec file not found: #{@podspec_path}"
+      end
+
+      parse_podspec
+    end
+
+    def find_workspace_path
+      example_dir = File.join(@podspec_dir, 'Example')
+
+      if Dir.exist?(example_dir)
+        # 查找 .xcworkspace 文件
+        workspace_files = Dir.glob(File.join(example_dir, '*.xcworkspace'))
+        return workspace_files.first if workspace_files.any?
+
+        # 如果没有找到 .xcworkspace，查找 .xcodeproj
+        project_files = Dir.glob(File.join(example_dir, '*.xcodeproj'))
+        return project_files.first if project_files.any?
+      end
+
+      raise DYXCFrameworkBuilder::Error, "No workspace or project file found in #{example_dir}"
+    end
+
+    def output_directory
+      File.join(@podspec_dir, 'build')
+    end
+
+    def framework_name
+      "#{@name}.xcframework"
+    end
+
+    def to_yaml_config
+      {
+        'project' => {
+          'path' => find_workspace_path,
+          'scheme' => @name,
+          'target' => @name,
+          'configuration' => 'Release'
+        },
+        'output' => {
+          'directory' => output_directory,
+          'framework_name' => framework_name
+        },
+        'platforms' => {
+          'ios' => {
+            'deployment_target' => @deployment_target || '11.0',
+            'architectures' => ['arm64']
+          },
+          'ios_simulator' => {
+            'deployment_target' => @deployment_target || '11.0',
+            'architectures' => ['arm64', 'x86_64']
+          }
+        },
+        'build_settings' => {
+          'enable_bitcode' => false,
+          'skip_warnings' => true,
+          'swift_version' => '5.0'
+        },
+        'metadata' => {
+          'generated_from_podspec' => @podspec_path,
+          'podspec_version' => @version,
+          'generated_at' => Time.now.strftime('%Y-%m-%d %H:%M:%S')
+        }
+      }
+    end
+
+    private
+
+    def parse_podspec
+      # 读取 podspec 文件内容
+      content = File.read(@podspec_path)
+
+      # 解析 name
+      if match = content.match(/s\.name\s*=\s*['"]([^'"]+)['"]/)
+        @name = match[1]
+      else
+        # 从文件名推断
+        @name = File.basename(@podspec_path, '.podspec')
+      end
+
+      # 解析 version
+      if match = content.match(/s\.version\s*=\s*['"]([^'"]+)['"]/)
+        @version = match[1]
+      end
+
+      # 解析 deployment_target
+      if match = content.match(/s\.ios\.deployment_target\s*=\s*['"]([^'"]+)['"]/)
+        @deployment_target = match[1]
+      elsif match = content.match(/s\.deployment_target\s*=\s*['"]([^'"]+)['"]/)
+        @deployment_target = match[1]
+      end
+
+      validate_parsed_data
+    end
+
+    def validate_parsed_data
+      raise DYXCFrameworkBuilder::Error, "Could not parse name from podspec: #{@podspec_path}" if @name.nil? || @name.empty?
+
+      puts "[INFO] Parsed podspec: #{@name} (#{@version || 'unknown version'})"
+      puts "[INFO] Deployment target: #{@deployment_target || 'using default 11.0'}"
+    end
+  end
+end

data/lib/DYXCFrameworkBuilder/version.rb

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

data/lib/DYXCFrameworkBuilder/xcframework_builder.rb

@@ -0,0 +1,483 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module DYXCFrameworkBuilder
+  # Core XCFramework building logic
+  class CoreBuilder
+    attr_reader :config, :verbose
+
+    def initialize(config, verbose: false)
+      @config = config
+      @verbose = verbose
+    end
+
+    def build
+      log "Building XCFramework from configuration"
+      log "Project: #{@config.project_path}"
+      log "Scheme: #{@config.scheme}"
+      log "Configuration: #{@config.configuration}"
+      log "Output Directory: #{@config.output_dir}"
+
+      # Create output directory
+      FileUtils.mkdir_p(@config.output_dir)
+
+      # Build for each platform
+      frameworks = []
+
+      if @config.platforms['ios']
+        log "Building for iOS device..."
+        ios_framework = build_for_platform('iphoneos', @config.platforms['ios'])
+        frameworks << ios_framework if ios_framework
+      end
+
+      if @config.platforms['ios_simulator']
+        log "Building for iOS Simulator..."
+        sim_framework = build_for_platform('iphonesimulator', @config.platforms['ios_simulator'])
+        frameworks << sim_framework if sim_framework
+      end
+
+      # Create XCFramework
+      if frameworks.any?
+        create_xcframework(frameworks)
+      else
+        raise Error, "No frameworks were built successfully"
+      end
+    end
+
+    private
+
+        def build_for_platform(sdk, platform_config)
+      deployment_target = platform_config['deployment_target'] || '11.0'
+      architectures = filter_architectures_for_sdk(platform_config['architectures'] || ['arm64'], sdk)
+
+      log "Building for #{sdk} with architectures: #{architectures.join(', ')}"
+
+      # Create derived data path
+      derived_data_path = File.join(@config.output_dir, "DerivedData")
+
+      # For modern Xcode, we can build all architectures in one go instead of separate archives
+      if architectures.length == 1 || should_build_universal_archive(sdk)
+        # Build single archive with multiple architectures
+        archive_path = File.join(@config.output_dir, "#{@config.scheme}-#{sdk}.xcarchive")
+
+        build_cmd = build_archive_command(sdk, architectures, deployment_target, archive_path, derived_data_path)
+
+        log "Executing: #{build_cmd}" if @verbose
+
+        success = execute_command(build_cmd)
+
+        if success
+          log "✅ Successfully built archive for #{sdk} with architectures: #{architectures.join(', ')}"
+          framework_path = create_framework_from_archives([archive_path], sdk)
+          return framework_path
+        else
+          log "❌ Failed to build archive for #{sdk}"
+        end
+      else
+        # Fallback: Build separate archives for each architecture
+        archive_paths = []
+
+        architectures.each do |arch|
+          archive_path = File.join(@config.output_dir, "#{@config.scheme}-#{sdk}-#{arch}.xcarchive")
+
+          build_cmd = build_archive_command(sdk, [arch], deployment_target, archive_path, derived_data_path)
+
+          log "Executing: #{build_cmd}" if @verbose
+
+          success = execute_command(build_cmd)
+
+          if success
+            archive_paths << archive_path
+            log "✅ Successfully built archive for #{sdk} #{arch}"
+          else
+            log "❌ Failed to build archive for #{sdk} #{arch}"
+          end
+        end
+
+        if archive_paths.any?
+          # Create framework from archives
+          framework_path = create_framework_from_archives(archive_paths, sdk)
+          return framework_path
+        end
+      end
+
+      nil
+    end
+
+        def build_archive_command(sdk, architectures, deployment_target, archive_path, derived_data_path)
+      # Determine whether to use -workspace or -project based on file extension
+      project_flag, project_path = determine_project_type(@config.project_path)
+
+      # Ensure architectures is an array
+      arch_list = Array(architectures)
+
+      cmd = [
+        "xcodebuild",
+        "archive",
+        project_flag, "\"#{project_path}\"",
+        "-scheme", "\"#{@config.scheme}\"",
+        "-configuration", @config.configuration,
+        "-destination", "\"generic/platform=#{platform_destination(sdk)}\"",
+        "-archivePath", "\"#{archive_path}\"",
+        "-derivedDataPath", "\"#{derived_data_path}\"",
+        "SKIP_INSTALL=NO",
+        "BUILD_LIBRARY_FOR_DISTRIBUTION=YES"
+      ]
+
+      # Add target if specified and different from scheme
+      if @config.target && @config.target != @config.scheme
+        cmd += ["-target", "\"#{@config.target}\""]
+      end
+
+      # Add architectures if multiple specified
+      if arch_list.length > 1
+        cmd << "ARCHS=#{arch_list.join(' ')}"
+        cmd << "VALID_ARCHS=#{arch_list.join(' ')}"
+      elsif arch_list.length == 1
+        cmd << "ARCHS=#{arch_list.first}"
+        cmd << "VALID_ARCHS=#{arch_list.first}"
+      end
+
+      # Add deployment target
+      case sdk
+      when 'iphoneos', 'iphonesimulator'
+        cmd << "IPHONEOS_DEPLOYMENT_TARGET=#{deployment_target}"
+      end
+
+      # Skip warnings if configured
+      if @config.skip_warnings
+        cmd << "GCC_WARN_INHIBIT_ALL_WARNINGS=YES"
+        cmd << "SWIFT_SUPPRESS_WARNINGS=YES"
+        cmd << "CLANG_WARN_DOCUMENTATION_COMMENTS=NO"
+        cmd << "CLANG_WARN_QUOTED_INCLUDE_IN_FRAMEWORK_HEADER=NO"
+      end
+
+      # Disable bitcode if configured
+      unless @config.enable_bitcode
+        cmd << "ENABLE_BITCODE=NO"
+      end
+
+      # Additional build settings for better compatibility
+      cmd << "ONLY_ACTIVE_ARCH=NO"
+      cmd << "DEFINES_MODULE=YES"
+
+      cmd.join(" ")
+    end
+
+    def platform_destination(sdk)
+      case sdk
+      when 'iphoneos'
+        'iOS'
+      when 'iphonesimulator'
+        'iOS Simulator'
+      else
+        sdk
+      end
+    end
+
+    def determine_project_type(project_path)
+      case File.extname(project_path).downcase
+      when '.xcworkspace'
+        ['-workspace', project_path]
+      when '.xcodeproj'
+        ['-project', project_path]
+      else
+        # Default to workspace if no extension or unknown extension
+        # Most modern iOS projects use workspaces
+        if File.exist?("#{project_path}.xcworkspace")
+          ['-workspace', "#{project_path}.xcworkspace"]
+        elsif File.exist?("#{project_path}.xcodeproj")
+          ['-project', "#{project_path}.xcodeproj"]
+        else
+          # Assume workspace as default for modern projects
+          ['-workspace', project_path]
+        end
+      end
+    end
+
+    def filter_architectures_for_sdk(architectures, sdk)
+      case sdk
+      when 'iphoneos'
+        # iOS device: only arm64
+        architectures.select { |arch| ['arm64'].include?(arch) }
+      when 'iphonesimulator'
+        # iOS simulator: arm64 and x86_64
+        architectures.select { |arch| ['arm64', 'x86_64'].include?(arch) }
+      else
+        architectures
+      end
+    end
+
+    def should_build_universal_archive(sdk)
+      # Modern Xcode can build universal archives in one go for most cases
+      true
+    end
+
+                def fix_framework_binary_name(framework_path, sdk)
+      # Keep the original scheme name for the binary (no SDK suffix)
+      target_binary_path = File.join(framework_path, @config.scheme)
+
+      # Check if binary already exists with correct name
+      if File.exist?(target_binary_path)
+        log "✅ Framework binary verified: #{target_binary_path}" if @verbose
+      else
+        # Try to find any binary file in the framework and rename it
+        found_binary = false
+        Dir.glob(File.join(framework_path, "*")).each do |file|
+          next if File.directory?(file)
+          next if File.extname(file) != ""  # Skip files with extensions
+          next if file.include?('Info.plist')
+
+          # Check if it's likely a binary file
+          if File.executable?(file) || File.size(file) > 1024  # Assume binary if executable or large enough
+            log "Renaming binary from #{File.basename(file)} to #{@config.scheme}" if @verbose
+            FileUtils.mv(file, target_binary_path)
+            found_binary = true
+            break
+          end
+        end
+
+        unless found_binary
+          log "❌ Warning: No binary found in framework: #{framework_path}"
+          return nil
+        end
+      end
+
+      # Verify the binary file exists and has correct permissions
+      if File.exist?(target_binary_path)
+        FileUtils.chmod(0755, target_binary_path) unless File.executable?(target_binary_path)
+        log "✅ Framework binary ready: #{target_binary_path}" if @verbose
+        return target_binary_path
+      end
+
+      nil
+    end
+
+    def update_framework_references(framework_path, old_name, new_name)
+      # Update Info.plist if it exists
+      info_plist_path = File.join(framework_path, 'Info.plist')
+      if File.exist?(info_plist_path)
+        content = File.read(info_plist_path)
+        updated_content = content.gsub(old_name, new_name)
+        File.write(info_plist_path, updated_content) if content != updated_content
+      end
+
+      # Update module.modulemap if it exists
+      modulemap_paths = [
+        File.join(framework_path, 'Modules', 'module.modulemap'),
+        File.join(framework_path, 'Headers', 'module.modulemap')
+      ]
+
+      modulemap_paths.each do |modulemap_path|
+        if File.exist?(modulemap_path)
+          content = File.read(modulemap_path)
+          updated_content = content.gsub(/framework module #{old_name}/, "framework module #{new_name}")
+          File.write(modulemap_path, updated_content) if content != updated_content
+        end
+      end
+    end
+
+    def create_framework_from_archives(archive_paths, sdk)
+      log "Creating framework from #{archive_paths.length} archive(s) for #{sdk}"
+
+      # Use temporary SDK-specific name during build, will be renamed for XCFramework
+      temp_framework_path = File.join(@config.output_dir, "#{@config.scheme}-#{sdk}.framework")
+
+      # Remove existing framework if it exists
+      FileUtils.rm_rf(temp_framework_path) if File.exist?(temp_framework_path)
+
+      if archive_paths.length == 1
+        # Single architecture - just copy the framework
+                archive_framework_path = find_framework_in_archive(archive_paths.first)
+        if archive_framework_path && File.exist?(archive_framework_path)
+          FileUtils.cp_r(archive_framework_path, temp_framework_path)
+
+          # Rename to final framework name
+          final_framework_path = File.join(@config.output_dir, "#{@config.scheme}.framework")
+          FileUtils.rm_rf(final_framework_path) if File.exist?(final_framework_path)
+          FileUtils.mv(temp_framework_path, final_framework_path)
+
+          # Fix binary name to use scheme name
+          fix_framework_binary_name(final_framework_path, sdk)
+
+          log "✅ Created framework: #{final_framework_path}"
+          return final_framework_path
+        end
+      else
+        # Multiple architectures - create universal binary
+        log "Creating universal framework for #{sdk}..."
+        universal_framework_path = create_universal_framework(archive_paths, sdk)
+        return universal_framework_path if universal_framework_path
+      end
+
+      log "⚠️  Warning: Could not find framework in archives for #{sdk}"
+      nil
+    end
+
+    def find_framework_in_archive(archive_path)
+      # Try different possible paths for the framework in the archive
+      possible_paths = [
+        File.join(archive_path, "Products/Library/Frameworks/#{@config.scheme}.framework"),
+        File.join(archive_path, "Products/@rpath/#{@config.scheme}.framework"),
+        File.join(archive_path, "Products/usr/local/lib/#{@config.scheme}.framework")
+      ]
+
+      possible_paths.each do |path|
+        return path if File.exist?(path)
+      end
+
+      # If not found, search recursively
+      framework_name = "#{@config.scheme}.framework"
+      Dir.glob(File.join(archive_path, "**/#{framework_name}")).first
+    end
+
+        def create_universal_framework(archive_paths, sdk)
+      log "Creating universal binary for multiple architectures"
+
+      # Use temporary SDK-specific name during build
+      temp_framework_path = File.join(@config.output_dir, "#{@config.scheme}-#{sdk}.framework")
+      temp_frameworks = []
+      binary_architectures = []
+
+      # Extract all frameworks and check architectures
+      archive_paths.each_with_index do |archive_path, index|
+        archive_framework_path = find_framework_in_archive(archive_path)
+        if archive_framework_path && File.exist?(archive_framework_path)
+          temp_framework_path = File.join(@config.output_dir, "temp_#{sdk}_#{index}.framework")
+          FileUtils.cp_r(archive_framework_path, temp_framework_path)
+
+          # Check binary architecture
+          binary_path = File.join(temp_framework_path, @config.scheme)
+          if File.exist?(binary_path)
+            arch_info = `lipo -info "#{binary_path}" 2>/dev/null`.strip
+            log "Framework #{index} architecture: #{arch_info}" if @verbose
+
+            # Extract architecture from lipo output
+            if arch_info.include?(":")
+              arch = arch_info.split(":").last.strip
+              unless binary_architectures.include?(arch)
+                binary_architectures << arch
+                temp_frameworks << temp_framework_path
+              else
+                log "⚠️  Skipping duplicate architecture: #{arch}"
+                FileUtils.rm_rf(temp_framework_path)
+              end
+            else
+              temp_frameworks << temp_framework_path
+            end
+          else
+            temp_frameworks << temp_framework_path
+          end
+        end
+      end
+
+      if temp_frameworks.empty?
+        log "❌ No frameworks found in archives"
+        return nil
+      end
+
+      # Use the first framework as base
+      base_framework = temp_frameworks.first
+      FileUtils.cp_r(base_framework, temp_framework_path)
+
+      # Create universal binary if we have multiple frameworks with different architectures
+      if temp_frameworks.length > 1
+        # Use the original scheme name for the binary
+        binary_path = File.join(temp_framework_path, @config.scheme)
+        all_binaries = temp_frameworks.map { |fw| File.join(fw, @config.scheme) }.select { |b| File.exist?(b) }
+
+        if all_binaries.length > 1
+          # Use lipo to create universal binary
+          lipo_cmd = "lipo -create #{all_binaries.map { |b| "\"#{b}\"" }.join(' ')} -output \"#{binary_path}\""
+
+          log "Creating universal binary: #{lipo_cmd}" if @verbose
+
+          if execute_command(lipo_cmd)
+            log "✅ Successfully created universal framework with architectures: #{binary_architectures.join(', ')}"
+          else
+            log "⚠️  Warning: Failed to create universal binary, using single architecture"
+          end
+        else
+          log "✅ Using single architecture framework"
+        end
+      else
+        log "✅ Using single framework (only one valid architecture)"
+      end
+
+            # Clean up temporary frameworks
+      temp_frameworks.each { |fw| FileUtils.rm_rf(fw) }
+
+      # Rename to final framework name
+      final_framework_path = File.join(@config.output_dir, "#{@config.scheme}.framework")
+      FileUtils.rm_rf(final_framework_path) if File.exist?(final_framework_path)
+      FileUtils.mv(temp_framework_path, final_framework_path)
+
+      # Fix binary name to use scheme name
+      fix_framework_binary_name(final_framework_path, sdk)
+
+      final_framework_path
+    end
+
+    def create_xcframework(frameworks)
+      xcframework_path = File.join(@config.output_dir, @config.framework_name)
+
+      log "Creating XCFramework at: #{xcframework_path}"
+
+      # Remove existing xcframework if it exists
+      FileUtils.rm_rf(xcframework_path) if File.exist?(xcframework_path)
+
+      cmd = [
+        "xcodebuild",
+        "-create-xcframework"
+      ]
+
+      frameworks.each do |framework|
+        cmd << "-framework" << "\"#{framework}\""
+      end
+
+      cmd << "-output" << "\"#{xcframework_path}\""
+
+      build_cmd = cmd.join(" ")
+      log "Executing: #{build_cmd}" if @verbose
+
+      success = execute_command(build_cmd)
+
+      if success
+        # Verify the XCFramework was created
+        if File.exist?(xcframework_path)
+          log "🎉 Successfully created XCFramework: #{xcframework_path}"
+
+          # Show XCFramework info
+          info_cmd = "xcodebuild -checkFirstLaunchForXcode"
+          execute_command("#{info_cmd} > /dev/null 2>&1") # Suppress output
+
+          # Clean up intermediate frameworks
+          frameworks.each { |fw| FileUtils.rm_rf(fw) }
+
+          return xcframework_path
+        else
+          raise Error, "XCFramework was not created at expected path: #{xcframework_path}"
+        end
+      else
+        raise Error, "Failed to create XCFramework"
+      end
+    end
+
+    def execute_command(command)
+      if @verbose
+        system(command)
+      else
+        system("#{command} > /dev/null 2>&1")
+      end
+    end
+
+    def log(message)
+      if @verbose
+        puts "[INFO] #{message}"
+      else
+        puts message
+      end
+    end
+  end
+end