fastlane-plugin-unity_exporter 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5d8f86fa27fb63a03a99dcc669832ad4ef700f9548e36ef2e1fc797fc54aa689
+  data.tar.gz: '029e648522051179dab3010516cd34920b0aa22934e66f49722cc000162fd494'
+SHA512:
+  metadata.gz: 0ea2e1fe2623d7ca96fe35fe766c530601fba3e176ffa4f9da385edb1d0d6a3dde03b8b0c1fc5b5f0414745d346bf391a3e97c4f3c9fbfd10c9e384bd4a9f2a5
+  data.tar.gz: f0a4509e13da5329766ca8d5a34ea56126e04bec7fa8171cafa3bcc396f5a1907885bb2744d99b3dae3afaab6ba9b7c27fc634748d10f0a0549785c947212063

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 ar:met
+
+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,156 @@
+# unity_exporter plugin
+
+[![fastlane Plugin Badge](https://rawcdn.githack.com/fastlane/fastlane/master/fastlane/assets/plugin-badge.svg)](https://rubygems.org/gems/fastlane-plugin-unity_exporter)
+
+
+## Getting Started
+
+This project is a [_fastlane_](https://github.com/fastlane/fastlane) plugin. To get started with `fastlane-plugin-unity_exporter`, add it to your project by running:
+
+```bash
+fastlane add_plugin unity_exporter
+```
+
+
+## About unity_exporter
+
+Plugin for _fastlane_ that defines an action to export iOS and Android projects via [_Unity3d_](https://unity.com/). This allows _Unity3d_ to more easily integrate with _fastlane_. 
+
+This action works by invoking _Unity3d_ via commandline to trigger an export of your _Unity3d_ project. [Per default _Unity3d_ supports a number of different commandline arguments.](https://docs.unity3d.com/Manual/CommandLineArguments.html) Therefore there are two ways to use the plugin: Either provide your own full list of commandline arguments or let the _fastlane plugin_ help you with some of it. This becomes clearer when looking at all [available actions](#actions).
+
+For convenience and easier versioning, there also exists the [_Unity Build Exporter_](https://github.com/ar-met/unity-build-exporter) which can be added via the [_Unity Package Manager_](https://docs.unity3d.com/Manual/Packages.html). The _Unity Build Exporter_ provides a custom execute method that parses custom commandline arguments. See [_Unity Build Exporter_](https://github.com/ar-met/unity-build-exporter) for a more in-depth explanation of the package.
+
+To make full use of the *unity_exporter* make sure to:
+* Install the [_Unity Hub_](https://docs.unity3d.com/Manual/GettingStartedInstallingHub.html) at its default path: We use the _Unity Hub_ to get the paths of your _Unity Editor_ installations,  such that we can use the _Unity Editor_ version that matches the version used by your _Unity3d_ project when exporting a build.
+* Add the [_Unity Build Exporter_](https://github.com/ar-met/unity-build-exporter) to your _Unity3d_ project: We invoke a specific `executeMethod` ([see docs](https://docs.unity3d.com/Manual/CommandLineArguments.html) and the [readme of the package](https://github.com/ar-met/unity-build-exporter/blob/master/Assets/BuildExporter/README.md) what's that about) provided by the package to handle versioning. Note that the package also exposes a new menu item to your _Unity3d_ project that helps with setting up _fastlane_ and the *fastlane-plugin-unity_exporter*.
+
+
+## Getting Started with a blank _Unity3d_ project
+
+Assuming you don't have _fastlane_ configured yet, we propose the following:
+1) Add the [_Unity Build Exporter_](https://github.com/ar-met/unity-build-exporter) via the [_Unity Package Manager_](https://docs.unity3d.com/Manual/Packages.html) to your _Unity3d_ project
+2) Open your _Unity3d_ project and find the menu items `Build Exporter / Initialize 'fastlane' directories for Android` and `Build Exporter / Initialize 'fastlane' directories for iOS`
+3) Commit the changes to your repository
+4) Navigate to `{Unity3d-project-root}/fastlane-build-exporter/iOS` and `{Unity3d-project-root}/fastlane-build-exporter/Android` and `fastlane init` respectively
+5) Commit the changes to your repository
+6) See [Getting Started](#getting-started)
+7) Use [the actions of the plugin](#actions)
+
+We suggest you also check out the [_example Unity3d project_](https://github.com/ar-met/fastlane-plugin-unity-exporter-example-project).
+
+
+## Actions
+
+Two actions are provided by this plugin:
+* `fastlane action unity_export`
+* `fastlane action unity_commit_version_bump`
+
+### Using `unity_export` with parameter `arguments`
+
+Note that when writing `{path-to-unity}` we expect a path like so:
+* Mac: `/Applications/Unity/Hub/Editor/<version>/Unity.app/Contents/MacOS/Unity`
+* Windows: `"C:\Program Files\Unity\Hub\Editor\<version>\Editor\Unity.exe"`
+* Linux: [see open issue](https://github.com/ar-met/fastlane-plugin-unity-exporter/issues/1)
+
+```ruby
+# for a full list of commandline arguments that are available to Unity see https://docs.unity3d.com/Manual/CommandLineArguments.html
+# uses the Unity Hub to resolve the path to a Unity Editor installation
+unity_export(arguments: "-batchmode -nographics -quit") 
+
+# setting 'use_default_path' to 'false', will not resolve the path to a Unity Editor installation via the Unity Hub
+# a path to a Unity Editor installation is expected as part of 'arguments'
+unity_export(arguments: "{path-to-unity} -batchmode -nographics -quit", use_default_paths: false)
+```
+
+### Using `unity_export` with parameter `build_target` 
+
+```ruby
+# will export a Xcode project
+unity_export(build_target: "iOS") 
+
+# will export an Android project ('Export Project' is ticked, see https://docs.unity3d.com/Manual/android-BuildProcess.html)
+unity_export(build_target: "Android")
+
+# expects a semantic version and sets this version as the new Unity3d project version
+# for semantic versioning see https://semver.org/
+unity_export(build_target: "...", new_version: "1.2.3")
+
+# increments the major, minor or patch part of the existing semantic version
+unity_export(build_target: "...", new_version: "major")
+unity_export(build_target: "...", new_version: "minor")
+unity_export(build_target: "...", new_version: "patch")
+
+# note that the plugin will keep the version code in sync across different platforms: version code (Android) and build number (iOS) will be the same
+# expects a non-negative number and sets it as version code
+unity_export(build_target: "...", new_version_code: "42")
+
+# increments the existing version code (Android) and build number (iOS)
+unity_export(build_target: "...", new_version_code: "increment")
+
+# combined usage of 'new_version' and 'new_version_code'
+unity_export(build_target: "...", new_version: "2.3.4", new_version_code: "0")
+```
+
+### Using `unity_commit_version_bump`
+
+Uses [shell commands to commit a version bump](https://github.com/ar-met/fastlane-plugin-unity-exporter/blob/master/lib/fastlane/plugin/unity_exporter/actions/unity_commit_version_bump.rb), if there is any.
+
+```ruby
+# let's say we first export the Unity3d project
+unity_export(build_target: "...", new_version: "3.4.5", new_version_code: "0")
+
+# after the export is finished, we commit the version bump
+unity_commit_version_bump
+```
+
+
+## Compatibility
+
+Both this _fastlane plugin_ and the [_Unity Build Exporter_](https://github.com/ar-met/unity-build-exporter) were developed with _Unity 2020.3.13f1_. We haven't tested the plugin with any earlier versions, but we don't expect there to be any issues. If you run into trouble, regarding compatibility or anything else, [please open an issue](https://github.com/ar-met/unity-build-exporter/issues). For pull requests [see here](#pull-requests).
+
+
+## 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`.
+
+Also check out the example [_Unity3d_ project](https://github.com/ar-met/fastlane-plugin-unity-exporter-example-project) to see how this plugin works. See the repositories readme for more details.
+
+
+## Pull requests
+
+We are happy to accept [pull requests](https://github.com/ar-met/unity-build-exporter/pulls). For easier development of this plugin, we suggest you use the provided [_Unity3d_ project](https://github.com/ar-met/fastlane-plugin-unity-exporter-dev-project).
+
+
+## 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/unity_exporter.rb

@@ -0,0 +1,16 @@
+require 'fastlane/plugin/unity_exporter/version'
+
+module Fastlane
+  module UnityExporter
+    # 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::UnityExporter.all_classes.each do |current|
+  require current
+end

data/lib/fastlane/plugin/unity_exporter/actions/unity_commit_version_bump.rb

@@ -0,0 +1,46 @@
+require 'fastlane/action'
+require_relative '../helper/unity_editor_helper'
+
+module Fastlane
+  module Actions
+    class UnityCommitVersionBumpAction < Action
+      def self.run(params)
+        # TODO: improve the commit command: currently it simply commits the ProjectSettings file
+        #      what if there are other changes in the file and you don't want these changes to be part of the commit
+
+        log_file = "unity-export-logs/#{DateTime.now.strftime('%Y-%m-%d_%H-%M-%S-%L')}_git.log"
+
+        # Thank you: https://linuxize.com/post/bash-redirect-stderr-stdout/#redirecting-stderr-to-stdout
+        sh("echo 'UnityCommitVersionBumpAction: created file' > #{log_file} 2>&1")
+        sh("git add '#{Helper::UnityEditorHelper.unity_project_path_relative_to_fastfile}ProjectSettings/ProjectSettings.asset' >> #{log_file} 2>&1")
+        sh("git commit -m 'Version Bump' >> #{log_file} 2>&1")
+      end
+
+      def self.description
+        "Commits a version bump, if there is any."
+      end
+
+      def self.authors
+        ["steft"]
+      end
+
+      def self.return_value
+        # If your method provides a return value, you can describe here what it does
+      end
+
+      def self.details
+        # Optional:
+      end
+
+      def self.available_options
+      end
+
+      def self.is_supported?(platform)
+        # Adjust this if your plugin only works for a particular platform (iOS vs. Android, for example)
+        # See: https://docs.fastlane.tools/advanced/#control-configuration-by-lane-and-by-platform
+        [:ios, :android].include?(platform)
+        true
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/unity_exporter/actions/unity_export.rb

@@ -0,0 +1,174 @@
+require 'fastlane/action'
+require 'fastlane_core/configuration/config_item'
+require_relative '../helper/unity_editor_helper'
+require_relative '../helper/unity_hub_helper'
+
+module Fastlane
+  module Actions
+    class UnityExportAction < Action
+      def self.run(params)
+        if params[:arguments]
+          if params[:use_default_paths]
+            invoke_unity(arguments: " #{params[:arguments]}")
+          else
+            # path to Unity is provided as part of 'arguments'
+            UI.important("Expecting path to Unity as part of 'arguments'.")
+            sh(params[:arguments])
+          end
+
+        elsif params[:build_target]
+          # following are arguments as defined in the docs: https://docs.unity3d.com/Manual/CommandLineArguments.html
+          headless_args = "-buildTarget #{params[:build_target]}"
+          headless_args << " -batchmode -nographics -quit" # some arguments that are required when running Unity in headless-mode
+          headless_args << " -accept-apiupdate -releaseCodeOptimization"
+          headless_args << " -projectPath #{Helper::UnityEditorHelper.unity_project_path_relative_to_fastfile}"
+          headless_args << " -logFile unity-export-logs/#{DateTime.now.strftime('%Y-%m-%d_%H-%M-%S-%L')}_#{params[:build_target]}_build.log" # logging; not specifying a path will print the log to the console
+
+          # following are custom arguments defined in 'UnityExporter.BuildUtility'
+          # this script is part of the 'fastlane-plugin-unity-exporter-package'
+          headless_args << " -executeMethod armet.BuildExporter.BuildUtility.CreateBuild"
+          headless_args << " -newVersion #{params[:new_version]}" if params[:new_version]
+          headless_args << " -newVersionCode #{params[:new_version_code]}" if params[:new_version_code]
+          headless_args << " -exportPath fastlane-build-exporter/#{params[:build_target]}/unity-export"
+
+          # NOTE: the different relative paths used in 'projectPath' and 'exportPath'
+          # while 'projectPath' is relative to the 'fastfile',
+          # 'exportPath' is relative to 'projectPath' aka the Unity project's root directory
+
+          invoke_unity(arguments: headless_args)
+
+        else
+          UI.user_error!("Either provide a 'build_target' or 'arguments'.") if !params[:build_target] && !params[:arguments]
+
+        end
+      end
+
+      def self.invoke_unity(params)
+        unless params[:arguments]
+          UI.error("'arguments' required")
+          return
+        end
+
+        unless Helper::UnityHubHelper.verify_default_path
+          return
+        end
+
+        unless Helper::UnityEditorHelper.verify_exporter_package
+          return
+        end
+
+        unity_path = Helper::UnityEditorHelper.unity_editor_path
+        if unity_path == ""
+          return
+        end
+
+        UI.message("Open 'logFile', if you want to know whats going on with your build.")
+        invocation = unity_path.to_s
+        invocation << " #{params[:arguments]}"
+        sh(invocation) # 'sh' will print what's passed to it
+      end
+
+      def self.description
+        "Exports a Unity project."
+      end
+
+      def self.authors
+        ["steft"]
+      end
+
+      def self.return_value
+        # If your method provides a return value, you can describe here what it does
+      end
+
+      def self.details
+        # Optional:
+        "Plugin for 'fastlane' that defines a pre-processing action to export iOS and Android projects via Unity3D. This allows Unity3D to more easily integrate with 'fastlane'."
+      end
+
+      def self.available_options
+        [
+          #
+          # How to start Unity via commandline?
+          # Want a full list of all of Unity's commandline arguments?
+          # See here: https://docs.unity3d.com/Manual/CommandLineArguments.html
+          #
+
+          FastlaneCore::ConfigItem.new(key: :arguments,
+                                       env_name: "FL_UNITY_ARGUMENTS",
+                                       description: "Use the 'arguments' parameter, if you want to specify all headless arguments yourself. See Unity docs regarding 'CommandLineArguments' for a all available arguments",
+                                       optional: true,
+                                       type: String,
+                                       conflicting_options: [:build_target]),
+
+          FastlaneCore::ConfigItem.new(key: :use_default_paths,
+                                       env_name: "FL_UNITY_USE_DEFAULT_PATHS",
+                                       description: "'true': Plugin expects Unity default paths. 'false': Custom path is provided as part of the 'arguments' parameter",
+                                       optional: true,
+                                       default_value: true,
+                                       conflicting_options: [:build_target],
+                                       verify_block: proc do |value|
+                                         unless value == true || value == false
+                                           UI.user_error!("Must be set to 'true' or 'false'.")
+                                         end
+                                       end),
+
+          FastlaneCore::ConfigItem.new(key: :build_target,
+                                       env_name: "FL_UNITY_BUILD_TARGET",
+                                       description: "The build target. Options: 'iOS' and/or 'Android' depending on your platform",
+                                       optional: true,
+                                       type: String,
+                                       conflicting_options: [:arguments],
+                                       verify_block: proc do |value|
+                                         # For now we only support iOS and Android as these platforms are supported by fastlane as well.
+                                         # TODO add support for other platforms that are also supported by both fastlane and Unity
+                                         # TODO verify if Unity's commandline param 'buildTarget' is case-sensitive
+                                         if FastlaneCore::Helper.is_mac?
+                                           unless value == "iOS" || value == "Android"
+                                             UI.user_error!("Please pass a valid build target. Mac options: 'iOS', 'Android'")
+                                           end
+                                         elsif FastlaneCore::Helper.is_windows?
+                                           unless value == "Android"
+                                             UI.user_error!("Please pass a valid build target. Windows options: 'Android'")
+                                           end
+                                         end
+                                       end),
+
+          FastlaneCore::ConfigItem.new(key: :new_version,
+                                       env_name: "FL_UNITY_NEW_VERSION",
+                                       description: "The new version. Options: 'major', 'minor', 'patch' (for bumping) and '{major}.{minor}.{patch}' (new semantic version to apply)",
+                                       optional: true,
+                                       type: String,
+                                       conflicting_options: [:arguments],
+                                       verify_block: proc do |value|
+                                         unless value == "major" || value == "minor" || value == "patch" || Gem::Version.new(value).correct?
+                                           UI.user_error!("Please pass a valid version. For options see 'fastlane action unity_exporter'")
+                                         end
+                                       end),
+
+          FastlaneCore::ConfigItem.new(key: :new_version_code,
+                                       env_name: "FL_UNITY_NEW_VERSION_CODE",
+                                       description: "The new version code. Options: 'increment' (for incrementing the current code), '{unsigned integer}' (new code to apply)",
+                                       optional: true,
+                                       type: String,
+                                       conflicting_options: [:arguments],
+                                       verify_block: proc do |value|
+                                         unless value == "increment"
+                                           # Thank you: https://stackoverflow.com/a/24980633
+                                           num = value.to_i
+                                           if num.to_s != value || num < 0
+                                             UI.user_error!("Please pass a valid version code. For options see 'fastlane action unity_exporter'")
+                                           end
+                                         end
+                                       end)
+        ]
+      end
+
+      def self.is_supported?(platform)
+        # Adjust this if your plugin only works for a particular platform (iOS vs. Android, for example)
+        # See: https://docs.fastlane.tools/advanced/#control-configuration-by-lane-and-by-platform
+        [:ios, :android].include?(platform)
+        true
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/unity_exporter/helper/generic_helper.rb

@@ -0,0 +1,24 @@
+require 'fastlane_core/ui/ui'
+require 'shellwords'
+
+module Fastlane
+  UI = FastlaneCore::UI unless Fastlane.const_defined?("UI")
+
+  module Helper
+    class GenericHelper
+      def self.shellify(path)
+        if FastlaneCore::Helper.is_mac?
+          return Shellwords.escape(path)
+
+        elsif FastlaneCore::Helper.is_windows?
+          return "\"#{path}\""
+
+        elsif FastlaneCore::Helper.linux?
+          # TODO
+          UI.error("Not implemented yet")
+
+        end
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/unity_exporter/helper/unity_editor_helper.rb

@@ -0,0 +1,111 @@
+require 'fastlane_core/ui/ui'
+require 'shellwords'
+require_relative './unity_hub_helper'
+require_relative './generic_helper'
+
+module Fastlane
+  UI = FastlaneCore::UI unless Fastlane.const_defined?("UI")
+
+  module Helper
+    class UnityEditorHelper
+      def self.unity_project_path_relative_to_fastfile
+        # project path relative if following hierarchy is given: "root/{unity-project}/fastlane-build-exporter/{platform}-export/."
+        # p File.expand_path("../../")
+        return "../../"
+      end
+
+      def self.unity_editor_path
+        unity_binary_path = find_best_unity_editor_version
+        return Helper::GenericHelper.shellify(unity_binary_path)
+      end
+
+      def self.find_best_unity_editor_version
+        installed_editors = Helper::UnityHubHelper.unity_hub_installed_editors
+
+        unity_project_version = load_unity_project_version
+        UI.important("Unity project uses version '#{unity_project_version}'")
+
+        if installed_editors.key?(unity_project_version)
+          UI.important("'#{unity_project_version}' is installed!")
+          return installed_editors[unity_project_version][2]
+        end
+
+        fallback_editor_version = find_closest_unity_version(unity_project_version, installed_editors.keys)
+        if fallback_editor_version == ""
+          # TODO: offer to install appropriate editor via Hub?
+          UI.user_error!("'#{unity_project_version}' not installed. No appropriate fallback found. Please install ‘#{unity_project_version}‘ or the latest '#{unity_project_version_no_patch}' manually via the Unity Hub.")
+          return ""
+        end
+
+        UI.important("'#{unity_project_version}' not installed. Using '#{fallback_editor_version}' instead.")
+        return installed_editors[fallback_editor_version][2]
+      end
+
+      def self.verify_exporter_package
+        # verifies that the UnityExporter package has been added to the Unity project
+        # TODO Unity currently does not support commandline arguments for the Package Manager
+        exporter_package_namespace = "io.armet.unity.buildexporter"
+        included = load_unity_project_package_manifest.include?(exporter_package_namespace)
+        unless included
+          UI.user_error!("Package 'io.armet.unity.exporter' must be added to the Unity project.")
+        end
+
+        return included
+      end
+
+      def self.load_unity_project_package_manifest
+        relative_path = if FastlaneCore::Helper.is_test?
+                          "/tmp/fastlane/tests/fixtures/unity_project"
+                        else
+                          unity_project_path_relative_to_fastfile
+                        end
+
+        package_manifest_path = "#{relative_path}/Packages/manifest.json"
+        package_manifest_json = File.read(package_manifest_path)
+        return package_manifest_json
+      end
+
+      def self.load_unity_project_version
+        relative_path = if FastlaneCore::Helper.is_test?
+                          "/tmp/fastlane/tests/fixtures/unity_project"
+                        else
+                          unity_project_path_relative_to_fastfile
+                        end
+
+        project_version_txt_path = "#{relative_path}/ProjectSettings/ProjectVersion.txt"
+        project_version_txt = File.read(project_version_txt_path)
+        project_version_match = project_version_txt.scan(/.*: (\d+\.\d+\.\d+[abf]\d+).*/)
+        project_version = project_version_match[0][0]
+        return project_version
+      end
+
+      def self.find_closest_unity_version(unity_version, other_versions)
+        # finds closest version by ignoring "patch"
+        closest_version = ""
+        version_no_patch_regex = /\d+\.\d+/
+        unity_project_version_no_patch = unity_version.match(version_no_patch_regex)[0]
+        other_versions_sorted = sort_unity_versions(other_versions)
+
+        other_versions_sorted_no_patch = other_versions_sorted.map do |other_version|
+          m = other_version.match(version_no_patch_regex)
+          if m.length > 0
+            m[0]
+          end
+        end
+
+        other_versions_sorted_no_patch.each_with_index do |other_version_no_patch, index|
+          if other_version_no_patch == unity_project_version_no_patch
+            # since the list is sorted, we keep going to match the highest available path version
+            closest_version = other_versions_sorted[index]
+          end
+        end
+
+        return closest_version
+      end
+
+      def self.sort_unity_versions(unity_versions)
+        return unity_versions.sort_by { |v| Gem::Version.new(v) }
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/unity_exporter/helper/unity_hub_helper.rb

@@ -0,0 +1,95 @@
+require 'fastlane_core/ui/ui'
+require_relative './generic_helper'
+
+module Fastlane
+  UI = FastlaneCore::UI unless Fastlane.const_defined?("UI")
+
+  module Helper
+    class UnityHubHelper
+      def self.unity_hub_path(escape_for_shell)
+        # https://docs.unity3d.com/Manual/GettingStartedInstallingHub.html
+        hub_path = ""
+
+        if FastlaneCore::Helper.is_mac?
+          hub_path = "/Applications/Unity Hub.app/Contents/MacOS/Unity Hub"
+        elsif FastlaneCore::Helper.is_windows?
+          hub_path = "C:\\Program Files\\Unity Hub\\Unity Hub.exe"
+        elsif FastlaneCore::Helper.linux?
+          # TODO
+          UI.error("Not implemented yet")
+        end
+
+        if escape_for_shell
+          return Helper::GenericHelper.shellify(hub_path)
+        else
+          return hub_path
+        end
+      end
+
+      def self.verify_default_path
+        # verifies that the Unity Hub exists at the default path
+        exists = File.file?(Helper::UnityHubHelper.unity_hub_path(false)) == true
+        unless exists
+          UI.error("Unity Hub does not exist at path '#{Helper::UnityHubHelper.unity_hub_path(false)}'")
+        end
+
+        return exists
+      end
+
+      def self.unity_hub_installed_editors
+        UI.message("Looking for installed Unity Editors known to the Unity Hub...")
+
+        # Unity Hub help: "./Unity\ Hub -- --headless help"
+        installed_editors_result = `#{unity_hub_path(true)} -- --headless editors -i`
+        installed_editors_list = parse_installed_editors(installed_editors_result)
+        installed_editors = installed_editors_list.collect do |installed_editor|
+          [installed_editor[0],
+           [
+             installed_editor[0],
+             installed_editor[1],
+             unity_binary_relative_to_path(installed_editor[2])
+           ]]
+        end.to_h
+
+        UI.message("Found Unity Editors: #{installed_editors.keys}")
+        return installed_editors
+      end
+
+      def self.parse_installed_editors(installed_editors_string)
+        installed_editors_list = []
+        installed_editors_string.split("\n").each do |editor_description|
+          next if editor_description == "" # skipping empty strings
+
+          # Mac: "2019.4.18f1 , installed at /Applications/Unity/Hub/Editor/2019.4.18f1/Unity.app"
+          # Windows: "2019.4.18f1 , installed at C:\Program Files\Unity\Hub\Editor\2019.4.18f1\Editor\Unity.exe"
+          # Linux: ?? TODO
+          editor_match = editor_description.scan(/((\d+\.\d+\.\d+)[abf]\d+).*installed at (.*)/)
+          installed_editors_list.append(
+            [
+              editor_match[0][0], # the Unity version
+              editor_match[0][1], # the semantic version part of the Unity version
+              editor_match[0][2] # the path to the Unity Editor
+            ]
+          )
+        end
+        return installed_editors_list
+      end
+
+      def self.unity_binary_relative_to_path(unity_path)
+        # https://docs.unity3d.com/Manual/GettingStartedInstallingHub.html#install
+
+        if FastlaneCore::Helper.is_mac?
+          # Mac example: "/Applications/Unity/Hub/Editor/<version>/Unity.app"
+          return "#{unity_path}/Contents/MacOS/Unity"
+        elsif FastlaneCore::Helper.is_windows?
+          # Windows example: "C:\Program Files\Unity\Hub\Editor\<version>\Editor\Unity.exe"
+          # path can be taken as is
+          return unity_path
+        elsif FastlaneCore::Helper.linux?
+          # Linux example: ?? TODO
+          UI.error("Not implemented yet")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,5 @@
+module Fastlane
+  module UnityExporter
+    VERSION = "1.0.0"
+  end
+end

metadata

@@ -0,0 +1,192 @@
+--- !ruby/object:Gem::Specification
+name: fastlane-plugin-unity_exporter
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- ar:met
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-07-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fastlane
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.187.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.187.0
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec_junit_formatter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.12.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.12.1
+- !ruby/object:Gem::Dependency
+  name: rubocop-performance
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-require_tools
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description:
+email: office@armet.at
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/fastlane/plugin/unity_exporter.rb
+- lib/fastlane/plugin/unity_exporter/actions/unity_commit_version_bump.rb
+- lib/fastlane/plugin/unity_exporter/actions/unity_export.rb
+- lib/fastlane/plugin/unity_exporter/helper/generic_helper.rb
+- lib/fastlane/plugin/unity_exporter/helper/unity_editor_helper.rb
+- lib/fastlane/plugin/unity_exporter/helper/unity_hub_helper.rb
+- lib/fastlane/plugin/unity_exporter/version.rb
+homepage: https://github.com/ar-met/fastlane-plugin-unity-exporter
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.5'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key:
+specification_version: 4
+summary: Plugin for 'fastlane' that defines an action to export iOS and Android projects
+  via Unity3d. This allows Unity3d to more easily integrate with 'fastlane'.
+test_files: []