fastlane-plugin-mobile_tools 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 26fdd7808252e393694a368045c09ebe1a09ec33bb520a6d0d91178a6150bfc8
-  data.tar.gz: 7ee6768f01189eabd2cd7fef32ebf6022e32c088eb5438cd3b0abbc78078c29e
+  metadata.gz: 8b8d5653d4f3f3b10d79db61208cd9f31b0fd9a30bd048303897e246d349120b
+  data.tar.gz: ece53b29c54071b28807c757c0c1157ae53846e09463e719b1c2ec3d4ee9b7d8
 SHA512:
-  metadata.gz: e707b3d692c424b21636fb67c2f78ebbb1e67a2f62a40627744dc63320cd3d229f91c3ed7b523d6e06945d3e81081eecaf5f762293e805c650da0f0815ca191c
-  data.tar.gz: def0229a1e8caca4a092fb46bb285d7fb6eba8b54582a749d0323591d72b150c29e056f228aea52a17d62b2c41d81e67e7a6920d3b275c9896d62f9effedd296
+  metadata.gz: 0a6d6a9d84e45d400121a5bb9fa9b4c99bffa221656fce87c80813db1acfdff46edc589139afe1e02289156fbfb9677aecba7580416dff37e5c8c285b9e023a9
+  data.tar.gz: c0bb6fb42a97af43acdb7c2a6e39e2fa3edea90737fa0b4520b4fb395d0b2364fb87adb5f9fc59c117140b213d2db884afb93d186957b435ffbba23f403ddf4b

data/lib/fastlane/plugin/mobile_tools/actions/create_xcframework_action.rb

@@ -26,6 +26,11 @@ module Fastlane
           end
 
           create_xcframework(params)
+          
+          remove_module_reference(params)
+          sign_xcframework(params)
+          zip_xcframework(params)
+          delete_xcframework(params)
 
           copy_dSYMs(params)
 
@@ -33,19 +38,28 @@ module Fastlane
 
           clean(params)
 
-          provide_shared_values
+          
+
+          provide_shared_values(params)
         else
           UI.important('xcframework can be produced only using Xcode 11 and above')
         end
       end
 
-      def self.provide_shared_values
-        Actions.lane_context[SharedValues::XCFRAMEWORK_OUTPUT_PATH] = File.expand_path(@xchelper.xcframework_path)
-        ENV[SharedValues::XCFRAMEWORK_OUTPUT_PATH.to_s] = File.expand_path(@xchelper.xcframework_path)
-        Actions.lane_context[SharedValues::XCFRAMEWORK_DSYM_OUTPUT_PATH] = File.expand_path(@xchelper.xcframework_dSYMs_path)
-        ENV[SharedValues::XCFRAMEWORK_DSYM_OUTPUT_PATH.to_s] = File.expand_path(@xchelper.xcframework_dSYMs_path)
-        Actions.lane_context[SharedValues::XCFRAMEWORK_BCSYMBOLMAPS_OUTPUT_PATH] = File.expand_path(@xchelper.xcframework_BCSymbolMaps_path)
-        ENV[SharedValues::XCFRAMEWORK_BCSYMBOLMAPS_OUTPUT_PATH.to_s] = File.expand_path(@xchelper.xcframework_BCSymbolMaps_path)
+      def self.provide_shared_values(params)
+        frameworks = params[:frameworks] || [nil]
+        frameworks.each do |framework|
+          xcframework_path = framework ? @xchelper.get_xcframework_path(framework) : @xchelper.xcframework_path
+          dsyms_path = framework ? @xchelper.framework_dSYMs_path(framework) : @xchelper.xcframework_dSYMs_path
+          bcsymbolmaps_path = framework ? @xchelper.framework_BCSymbolMaps_path(framework) : @xchelper.xcframework_BCSymbolMaps_path
+      
+          Actions.lane_context[SharedValues::XCFRAMEWORK_OUTPUT_PATH] = File.expand_path(xcframework_path)
+          ENV[SharedValues::XCFRAMEWORK_OUTPUT_PATH.to_s] = File.expand_path(xcframework_path)
+          Actions.lane_context[SharedValues::XCFRAMEWORK_DSYM_OUTPUT_PATH] = File.expand_path(dsyms_path)
+          ENV[SharedValues::XCFRAMEWORK_DSYM_OUTPUT_PATH.to_s] = File.expand_path(dsyms_path)
+          Actions.lane_context[SharedValues::XCFRAMEWORK_BCSYMBOLMAPS_OUTPUT_PATH] = File.expand_path(bcsymbolmaps_path)
+          ENV[SharedValues::XCFRAMEWORK_BCSYMBOLMAPS_OUTPUT_PATH.to_s] = File.expand_path(bcsymbolmaps_path)
+        end
       end
 
       def self.clean(params)
@@ -53,73 +67,232 @@ module Fastlane
       end
 
       def self.create_xcframework(params)
-        xcframework = @xchelper.xcframework_path
-        begin
-          FileUtils.rm_rf(xcframework) if File.exist?(xcframework)
-
-          arguments = ['-create-xcframework']
-          arguments << '-allow-internal-distribution' if params[:allow_internal_distribution]
-          params[:destinations].each_with_index do |_, index|
-            arguments << "-framework #{@xchelper.xcarchive_framework_path(index)}"
-            arguments << debug_symbols(index: index, params: params)
+        UI.message("params: #{params}")
+
+        if params[:frameworks]
+          params[:frameworks].each do |framework|
+            UI.message("▸ Creating xcframework for #{framework}")
+            xcframework = @xchelper.get_xcframework_path(framework)
+            UI.message("▸ Creating xcframework for #{framework} at path: #{xcframework}")
+            begin
+              FileUtils.rm_rf(xcframework) if File.exist?(xcframework)
+      
+              arguments = ['-create-xcframework']
+              arguments << '-allow-internal-distribution' if params[:allow_internal_distribution]
+      
+              params[:destinations].each_with_index do |_, index|
+                arguments << "-framework #{@xchelper.get_xcarchive_framework_path(index, framework)}"
+                arguments << debug_symbols(index: index, params: params, framework: framework)
+              end
+              arguments << "-output #{xcframework}"
+              UI.message("set -o pipefail && xcodebuild #{arguments.reject(&:empty?).join(' ')}")
+
+              Actions.sh("set -o pipefail && xcodebuild #{arguments.reject(&:empty?).join(' ')}")
+            rescue StandardError => e
+              UI.user_error!(e)
+            end
           end
-          arguments << "-output #{xcframework}"
+        else
+          xcframework = @xchelper.xcframework_path
+          UI.message("▸ Creating xcframework at path: #{xcframework}")
+          begin
+            FileUtils.rm_rf(xcframework) if File.exist?(xcframework)
+      
+            arguments = ['-create-xcframework']
+            arguments << '-allow-internal-distribution' if params[:allow_internal_distribution]
+      
+            params[:destinations].each_with_index do |_, index|
+              arguments << "-framework #{@xchelper.xcarchive_framework_path(index)}"
+              arguments << debug_symbols(index: index, params: params, framework: @xchelper.framework)
+            end
+            arguments << "-output #{xcframework}"
+      
+            Actions.sh("set -o pipefail && xcodebuild #{arguments.reject(&:empty?).join(' ')}")
+          rescue StandardError => e
+            UI.user_error!(e)
+          end
+        end
+      end
 
-          Actions.sh("set -o pipefail && xcodebuild #{arguments.reject(&:empty?).join(' ')}")
-        rescue StandardError => e
-          UI.user_error!(e)
+      def self.sign_xcframework(params)
+        return if params[:code_sign_identity].nil? || params[:code_sign_identity] == false
+      
+        frameworks = params[:frameworks] || [nil]
+      
+        frameworks.each do |framework|
+          xcframework = framework ? @xchelper.get_xcframework_path(framework) : @xchelper.xcframework_path
+          UI.message("▸ Signing xcframework with '#{params[:code_sign_identity]}' at path: #{xcframework}")
+      
+          begin
+            command = "codesign --force --sign '#{params[:code_sign_identity]}' --timestamp=none #{xcframework}"
+            UI.message(command)
+            Actions.sh(command)
+          rescue StandardError => e
+            UI.user_error!(e)
+          end
         end
       end
 
-      def self.debug_symbols(index:, params:)
-        return '' if !Helper.xcode_at_least?('12.0.0') || params[:include_debug_symbols] == false
+      require 'tmpdir'
+      def self.zip_xcframework(params)
+        return if params[:zip_xcframework].nil? || params[:zip_xcframework] == false
 
-        debug_symbols = []
+        # Check if the zip utility is installed
+        unless system("which zip > /dev/null 2>&1")
+          UI.important("zip utility is not installed. Installing...")
+          system("brew install zip") || UI.crash!("Error: Failed to install zip utility")
+        end
+
+        frameworks = params[:frameworks] || [nil]
+
+        if params[:combine_all_zip]
+          Dir.mktmpdir do |tmpdir|
+            frameworks.each do |framework|
+              xcframework = framework ? @xchelper.get_xcframework_path(framework) : @xchelper.xcframework_path
+              UI.message("▸ Copying xcframework at path: #{xcframework} to tmp directory")
+              FileUtils.cp_r(xcframework, tmpdir)
+            end
+        
+            combined_zip_path = File.join(tmpdir, 'combined_xcframeworks.zip')
+            UI.message("▸ Listing all files in tmp directory")
+            UI.message(Dir.entries(tmpdir))
+        
+            Dir.chdir(tmpdir) do
+              command = "zip -r -X #{combined_zip_path} ."
+              UI.message("▸ Zipping all xcframeworks into one zip at path: #{combined_zip_path}")
+              UI.message(command)
+        
+              begin
+                Actions.sh(command)
+              rescue StandardError => e
+                UI.user_error!(e)
+              end
+            end
+        
+            output_directory = params[:output_directory] || '.'
+            final_zip_path = File.join(output_directory, 'combined_xcframeworks.zip')
+            FileUtils.mv(combined_zip_path, final_zip_path)
+            UI.message("▸ Moved combined zip to output directory at path: #{final_zip_path}")
+          end
+        else
+          frameworks.each do |framework|
+            xcframework = framework ? @xchelper.get_xcframework_path(framework) : @xchelper.xcframework_path
 
-        # Include dSYMs in xcframework
-        if params[:include_dSYMs] != false
-          debug_symbols << "-debug-symbols #{@xchelper.xcarchive_dSYMs_path(index)}/#{@xchelper.framework}.dSYM"
+            UI.message("▸ Zipping xcframework at path: #{xcframework}")
+            begin
+              zip_path = "#{xcframework}.zip"
+              FileUtils.rm_f(zip_path) if File.exist?(zip_path)
+
+              command = "zip -r -X #{zip_path} #{xcframework}"
+              UI.message(command)
+
+              Actions.sh(command)
+            rescue StandardError => e
+              UI.user_error!(e)
+            end
+          end
         end
+      end
 
-        # Include BCSymbols in xcframework
-        if params[:include_BCSymbolMaps] != false && params[:enable_bitcode] != false
-          bc_symbols_dir = @xchelper.xcarchive_BCSymbolMaps_path(index)
-          if Dir.exist?(bc_symbols_dir)
-            arguments = Dir.children(bc_symbols_dir).map { |path| "-debug-symbols #{File.expand_path("#{bc_symbols_dir}/#{path}")}" }
-            debug_symbols << arguments.join(' ')
+      def self.delete_xcframework(params)
+        return if params[:delete_xcframework].nil? || params[:delete_xcframework] == false
+
+        frameworks = params[:frameworks] || [nil]
+
+        frameworks.each do |framework|
+          xcframework = framework ? @xchelper.get_xcframework_path(framework) : @xchelper.xcframework_path
+          UI.message("▸ Deleting xcframework at path: #{xcframework}")
+
+          begin
+            FileUtils.rm_rf(xcframework)
+          rescue StandardError => e
+            UI.user_error!(e)
+          end
+        end
+      end
+
+      # #Fix compile problem go to xcframework and run this command (https://developer.apple.com/forums/thread/123253):
+      # #The generated file includes many module references that Swift thinks are class references because it uses the class ahead of the module
+      # #The problem is that in the Swiftinterface file, we have a class named ABCConnections, but the module is also called ABCConnections. 
+      def self.remove_module_reference(params)
+        return if params[:ignore_module_reference].nil? || params[:ignore_module_reference] == false
+      
+        frameworks = params[:frameworks] || [nil]
+      
+        frameworks.each do |framework|
+          output_path = framework ? @xchelper.get_xcframework_path(framework) : @xchelper.xcframework_path
+          params[:ignore_module_reference].each do |module_reference|
+            begin
+              command = "find #{output_path} -name '*.swiftinterface' -exec sed -i -e 's/#{module_reference}\\.//g' {} \\;"
+              success = system(command)
+              unless success
+                UI.error("Failed to execute command: #{command}")
+              else
+                UI.success("▸ Removed module reference for #{module_reference} in all matching files")
+              end
+            rescue => e
+              UI.error("Error: #{e.message}")
+            end
           end
         end
+      end
 
+      def self.debug_symbols(index:, params:, framework: nil)
+        return '' if !Helper.xcode_at_least?('12.0.0') || params[:include_debug_symbols] == false
+      
+        frameworks = params[:frameworks] || [framework]
+        debug_symbols = []
+      
+        frameworks.each do |fw|
+          # Include dSYMs in xcframework
+          if params[:include_dSYMs] != false
+            debug_symbols << "-debug-symbols #{@xchelper.xcarchive_dSYMs_path(index)}/#{fw}.dSYM"
+          end
+      
+          # Include BCSymbols in xcframework
+          if params[:include_BCSymbolMaps] != false
+            bc_symbols_dir = @xchelper.xcarchive_BCSymbolMaps_path(index)
+            if Dir.exist?(bc_symbols_dir)
+              arguments = Dir.children(bc_symbols_dir).map { |path| "-debug-symbols #{File.expand_path("#{bc_symbols_dir}/#{path}")}" }
+              debug_symbols << arguments.join(' ')
+            end
+          end
+        end
+      
         debug_symbols.join(' ')
       end
 
       def self.copy_dSYMs(params)
         return if params[:include_dSYMs] == false
-
-        dSYMs_output_dir = @xchelper.xcframework_dSYMs_path
-        FileUtils.mkdir_p(dSYMs_output_dir)
-
-        params[:destinations].each_with_index do |_, framework_index|
-          dSYM_source = "#{@xchelper.xcarchive_dSYMs_path(framework_index)}/#{@xchelper.framework}.dSYM"
+      
+        frameworks = params[:frameworks] || [nil]
+      
+        frameworks.each_with_index do |framework, framework_index|
+          dSYMs_output_dir = framework ? @xchelper.framework_dSYMs_path(framework) : @xchelper.xcframework_dSYMs_path
+          FileUtils.mkdir_p(dSYMs_output_dir)
+      
+          dSYM_source = "#{@xchelper.xcarchive_dSYMs_path(framework_index)}/#{framework}.dSYM"
           identifier = @xchelper.library_identifier(framework_index)
-          dSYM = "#{@xchelper.framework}.#{identifier}.dSYM"
+          dSYM = "#{framework}.#{identifier}.dSYM"
           dSYM_destination = "#{dSYMs_output_dir}/#{dSYM}"
-
+      
           UI.important("▸ Copying #{dSYM} to #{dSYMs_output_dir}")
           FileUtils.cp_r(dSYM_source, dSYM_destination)
         end
       end
 
       def self.copy_BCSymbolMaps(params)
-        return if params[:enable_bitcode] == false || params[:include_BCSymbolMaps] == false
-
-        symbols_output_dir = @xchelper.xcframework_BCSymbolMaps_path
-        FileUtils.mkdir_p(symbols_output_dir)
-
-        params[:destinations].each_with_index do |_, framework_index|
+        return if params[:include_BCSymbolMaps] == false
+      
+        frameworks = params[:frameworks] || [nil]
+      
+        frameworks.each_with_index do |framework, framework_index|
+          symbols_output_dir = framework ? @xchelper.framework_BCSymbolMaps_path(framework) : @xchelper.xcframework_BCSymbolMaps_path
+          FileUtils.mkdir_p(symbols_output_dir)
+      
           symbols_xcarchive_dir = @xchelper.xcarchive_BCSymbolMaps_path(framework_index)
           next unless Dir.exist?(symbols_xcarchive_dir)
-
+      
           FileUtils.cp_r("#{symbols_xcarchive_dir}/.", symbols_output_dir)
           UI.important("▸ Copying #{Dir.children(symbols_xcarchive_dir)} to #{symbols_output_dir}")
         end
@@ -133,22 +306,32 @@ module Fastlane
       end
 
       def self.update_xcargs(params)
-        xcargs = []
-        if params[:override_xcargs]
-          UI.important('Overwriting SKIP_INSTALL and BUILD_LIBRARY_FOR_DISTRIBUTION options')
-          if params[:xcargs]
-            params[:xcargs].gsub!(/SKIP_INSTALL(=|\s+)(YES|NO)/, '')
-            params[:xcargs].gsub!(/BUILD_LIBRARY_FOR_DISTRIBUTION(=|\s+)(YES|NO)/, '')
+        xcargs = params[:override_xcargs].to_s.strip.split(' ')
+        skip_install_set = false
+        build_library_for_distribution_set = false
+      
+        xcargs.each do |arg|
+          if arg.match?(/SKIP_INSTALL(=|\s+)/)
+            skip_install_set = true
+            unless arg.match?(/SKIP_INSTALL=NO/)
+              xcargs.delete(arg)
+              xcargs << 'SKIP_INSTALL=NO'
+            end
+          end
+      
+          if arg.match?(/BUILD_LIBRARY_FOR_DISTRIBUTION(=|\s+)/)
+            build_library_for_distribution_set = true
+            unless arg.match?(/BUILD_LIBRARY_FOR_DISTRIBUTION=YES/)
+              xcargs.delete(arg)
+              xcargs << 'BUILD_LIBRARY_FOR_DISTRIBUTION=YES'
+            end
           end
-          xcargs.concat(['SKIP_INSTALL=NO', 'BUILD_LIBRARY_FOR_DISTRIBUTION=YES'])
-        end
-
-        if params[:enable_bitcode] != false
-          params[:xcargs].gsub!(/ENABLE_BITCODE(=|\s+)(YES|NO)/, '') if params[:xcargs]
-          xcargs << ['OTHER_CFLAGS="-fembed-bitcode"', 'BITCODE_GENERATION_MODE="bitcode"', 'ENABLE_BITCODE=YES']
         end
-
-        "#{params[:xcargs].to_s.strip} #{xcargs.join(' ')}"
+      
+        xcargs << 'SKIP_INSTALL=NO' unless skip_install_set
+        xcargs << 'BUILD_LIBRARY_FOR_DISTRIBUTION=YES' unless build_library_for_distribution_set
+      
+        xcargs.join(' ')
       end
 
       def self.update_destinations(params)
@@ -203,7 +386,7 @@ module Fastlane
       end
 
       def self.authors
-        ['Boris Bielik', 'Alexey Alter-Pesotskiy']
+        ['ykhandelwal']
       end
 
       def self.details
@@ -218,13 +401,6 @@ module Fastlane
             description: "The project's scheme. Make sure it's marked as Shared",
             optional: false
           ),
-          FastlaneCore::ConfigItem.new(
-            key: :enable_bitcode,
-            description: 'Should the project be built with bitcode enabled?',
-            optional: true,
-            is_string: false,
-            default_value: true
-          ),
           FastlaneCore::ConfigItem.new(
             key: :destinations,
             description: 'Use custom destinations for building the xcframework',
@@ -282,8 +458,46 @@ module Fastlane
                           'Set this to false to preserve the passed xcargs',
             optional: true,
             default_value: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :frameworks,
+            description: 'List of frameworks to create xcframework for',
+            optional: true,
+            is_string: false,
+            type: Array,
+            default_value: []),
+          FastlaneCore::ConfigItem.new(
+            key: :code_sign_identity,
+            description: 'Code sign identity to use for building the xcframework',
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :zip_xcframework,
+            description: 'Zip the xcframework after creation',
+            optional: true,
+            default_value: false
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :ignore_module_reference,
+            description: 'List of module references to remove from the xcframework',
+            optional: true,
+            is_string: false,
+            type: Array,
+            default_value: []),
+          FastlaneCore::ConfigItem.new(
+            key: :delete_xcframework,
+            description: 'Delete the xcframework after creation',
+            optional: true,
+            default_value: false
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :combine_all_zip,
+            description: 'Combine all xcframeworks into one zip file',
+            optional: true,
+            default_value: false
           )
         ]
+        
       end
 
       def self.category

data/lib/fastlane/plugin/mobile_tools/actions/validate_xcframework_action.rb

@@ -0,0 +1,105 @@
+module Fastlane
+    module Actions
+      class ValidateXcframeworkAction < Action
+        def self.run(params)
+          validate_xcframework(params)
+        end
+  
+        def self.validate_xcframework(params)
+          return if params[:validate_xcframework].nil? || params[:validate_xcframework] == false
+  
+          UI.message("▸ Validating xcframework")
+          xcframework_paths = []
+  
+          frameworks = params[:frameworks] || [nil]
+            
+          @xchelper = Helper::CreateXcframeworkHelper.new(params)
+          frameworks.each do |framework|
+            xcframework = framework ? @xchelper.get_xcframework_path(framework) : @xchelper.xcframework_path
+            xcframework_paths << xcframework
+          end
+          
+          UI.message("▸ Creating temporary sample app")
+          sample_app_path = Helper::ValidateXcframeworkHelper.create_sample_app(xcframework_paths)
+  
+          UI.message("▸ Building the sample app to validate xcframework")
+          begin
+            Dir.chdir(sample_app_path) do
+              Actions.sh("swift build")
+              UI.success("xcframework validation succeeded")
+            end
+          rescue StandardError => e
+            UI.user_error!("xcframework validation failed: #{e}")
+          end
+  
+          UI.message("▸ Creating project.yml for xcodegen")
+          project_yml_path = Helper::ValidateXcframeworkHelper.create_project_yml(xcframework_paths, sample_app_path)
+  
+          UI.message("▸ Generating Xcode project using xcodegen")
+          begin
+            Helper::ValidateXcframeworkHelper.generate_xcode_project(project_yml_path)
+            UI.success("Xcode project generated successfully with xcodegen")
+          rescue StandardError => e
+            UI.user_error!("Failed to generate Xcode project with xcodegen: #{e}")
+          end
+  
+          UI.message("▸ Building the Xcode project to validate xcframework")
+          xcodeproj_path = File.join(sample_app_path, 'SampleApp.xcodeproj')
+          begin
+            Helper::ValidateXcframeworkHelper.build_xcode_project(xcodeproj_path)
+            UI.success("xcframework validation succeeded with xcodebuild")
+          rescue StandardError => e
+            UI.user_error!("xcframework validation failed with xcodebuild: #{e}")
+          end
+        end
+  
+        def self.run_swiftlint
+          UI.message("▸ Running SwiftLint")
+          begin
+            Actions.sh("if which swiftlint >/dev/null; then swiftlint; else echo 'warning: SwiftLint not installed, download from https://github.com/realm/SwiftLint'; fi")
+            UI.success("SwiftLint check completed successfully")
+          rescue StandardError => e
+            UI.user_error!("SwiftLint check failed: #{e}")
+          end
+        end
+  
+        def self.description
+          "Validate xcframework and run SwiftLint"
+        end
+  
+        def self.authors
+          ["Your Name"]
+        end
+  
+        def self.return_value
+          # If your method provides a return value, you can describe it here
+        end
+  
+        def self.details
+          # Optional:
+          "This action validates an xcframework by creating a temporary sample app, building it, and running SwiftLint."
+        end
+  
+        def self.available_options
+          [
+            FastlaneCore::ConfigItem.new(key: :frameworks,
+                                         description: "Paths to the frameworks to be validated",
+                                         optional: false,
+                                         type: Array),
+            FastlaneCore::ConfigItem.new(key: :validate_xcframework,
+                                         description: "Flag to validate xcframework",
+                                         optional: true,
+                                         type: Boolean),
+            FastlaneCore::ConfigItem.new(key: :xcframework_output_directory,
+                                        description: "Output directory for the xcframework",
+                                        optional: true,
+                                        type: String)
+          ]
+        end
+  
+        def self.is_supported?(platform)
+          true
+        end
+      end
+    end
+  end

data/lib/fastlane/plugin/mobile_tools/helper/create_xcframework_helper.rb

@@ -32,6 +32,22 @@ module Fastlane
         UI.user_error!("▸ PRODUCT_NAME was misdefined: `#{product_name}`. Please, provide :product_name option")
       end
 
+      def get_xcarchive_framework_path(framework_index, framework_name)
+        UI.message("▸ get_xcarchive_framework_path: framework_name: `#{framework_name}`")
+        framework_path = "#{xcarchive_path_for_destination(framework_index)}/Products/Library/Frameworks/#{framework_name}.framework"
+        UI.message("▸ get_xcarchive_framework_path: framework_path: `#{framework_path}`")
+        return framework_path if File.exist?(framework_path)
+
+        UI.user_error!("▸ get_xcarchive_framework_path: framework_name was misdefined: `#{framework_name}`. Please, provide :framework_name option")
+      end
+
+      def xcarchive_frameworks_dir(framework_index)
+        frameworks_dir = "#{xcarchive_path_for_destination(framework_index)}/Products/Library/Frameworks"
+        return frameworks_dir if File.exist?(frameworks_dir)
+      
+        UI.user_error!("▸ Frameworks directory does not exist for the given index: `#{framework_index}`.")
+      end
+
       def xcarchive_frameworks_path
         @params[:destinations].each_with_index.map { |_, i| xcarchive_framework_path(i) }
       end
@@ -44,6 +60,10 @@ module Fastlane
         File.expand_path("#{output_directory}/#{product_name}.dSYMs")
       end
 
+      def framework_dSYMs_path(framework_name)
+        File.expand_path("#{output_directory}/#{framework_name}.dSYMs")
+      end
+
       def xcarchive_BCSymbolMaps_path(framework_index)
         File.expand_path("#{xcarchive_path_for_destination(framework_index)}/BCSymbolMaps")
       end
@@ -52,10 +72,18 @@ module Fastlane
         File.expand_path("#{output_directory}/#{product_name}.BCSymbolMaps")
       end
 
+      def framework_BCSymbolMaps_path(framework_name)
+        File.expand_path("#{output_directory}/#{framework_name}.BCSymbolMaps")
+      end
+
       def xcframework_path
         File.expand_path("#{output_directory}/#{xcframework}")
       end
 
+      def get_xcframework_path(framework_name)
+        File.expand_path("#{output_directory}/#{framework_name}.xcframework")
+      end
+
       def output_directory
         @params[:xcframework_output_directory] || ''
       end

data/lib/fastlane/plugin/mobile_tools/helper/validate_xcframework_helper.rb

@@ -0,0 +1,142 @@
+module Fastlane
+    module Helper
+      class ValidateXcframeworkHelper
+        def self.create_sample_app(framework_paths)
+          tmpdir = Dir.mktmpdir
+          sample_app_path = File.join(tmpdir, 'SampleApp')
+          Dir.mkdir(sample_app_path)
+          Dir.chdir(sample_app_path) do
+            system("swift package init --type executable")
+            tests_path = File.join(sample_app_path, 'Tests', 'SampleAppTests')
+            FileUtils.mkdir_p(tests_path)
+  
+            # Copy frameworks to the temporary sample app folder
+            framework_paths.each do |path|
+              FileUtils.cp_r(path, sample_app_path)
+            end
+  
+            package_swift_path = File.join(sample_app_path, 'Package.swift')
+            # Extract names from framework paths and ensure paths are relative
+            binary_targets = framework_paths.map do |path|
+              name = File.basename(path, ".framework")
+              relative_path = "./" + File.basename(path)
+              ".binaryTarget(name: \"#{name}\", path: \"#{relative_path}\")"
+            end.join(",\n        ")
+  
+            # Create dependencies for SampleApp target
+            dependencies = framework_paths.map do |path|
+              name = File.basename(path, ".framework")
+              "\"#{name}\""
+            end.join(", ")
+  
+            resources = framework_paths.map do |path|
+              name = File.basename(path, ".framework")
+              ".copy(\"./#{name}.framework\")"
+            end.join(",\n                      ")
+  
+            # Add all framework names to the products target
+            product_targets = framework_paths.map do |path|
+              name = File.basename(path, ".framework")
+              "\"#{name}\""
+            end.join(", ")
+  
+            package_swift_content = <<-SWIFT
+            // swift-tools-version:5.3
+            import PackageDescription
+  
+            let package = Package(
+                name: "SampleApp",
+                platforms: [
+                    .macOS(.v10_15),
+                    .iOS(.v13)
+                ],
+                products: [
+                    .executable(name: "SampleApp", targets: ["SampleApp", #{product_targets}]),
+                ],
+                dependencies: [
+                    // Add dependencies here
+                ],
+                targets: [
+                    #{binary_targets},
+                    .target(
+                        name: "SampleApp",
+                        dependencies: [#{dependencies}],
+                        path: "Sources",
+                        resources: [
+                            #{resources}
+                        ]
+                    ),
+                    .testTarget(
+                        name: "SampleAppTests",
+                        dependencies: ["SampleApp"],
+                        path: "Tests/SampleAppTests"
+                    ),
+                ]
+            )
+            SWIFT
+  
+            File.write(package_swift_path, package_swift_content.strip)
+          end
+          sample_app_path
+        end
+  
+        def self.create_project_yml(framework_paths, sample_app_path)
+          project_yml_content = {
+            "name" => "SampleApp",
+            "options" => {
+              "bundleIdPrefix" => "com.intuit"
+            },
+            "targets" => {
+              "SampleApp" => {
+                "type" => "application",
+                "platform" => "iOS",
+                "deploymentTarget" => "13.0",
+                "sources" => ["Sources"],
+                "resources" => framework_paths.map { |path| "./#{File.basename(path)}" },
+                "dependencies" => framework_paths.map { |path| { "framework" => "./#{File.basename(path)}", "embed" => true } },
+                "settings" => {
+                  "base" => {
+                    "DEVELOPMENT_TEAM" => "F6DWWXWEX6",
+                    "GENERATE_INFOPLIST_FILE" => "YES",
+                    "CODE_SIGN_IDENTITY" => "iPhone Developer",
+                    "LD_RUNPATH_SEARCH_PATHS" => ["$(inherited)", "@executable_path/Frameworks"],
+                    "SDKROOT" => "iphoneos",
+                    "TARGETED_DEVICE_FAMILY" => "1,2",
+                    "VERSIONING_SYSTEM" => "apple-generic",
+                    "CURRENT_PROJECT_VERSION" => "1",
+                    "MARKETING_VERSION" => "1.0",
+                    "CFBundleVersion" => "$(CURRENT_PROJECT_VERSION)",
+                    "CFBundleShortVersionString" => "$(MARKETING_VERSION)"
+                  },
+                  "configs" => {
+                    "debug" => {
+                      "CODE_SIGN_STYLE" => "Manual",
+                      "PROVISIONING_PROFILE_SPECIFIER" => "com.intuit.*.InHouse",
+                      "CODE_SIGN_IDENTITY" => "iPhone Distribution: Intuit Inc.(Ent)"
+                    },
+                    "release" => {
+                      "CODE_SIGN_STYLE" => "Manual",
+                      "PROVISIONING_PROFILE_SPECIFIER" => "com.intuit.*.InHouse",
+                      "CODE_SIGN_IDENTITY" => "iPhone Distribution: Intuit Inc.(Ent)"
+                    }
+                  }
+                }
+              }
+            }
+          }
+  
+          project_yml_path = File.join(sample_app_path, 'project.yml')
+          File.write(project_yml_path, project_yml_content.to_yaml)
+          project_yml_path
+        end
+  
+        def self.generate_xcode_project(project_yml_path)
+          Actions.sh("xcodegen generate --spec #{project_yml_path}")
+        end
+  
+        def self.build_xcode_project(xcodeproj_path)
+          Actions.sh("xcodebuild -project #{xcodeproj_path} -scheme SampleApp -sdk iphonesimulator -destination 'platform=iOS Simulator,name=iPhone 14' build")
+        end
+      end
+    end
+  end

data/lib/fastlane/plugin/mobile_tools/version.rb

@@ -1,5 +1,5 @@
 module Fastlane
   module MobileTools
-    VERSION = "0.1.0"
+    VERSION = "0.1.2"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fastlane-plugin-mobile_tools
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - Yogesh Khandelwal
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-08-16 00:00:00.000000000 Z
+date: 2024-09-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -192,7 +192,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description:
+description: 
 email: yogesh_khandelwal@intuit.com
 executables: []
 extensions: []
@@ -202,13 +202,15 @@ files:
 - README.md
 - lib/fastlane/plugin/mobile_tools.rb
 - lib/fastlane/plugin/mobile_tools/actions/create_xcframework_action.rb
+- lib/fastlane/plugin/mobile_tools/actions/validate_xcframework_action.rb
 - lib/fastlane/plugin/mobile_tools/helper/create_xcframework_helper.rb
+- lib/fastlane/plugin/mobile_tools/helper/validate_xcframework_helper.rb
 - lib/fastlane/plugin/mobile_tools/version.rb
 homepage: https://github.com/ykhandelwal913/fastlane-plugin-mobile_tools
 licenses:
 - MIT
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -223,8 +225,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
-signing_key:
+rubygems_version: 3.2.3
+signing_key: 
 specification_version: 4
 summary: fastlane plugin for mobile devops tooling
 test_files: []