fastlane-plugin-build_xcframework 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 692809331fa5197fab9b15a5aef97870097cde17bf3317fafd5f295b5fee9ff7
+  data.tar.gz: 0602bf78276e4a3b31a92a66b7429e9ba5a1189bda1a68148aef7471b4d087fb
+SHA512:
+  metadata.gz: 4fde38204ec0e659645d181cac3a0c8c004494750e0e850e9e70f8b1cad9f767debfd9c94216b8a1af4f8a2a9dab807b6afc013453e05fc376db6a88806069ad
+  data.tar.gz: 0b96f623318cb4d4826a3900ce25a27241262e08338be193fe9d91a533ab623b9781d24d72e362ec1fd8f328f314863967a1c69d946a627abe3a02d9d633c99d

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Alex Crowe <alexei.hmelevski@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,52 @@
+# build_xcframework plugin
+
+[![fastlane Plugin Badge](https://rawcdn.githack.com/fastlane/fastlane/master/fastlane/assets/plugin-badge.svg)](https://rubygems.org/gems/fastlane-plugin-build_xcframework)
+
+## Getting Started
+
+This project is a [_fastlane_](https://github.com/fastlane/fastlane) plugin. To get started with `fastlane-plugin-build_xcframework`, add it to your project by running:
+
+```bash
+fastlane add_plugin build_xcframework
+```
+
+## About build_xcframework
+
+This plugin provides high-level api for creating xcframework
+
+**Note to author:** Add a more detailed description about this plugin here. If your plugin contains multiple actions, make sure to mention them here.
+
+## Example
+
+Check out the [example `Fastfile`](fastlane/Fastfile) to see how to use this plugin. Try it by cloning the repo, running `fastlane install_plugins` and `bundle exec fastlane test`.
+
+**Note to author:** Please set up a sample project to make it easy for users to explore what your plugin does. Provide everything that is necessary to try out the plugin in this project (including a sample Xcode/Android project if necessary)
+
+## Run tests for this plugin
+
+To run both the tests, and code style validation, run
+
+```
+rake
+```
+
+To automatically fix many of the styling issues, use
+```
+rubocop -a
+```
+
+## Issues and Feedback
+
+For any other issues and feedback about this plugin, please submit it to this repository.
+
+## Troubleshooting
+
+If you have trouble using plugins, check out the [Plugins Troubleshooting](https://docs.fastlane.tools/plugins/plugins-troubleshooting/) guide.
+
+## Using _fastlane_ Plugins
+
+For more information about how the `fastlane` plugin system works, check out the [Plugins documentation](https://docs.fastlane.tools/plugins/create-plugin/).
+
+## About _fastlane_
+
+_fastlane_ is the easiest way to automate beta deployments and releases for your iOS and Android apps. To learn more, check out [fastlane.tools](https://fastlane.tools).

data/lib/fastlane/plugin/build_xcframework/actions/build_utils.rb

@@ -0,0 +1,20 @@
+require 'fastlane/action'
+
+module Fastlane
+  module Actions
+    class BuildUtils
+      def self.prepare(config)
+        UI.important("Preparing folders")
+        UI.message("Removing old: #{config[:base]}")
+        FileUtils.rm_rf(config[:release_folder])
+        UI.message("Creating empty: #{config[:release_folder]}")
+        Actions.sh("set -o pipefail && mkdir -p #{config[:release_folder]}")
+      end
+
+      def self.clean_temp_folder(config)
+        UI.message("Clearing derived data folder: #{config[:derived_data]}")
+        FileUtils.rm_rf(config[:derived_data])
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/build_xcframework/actions/build_xcframework_action.rb

@@ -0,0 +1,144 @@
+require 'fastlane/action'
+require_relative '../helper/helper_object'
+require_relative './path_builder'
+require_relative './lipo_runner'
+require_relative './build_utils'
+require_relative './xconfig_builder'
+require_relative './xcframework_builder'
+
+module Fastlane
+  module Actions
+    class BuildXcframeworkAction < Action
+      def self.build_xcframework(params)
+        UI.message("Started building #{XconfigBuilder.paths_components[:project_name]}.#{params[:type]} for #{params[:sdk]} support")
+        Actions::XcodebuildAction.run(params)
+        UI.message("Finished building #{XconfigBuilder.paths_components[:project_name]}.#{params[:type]}  for #{params[:sdk]} support")
+      end
+
+      def self.run(params)
+        if params[:type] != 'framework' && params[:type] != 'xcframework'
+          UI.error("Unsupported framework type of: #{params[:type]}")
+          return
+        end
+
+        UI.message('Building paths components')
+        paths_components = get_paths_components(params)
+        if paths_components.nil?
+          return
+        end
+
+        Actions::BuildUtils.prepare(paths_components)
+        UI.message('Building paths components finished')
+
+        XconfigBuilder.params = params
+        XconfigBuilder.paths_components = paths_components
+
+        build_for_sim_if_required(params)
+
+        UI.success("Building for device")
+        build_for_device
+
+        if params[:type] == 'framework'
+          lipo_config = Helper::Object.copy(paths_components)
+          lipo_config[:includeSimulator] = params[:includeSimulator]
+          Actions::LipoRunner.run(lipo_config)
+        else
+          Actions::XCFrameworkBuilder.run(paths_components)
+        end
+        Actions::BuildUtils.clean_temp_folder(paths_components)
+        UI.success("Build succeed")
+      end
+
+      def self.build_for_device
+        xcodebuild_configs = XconfigBuilder.device_config
+        build_xcframework(xcodebuild_configs)
+      end
+
+      def self.build_for_sim_if_required(params)
+        if params[:includeSimulator] || params[:type] == 'xcframework'
+          UI.message("Building for sim")
+          xcodebuild_configs = XconfigBuilder.simulator_config
+          build_xcframework(xcodebuild_configs)
+        end
+      end
+
+      def self.get_paths_components(params)
+        builder_config = {}
+        builder_config[:project] = params[:project]
+        builder_config[:workspace] = params[:workspace]
+        PathBuilder.build_paths(params)
+      end
+
+      def self.authors
+        ["Alex Crowe"]
+      end
+
+      def self.details
+        # Optional:
+        "It encapsulates xcbuild to provide simple api to create xcframework"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :project,
+                                       description: "Project name",
+                                       optional: true,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :output_folder,
+                                       description: "Output folder",
+                                       default_value: "./fastlane_build",
+                                       optional: true,
+                                       type: String),
+
+          FastlaneCore::ConfigItem.new(key: :workspace,
+                                       description: "Workspace name",
+                                       optional: true,
+                                       type: String),
+
+          FastlaneCore::ConfigItem.new(key: :scheme,
+                                       description: "Scheme name",
+                                       optional: true,
+                                       type: String),
+
+          FastlaneCore::ConfigItem.new(key: :configuration,
+                                       description: "Build Configuration",
+                                       default_value: 'Release',
+                                       optional: true,
+                                       type: String),
+
+          FastlaneCore::ConfigItem.new(key: :sim_configuration,
+                                       description: "Sim Build Configuration",
+                                       default_value: 'Release',
+                                       optional: true,
+                                       type: String),
+
+          FastlaneCore::ConfigItem.new(key: :type,
+                                       description: "Framework type",
+                                       optional: true,
+                                       default_value: 'xcframework',
+                                       type: String),
+
+          FastlaneCore::ConfigItem.new(key: :includeSimulator,
+                                       description: "Include simulator support",
+                                       optional: true,
+                                       default_value: false,
+                                       is_string: false),
+
+          FastlaneCore::ConfigItem.new(key: :dev_archs,
+                                       description: "Build for device architectures",
+                                       optional: true,
+                                       type: Array),
+
+          FastlaneCore::ConfigItem.new(key: :sim_archs,
+                                       description: "Build for sim architectures",
+                                       optional: true,
+                                       type: Array)
+        ]
+      end
+
+      def self.is_supported?(platform)
+         [:ios, :mac].include?(platform)
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/build_xcframework/actions/lipo_runner.rb

@@ -0,0 +1,25 @@
+require 'fastlane/action'
+
+module Fastlane
+  module Actions
+    class LipoRunner
+      def self.run(config)
+        Actions.sh("set -o pipefail && cp -r #{config[:device_framework_filename]} #{config[:release_framework_filename]}")
+        release_binary_path = binary_path(config[:release_framework_filename], config[:project_name])
+        temp_device_binary_path = binary_path(config[:device_framework_filename], config[:project_name])
+        args = release_binary_path + ' ' + temp_device_binary_path
+
+        if config[:includeSimulator]
+          UI.message('merging with simulator')
+          sim_binary_path = binary_path(config[:sim_framework_filename], config[:project_name])
+          args += " #{sim_binary_path}"
+        end
+        Actions.sh("set -o pipefail && lipo -create -output #{args}")
+      end
+
+      def self.binary_path(filename, proejct_name)
+        "#{filename}/#{proejct_name}"
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/build_xcframework/actions/path_builder.rb

@@ -0,0 +1,88 @@
+require "pathname"
+
+module Fastlane
+  class PathBuilder
+    def self.build_paths(config)
+      base = config[:output_folder]
+      derived = base + '/derivedData'
+      file_name = config[:project] || config[:workspace] || detect_file("*.xcworkspace") || detect_file("*.xcodeproj")
+
+      UI.important("Detected file name: #{file_name}")
+
+      configuration = config[:configuration]
+      sim_configuration = config[:sim_configuration]
+      name = ''
+
+      path = Pathname.new(file_name)
+      file_name = path.basename.to_s || file_name
+      if file_name
+        name = file_name.split('.').first
+      end
+
+      if name.nil? || name.empty?
+        UI.error("Could not find project or workspace")
+        raise StandardError, "Could not find project or workspace"
+      end
+
+      UI.important("Detected project name: #{name}")
+      framework_name = name + '.framework'
+      xcframework_name = name + '.xcframework'
+      release_folder = base
+
+      temp_folder_config = {
+        derived: derived,
+        name: name
+      }
+
+      sim_temp_folder_cfg = deep_clone(temp_folder_config)
+      sim_temp_folder_cfg[:os] = 'iphonesimulator'
+      sim_temp_folder_cfg[:config] = sim_configuration
+
+      dev_temp_folder_cfg = deep_clone(temp_folder_config)
+      dev_temp_folder_cfg[:os] = 'iphoneos'
+      dev_temp_folder_cfg[:config] = configuration
+
+      {
+          out_base: base,
+          derived_data: derived,
+          buildlog_path: derived + "/logs",
+          project_name: name,
+          release_folder: release_folder,
+          release_framework_filename: release_folder + "/#{framework_name}",
+          release_xcframework_filename: release_folder + "/#{xcframework_name}",
+          device_framework_filename: temp_folder(dev_temp_folder_cfg) + "/#{framework_name}",
+          sim_framework_filename: temp_folder(sim_temp_folder_cfg) + "/#{framework_name}",
+          build_path_device: temp_folder(dev_temp_folder_cfg).to_s,
+          build_path_sim: temp_folder(sim_temp_folder_cfg).to_s
+      }
+    end
+
+    def self.deep_clone(obj)
+      obj.clone.tap do |new_obj|
+        new_obj.each do |key, val|
+          new_obj[key] = deep_clone(val) if val.kind_of?(Hash)
+        end
+      end
+    end
+
+    def self.temp_folder(cfg)
+      return cfg[:derived] + "/#{cfg[:os]}/#{cfg[:name]}.xcarchive/Products/Library/Frameworks"
+    end
+
+    def self.detect_file(name)
+      file = nil
+      files = Dir.glob(name)
+
+      if files.length > 1
+        UI.important("Multiple files detected.")
+      end
+
+      unless files.empty?
+        file = files.first
+        UI.important("Using file \"#{file}\"")
+      end
+
+      return file
+    end
+  end
+end

data/lib/fastlane/plugin/build_xcframework/actions/xcframework_builder.rb

@@ -0,0 +1,18 @@
+require 'fastlane/action'
+
+module Fastlane
+  module Actions
+    class XCFrameworkBuilder
+      def self.run(config)
+        temp_device_framework = config[:device_framework_filename]
+        temp_sim_framework = config[:sim_framework_filename]
+        framework_command_args = [temp_device_framework, temp_sim_framework].compact.reduce('') { |sum, cur| sum + " -framework " + cur }
+        Actions.sh("set -o pipefail && xcodebuild -create-xcframework #{framework_command_args} -output #{config[:release_xcframework_filename]}")
+      end
+
+      def self.framework_temp_path(base, name)
+        "#{base}/Products/Library/Frameworks/#{name}"
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/build_xcframework/actions/xconfig_builder.rb

@@ -0,0 +1,89 @@
+module Fastlane
+  class XconfigBuilder
+    @paths_components = {}
+    @params = {}
+
+    class << self
+      attr_reader :params
+      attr_writer(:params)
+      attr_reader :paths_components
+      attr_writer(:paths_components)
+    end
+
+    def self.prepare_config(simulator)
+      xcodebuild_configs = base_config
+      archs = params[:sim_archs]
+
+      if simulator == true
+        xcodebuild_configs[:sdk] = 'iphonesimulator'
+        xcodebuild_configs[:configuration] = params[:configuration]
+
+        archs = params[:sim_archs]
+      else
+        xcodebuild_configs[:sdk] = 'iphoneos'
+        xcodebuild_configs[:configuration] = params[:sim_configuration]
+        archs = params[:dev_archs]
+      end
+      # if params[:type] == 'xcframework'
+      path = "#{paths_components[:derived_data]}/#{xcodebuild_configs[:sdk]}/#{paths_components[:project_name]}"
+      xcodebuild_configs[:archive_path] = path
+      destination = ''
+      if simulator
+        destination = "generic/platform=iOS Simulator"
+      else
+        destination = "generic/platform=iOS"
+      end
+      xcodebuild_configs[:destination] = destination
+      # end
+
+      if archs
+        xcodebuild_configs[:xcargs] += ' ' + archs.reduce('') { |sum, cur| sum + " -arch " + cur }
+      end
+      if simulator == true && params[:type] == 'framework'
+        xcodebuild_configs[:xcargs] += ' ' + "EXCLUDED_ARCHS=\"arm64\""
+      end
+      xcodebuild_configs
+    end
+
+    def self.simulator_config
+      prepare_config(true)
+    end
+
+    def self.device_config
+      prepare_config(false)
+    end
+
+    def self.base_config
+      case params[:type]
+      when 'framework'
+        xcodebuild_configs = static_framework_settings
+        # xcodebuild_configs[:derivedDataPath] = paths_components[:derived_data]
+      when 'xcframework'
+        xcodebuild_configs = xc_framework_settings
+      else
+        xcodebuild_configs = {}
+      end
+      xcodebuild_configs[:project] = params[:project]
+      xcodebuild_configs[:workspace] = params[:workspace]
+      xcodebuild_configs[:scheme] =  params[:scheme] || paths_components[:project_name]
+      xcodebuild_configs[:xcargs] = ''
+      xcodebuild_configs
+    end
+
+    def self.static_framework_settings
+      {
+        only_active_arch: false,
+        archive: true,
+        defines_module: false
+      }
+    end
+
+    def self.xc_framework_settings
+      {
+        only_active_arch: false,
+        archive: true,
+        defines_module: false
+      }
+    end
+  end
+end

data/lib/fastlane/plugin/build_xcframework/helper/build_xcframework_helper.rb

@@ -0,0 +1,13 @@
+require 'fastlane_core/ui/ui'
+
+module Fastlane
+  UI = FastlaneCore::UI unless Fastlane.const_defined?(:UI)
+
+  module Helper
+    class BuildXcframeworkHelper
+      def self.show_message
+        UI.message("Hello from the build_xcframework plugin helper!")
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/build_xcframework/helper/helper_object.rb

@@ -0,0 +1,15 @@
+require 'fastlane_core/ui/ui'
+
+module Fastlane
+  module Helper
+    class Object
+      def self.copy(obj)
+        obj.clone.tap do |new_obj|
+          new_obj.each do |key, val|
+            new_obj[key] = deep_clone(val) if val.kind_of?(Hash)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,5 @@
+module Fastlane
+  module BuildXcframework
+    VERSION = "0.1.0"
+  end
+end

data/lib/fastlane/plugin/build_xcframework.rb

@@ -0,0 +1,16 @@
+require 'fastlane/plugin/build_xcframework/version'
+
+module Fastlane
+  module BuildXcframework
+    # Return all .rb files inside the "actions" and "helper" directory
+    def self.all_classes
+      Dir[File.expand_path('**/{actions,helper}/*.rb', File.dirname(__FILE__))]
+    end
+  end
+end
+
+# By default we want to import all available actions and helpers
+# A plugin can contain any number of actions and plugins
+Fastlane::BuildXcframework.all_classes.each do |current|
+  require current
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: fastlane-plugin-build_xcframework
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Alex Crowe
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-03-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pathname
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+description:
+email: alexei.hmelevski@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/fastlane/plugin/build_xcframework.rb
+- lib/fastlane/plugin/build_xcframework/actions/build_utils.rb
+- lib/fastlane/plugin/build_xcframework/actions/build_xcframework_action.rb
+- lib/fastlane/plugin/build_xcframework/actions/lipo_runner.rb
+- lib/fastlane/plugin/build_xcframework/actions/path_builder.rb
+- lib/fastlane/plugin/build_xcframework/actions/xcframework_builder.rb
+- lib/fastlane/plugin/build_xcframework/actions/xconfig_builder.rb
+- lib/fastlane/plugin/build_xcframework/helper/build_xcframework_helper.rb
+- lib/fastlane/plugin/build_xcframework/helper/helper_object.rb
+- lib/fastlane/plugin/build_xcframework/version.rb
+homepage: https://github.com/Swift-Gurus/fastlane_build_xcframework
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.6'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key:
+specification_version: 4
+summary: This plugin provides high-level api for creating xcframework
+test_files: []