fastlane-plugin-nico 0.10.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 259c370e91a20c3cd611d0c7c177e77e8513d5e1d9e3475cdb95b5f3371549e6
+  data.tar.gz: 243639ffeb90a983f58a92d3e8662bfaf8878af2217cb0077f2fc9349994ed9e
+SHA512:
+  metadata.gz: aee24183a3debfd3c4b99612737426f8047df98bdb9bf9111aabf9dae35f2a5862d7a9aea1a516fc19a1a1074196b29056063ab8f6beb06965cf99db4a434645
+  data.tar.gz: 7b5cad5c552acde4ff08d1415be04540337f74224117c4bd6ee30e5d12dedc97a6d48a2d6a274f56d4bc718d0df580422f1cf02c8de86581544a7d15e1f71b13

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 Noah Martin <noahm444@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,100 @@
+# Emerge `fastlane` plugin
+
+[![fastlane Plugin Badge](https://rawcdn.githack.com/fastlane/fastlane/master/fastlane/assets/plugin-badge.svg)](https://rubygems.org/gems/fastlane-plugin-emerge)
+
+## Getting Started
+
+This project is a [_fastlane_](https://github.com/fastlane/fastlane) plugin. To get started with `fastlane-plugin-emerge`, add it to your project by running:
+
+```bash
+fastlane add_plugin emerge
+```
+
+## About Emerge
+
+[Emerge](https://emergetools.com) offers a suite of products to help optimize app size, performance and quality. This plugin provides a set of actions to interact with the Emerge API.
+
+## Usage
+
+To get started, first obtain an [API token](https://docs.emergetools.com/docs/uploading-basics#obtain-an-api-key) for your organization. The API Token is used to authenticate with the Emerge API in each call. Our actions will automatically pick up the API key if configured as an `EMERGE_API_TOKEN` environment variable.
+
+### Size Analysis
+
+```ruby
+platform :ios do
+  lane :emerge_upload do
+    # Tip: group builds in our dashboard via the `tag` parameter
+    emerge(tag: 'pr_build')
+  end
+end
+```
+
+1. Produce a build using `gym()`, `run_tests()`, or other Fastlane actions
+2. When you are ready to upload to Emerge, simply call the `emerge()` action
+    - a. We will automatically detect the most recently built app to upload, or you can manually pass in a `file_path` parameter
+
+For a full list of available parameters run `fastlane action emerge`.
+
+### Snapshot Testing
+
+```ruby
+platform :ios do
+  lane :snapshot_testing do
+    # Call our `emerge_snapshot()` action with the respective scheme for
+    # us to build. We will generate a build with the recommended settings
+    # and upload to our API.
+    emerge_snapshot(scheme: 'Hacker News')
+  end
+end
+```
+
+For a full list of available parameters run `fastlane action emerge_snapshot`.
+
+## Git Configuration
+
+For build comparisons to work, Emerge needs the appropriate Git `sha` and `base_sha` values set on each build. Emerge will automatically compare a build at `sha` against the build we find matching the `base_sha` for a given application id. We also recommend setting `pr_number`, `branch`, `repo_name`, and `previous_sha` for the best experience.
+
+For example:
+
+- `sha`: `pr-branch-commit-2`
+- `base_sha`: `main-branch-commit-1`
+- `previous_sha`: `pr-branch-commit-1`
+- `pr_number`: `42`
+- `branch`: `my-awesome-feature`
+- `repo_name`: `EmergeTools/hackernews`
+
+Will compare the size difference of your pull request changes.
+
+This plugin will automatically configure Git values for you assuming certain Github workflow triggers:
+
+```yaml
+on:
+  # Produce base builds with a 'sha' when commits are pushed to the main branch
+  push:
+    branches: [main]
+
+  # Produce branch comparison builds with `sha` and `base_sha` when commits are pushed
+  # to open pull requests
+  pull_request:
+    branches: [main]
+
+  ...
+```
+
+If this doesn't cover your use-case, manually set the `sha` and `base_sha` values when calling the Emerge plugin.
+
+## Issues and Feedback
+
+For any other issues and feedback about this plugin, please open a [GitHub issue](https://github.com/EmergeTools/fastlane-plugin-emerge/issues).
+
+## 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/emerge/actions/emerge_action.rb

@@ -0,0 +1,227 @@
+require 'fastlane/action'
+require 'fastlane_core/print_table'
+require_relative '../helper/emerge_helper'
+require_relative '../helper/git'
+require_relative '../helper/github'
+require 'pathname'
+require 'tmpdir'
+require 'json'
+require 'fileutils'
+
+module Fastlane
+  module Actions
+    class EmergeAction < Action
+      def self.run(params)
+        api_token = params[:api_token]
+
+        file_path = if params[:file_path]
+                      UI.message("Using input file_path: #{file_path}")
+                      params[:file_path]
+                    elsif lane_context[SharedValues::XCODEBUILD_ARCHIVE]
+                      UI.message("Using XCODEBUILD_ARCHIVE path")
+                      lane_context[SharedValues::XCODEBUILD_ARCHIVE]
+                    else
+                      UI.message("Falling back to searching SCAN_DERIVED_DATA_PATH")
+                      Dir.glob("#{lane_context[SharedValues::SCAN_DERIVED_DATA_PATH]}/Build/Products/Debug-iphonesimulator/*.app").first
+                    end
+
+        git_params = Helper::EmergeHelper.make_git_params
+        pr_number = params[:pr_number] || git_params.pr_number
+        branch = params[:branch] || git_params.branch
+        sha = params[:sha] || params[:build_id] || git_params.sha
+        base_sha = params[:base_sha] || params[:base_build_id] || git_params.base_sha
+        previous_sha = params[:previous_sha] || git_params.previous_sha
+        repo_name = params[:repo_name] || git_params.repo_name
+        gitlab_project_id = params[:gitlab_project_id]
+        tag = params[:tag]
+        order_file_version = params[:order_file_version]
+        config_path = params[:config_path]
+
+        if file_path.nil? || !File.exist?(file_path)
+          UI.error("Invalid input file")
+          return false
+        else
+          UI.message("Using file_path: #{file_path}")
+        end
+        extension = File.extname(file_path)
+
+        # If the user provided a .app we will look for dsyms and package it into a zipped xcarchive
+        if extension == '.app'
+          absolute_path = Pathname.new(File.expand_path(file_path))
+          UI.message("A .app was provided, dSYMs will be looked for in #{absolute_path.dirname}")
+          Dir.mktmpdir do |d|
+            application_folder = "#{d}/archive.xcarchive/Products/Applications/"
+            dsym_folder = "#{d}/archive.xcarchive/dSYMs/"
+            FileUtils.mkdir_p(application_folder)
+            FileUtils.mkdir_p(dsym_folder)
+            if params[:linkmaps] && params[:linkmaps].length > 0
+              linkmap_folder = "#{d}/archive.xcarchive/Linkmaps/"
+              FileUtils.mkdir_p(linkmap_folder)
+              params[:linkmaps].each do |l|
+                FileUtils.cp(l, linkmap_folder)
+              end
+            end
+            Helper::EmergeHelper.copy_config(config_path, "#{d}/archive.xcarchive")
+            FileUtils.cp_r(file_path, application_folder)
+            copy_dsyms("#{absolute_path.dirname}/*.dsym", dsym_folder)
+            copy_dsyms("#{absolute_path.dirname}/*/*.dsym", dsym_folder)
+            Xcodeproj::Plist.write_to_path({ "NAME" => "Emerge Upload" }, "#{d}/archive.xcarchive/Info.plist")
+            file_path = "#{absolute_path.dirname}/archive.xcarchive.zip"
+            ZipAction.run(
+              path: "#{d}/archive.xcarchive",
+              symlinks: true,
+              output_path: file_path,
+              exclude: [],
+              include: []
+            )
+            UI.message("Archive generated at #{file_path}")
+          end
+        elsif extension == '.xcarchive'
+          zip_path = file_path + ".zip"
+          if params[:linkmaps] && params[:linkmaps].length > 0
+            linkmap_folder = "#{file_path}/Linkmaps/"
+            FileUtils.mkdir_p(linkmap_folder)
+            params[:linkmaps].each do |l|
+              FileUtils.cp(l, linkmap_folder)
+            end
+          end
+          Helper::EmergeHelper.copy_config(config_path, file_path)
+          Actions::ZipAction.run(
+            path: file_path,
+            symlinks: true,
+            output_path: zip_path,
+            exclude: [],
+            include: []
+          )
+          file_path = zip_path
+        elsif (extension == '.zip' || extension == '.ipa') && params[:linkmaps] && params[:linkmaps].length > 0
+          UI.error("Provided #{extension == '.zip' ? 'zipped archive' : 'ipa'} and linkmaps, linkmaps will not be added to upload.")
+        elsif extension != '.zip' && extension != '.ipa'
+          UI.error("Invalid input file")
+          return false
+        end
+
+        params = {
+          prNumber: pr_number,
+          branch: branch,
+          sha: sha,
+          baseSha: base_sha,
+          previousSha: previous_sha,
+          repoName: repo_name,
+          gitlabProjectId: gitlab_project_id,
+          orderFileVersion: order_file_version,
+          appIdSuffix: params[:app_id_suffix],
+          releaseNotes: params[:release_notes],
+          tag: tag || "default"
+        }
+        upload_id = Helper::EmergeHelper.perform_upload(api_token, params, file_path)
+        UI.success("🎉 Your app is processing, you can find the results at https://emergetools.com/build/#{upload_id}")
+        upload_id
+      end
+
+      def self.copy_dsyms(from, to)
+        Dir.glob(from) do |filename|
+          UI.message("Found dSYM: #{Pathname.new(filename).basename}")
+          FileUtils.cp_r(filename, to)
+        end
+      end
+
+      def self.description
+        "Fastlane plugin for Emerge"
+      end
+
+      def self.authors
+        ["Emerge Tools"]
+      end
+
+      def self.return_value
+        "If successful, returns the upload id of the generated build"
+      end
+
+      def self.details
+        ""
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :api_token,
+                                       env_name: "EMERGE_API_TOKEN",
+                                       description: "An API token for Emerge",
+                                       optional: false,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :file_path,
+                                       env_name: "EMERGE_FILE_PATH",
+                                       description: "Path to the zipped xcarchive or app to upload",
+                                       optional: true,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :linkmaps,
+                                       description: "List of paths to linkmaps",
+                                       optional: true,
+                                       type: Array),
+          FastlaneCore::ConfigItem.new(key: :pr_number,
+                                       description: "The PR number that triggered this upload",
+                                       optional: true,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :branch,
+                                       description: "The current git branch",
+                                       optional: true,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :sha,
+                                       description: "The git SHA that triggered this build",
+                                       optional: true,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :base_sha,
+                                       description: "The git SHA of the base build",
+                                       optional: true,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :previous_sha,
+                                       description: "The git SHA of the commit right before this build's commit",
+                                       optional: true,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :build_id,
+                                       description: "A string to identify this build",
+                                       deprecated: "Replaced by `sha`",
+                                       optional: true,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :base_build_id,
+                                       description: "Id of the build to compare with this upload",
+                                       deprecated: "Replaced by `base_sha`",
+                                       optional: true,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :repo_name,
+                                       description: "Full name of the respository this upload was triggered from. For example: EmergeTools/Emerge",
+                                       optional: true,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :gitlab_project_id,
+                                       description: "Id of the gitlab project this upload was triggered from",
+                                       optional: true,
+                                       type: Integer),
+          FastlaneCore::ConfigItem.new(key: :tag,
+                                       description: "String to label the build. Useful for grouping builds together in our dashboard, like development, default, or pull-request",
+                                       optional: true,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :order_file_version,
+                                       description: "Version of the order file to download",
+                                       optional: true,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :config_path,
+                                       description: "Path to Emerge config path",
+                                       optional: true,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :app_id_suffix,
+                                       description: "A suffix to append to the application ID to differentiate between different builds of the same app",
+                                       optional: true,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :release_notes,
+                                       description: "A markdown string with release notes for the upload",
+                                       optional: true,
+                                       type: String)
+        ]
+      end
+
+      def self.is_supported?(platform)
+        platform == :ios
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/emerge/actions/emerge_comment_action.rb

@@ -0,0 +1,86 @@
+require 'fastlane/action'
+require 'fastlane_core/print_table'
+require_relative '../helper/emerge_helper'
+
+module Fastlane
+  module Actions
+    class EmergeComment < Action
+      def self.run(params)
+        url = 'https://api.emergetools.com/getComment'
+        api_token = params[:api_token]
+        gitlab_url = params[:gitlab_url]
+        project_id = params[:gitlab_project_id]
+        pr_number = params[:pr_number]
+        gitlab_access_token = params[:gitlab_access_token]
+
+        request_params = {
+          buildId: params[:build_id],
+          baseBuildId: params[:base_build_id]
+        }
+        resp = Faraday.get(url, request_params, 'x-api-token' => api_token)
+        case resp.status
+        when 200
+          UI.message("Received comment from Emerge")
+          baseURL = gitlab_url ? gitlab_url : "https://gitlab.com"
+          url = "#{baseURL}/api/v4/projects/#{project_id}/merge_requests/#{pr_number}/notes"
+          gitlab_response = Faraday.post(url, { "body" => resp.body }, 'Authorization' => "Bearer #{gitlab_access_token}")
+          case gitlab_response.status
+          when 200...299
+            UI.message("Successfully posted comment")
+          else
+            UI.error("Received error #{gitlab_response.status} from Gitlab")
+          end
+        else
+          UI.error("Received error #{resp.status} from Emerge")
+        end
+      end
+
+      def self.description
+        "Post an Emerge PR comment, currently supports Gitlab only."
+      end
+
+      def self.authors
+        ["Emerge Tools"]
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :api_token,
+                                       env_name: "EMERGE_API_TOKEN",
+                                       description: "An API token for Emerge",
+                                       optional: false,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :gitlab_acces_token,
+                                       env_name: "GITLAB_ACCESS_TOKEN",
+                                       description: "An access token for Gitlab",
+                                       optional: false,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :pr_number,
+                                       description: "The PR number that triggered this upload",
+                                       optional: false,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :build_id,
+                                       description: "A string to identify this build",
+                                       optional: false,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :base_build_id,
+                                       description: "Id of the build to compare with this upload",
+                                       optional: false,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :gitlab_url,
+                                       description: "URL of the self hosted gitlab instance",
+                                       optional: true,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :gitlab_project_id,
+                                       description: "Id of the gitlab project this upload was triggered from",
+                                       optional: false,
+                                       type: Integer)
+        ]
+      end
+
+      def self.is_supported?(platform)
+        platform == :ios
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/emerge/actions/emerge_order_file_action.rb

@@ -0,0 +1,77 @@
+require 'fastlane/action'
+require 'tmpdir'
+require 'tempfile'
+require 'fileutils'
+
+module Fastlane
+  module Actions
+    class EmergeOrderFileAction < Action
+      def self.run(params)
+        puts "https://order-files-prod.emergetools.com/#{params[:app_id]}/#{params[:order_file_version]}"
+        resp = Faraday.get("https://order-files-prod.emergetools.com/#{params[:app_id]}/#{params[:order_file_version]}", nil, {'X-API-Token' => params[:api_token]})
+        case resp.status
+        when 200
+          Tempfile.create do |f|
+            f.write(resp.body)
+            decompressed = IO.popen(['gunzip', '-c', f.path]).read
+            IO.write(params[:output_path], decompressed)
+          end
+          return 200
+        when 401
+          UI.error("Unauthorized")
+        when 403
+          UI.message("No order file found, this is expected for the first build of an app_id/version.")
+          # The API will return a 403 when no order file is found, but we change that to a 200 for the
+          # fastlane plugin because this is an expected state for a CI integraion.
+          return 200
+        else
+          UI.error("Failed to download order file code: #{resp.status}")
+        end
+        resp.status
+      end
+
+      def self.description
+        "Fastlane plugin to download order files"
+      end
+
+      def self.authors
+        ["Emerge Tools"]
+      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
+        [
+          FastlaneCore::ConfigItem.new(key: :api_token,
+                                  env_name: "EMERGE_API_TOKEN",
+                               description: "An API token for Emerge",
+                                  optional: false,
+                                      type: String),
+          FastlaneCore::ConfigItem.new(key: :app_id,
+                               description: "Id of the app being built with the order file",
+                                  optional: false,
+                                      type: String),
+          FastlaneCore::ConfigItem.new(key: :output_path,
+                                   description: "Path to the order file",
+                                      optional: false,
+                                          type: String),
+          FastlaneCore::ConfigItem.new(key: :order_file_version,
+                               description: "Version of the order file to download",
+                                  optional: false,
+                                      type: String),
+        ]
+      end
+
+      def self.is_supported?(platform)
+        platform == :ios
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/emerge/actions/emerge_snapshot_action.rb

@@ -0,0 +1,162 @@
+require 'fastlane/action'
+require 'fastlane_core/print_table'
+require_relative '../helper/emerge_helper'
+require_relative '../helper/git'
+require_relative '../helper/github'
+require 'pathname'
+require 'tmpdir'
+require 'json'
+require 'fileutils'
+
+module Fastlane
+  module Actions
+    class EmergeSnapshotAction < Action
+      def self.run(params)
+        api_token = params[:api_token]
+
+        git_params = Helper::EmergeHelper.make_git_params
+        pr_number = params[:pr_number] || git_params.pr_number
+        branch = params[:branch] || git_params.branch
+        sha = params[:sha] || git_params.sha
+        base_sha = params[:base_sha] || git_params.base_sha
+        previous_sha = params[:previous_sha] || git_params.previous_sha
+        repo_name = params[:repo_name] || git_params.repo_name
+        gitlab_project_id = params[:gitlab_project_id]
+        tag = params[:tag]
+        config_path = params[:config_path]
+        scheme = params[:scheme]
+        configuration = params[:configuration]
+        team_id = params[:team_id] || CredentialsManager::AppfileConfig.try_fetch_value(:team_id)
+
+        Dir.mktmpdir do |temp_dir|
+          archive_name = "#{scheme}-Emerge-Snapshots"
+          archive_path = "#{temp_dir}/build/#{archive_name}.xcarchive"
+          make_debug_build(
+            scheme: scheme,
+            configuration: configuration,
+            team_id: team_id,
+            archive_path: archive_path
+          )
+          Helper::EmergeHelper.copy_config(config_path, archive_path)
+          Xcodeproj::Plist.write_to_path({ "NAME" => "Emerge Upload" }, "#{archive_path}/Info.plist")
+
+          zip_file_path = "#{temp_dir}/build/#{archive_name}.xcarchive.zip"
+          ZipAction.run(
+            path: archive_path,
+            symlinks: true,
+            output_path: zip_file_path,
+            exclude: [],
+            include: []
+          )
+
+          params = {
+            appIdSuffix: 'snapshots',
+            prNumber: pr_number,
+            branch: branch,
+            sha: sha,
+            baseSha: base_sha,
+            previousSha: previous_sha,
+            repoName: repo_name,
+            gitlabProjectId: gitlab_project_id,
+            tag: tag || "default"
+          }
+          upload_id = Helper::EmergeHelper.perform_upload(api_token, params, zip_file_path)
+          UI.success("🎉 Your app is processing, you can find the results at https://emergetools.com/snapshot/#{upload_id}")
+        end
+      end
+
+      def self.make_debug_build(scheme:, configuration:, team_id:, archive_path:)
+        other_action.gym(
+          scheme: scheme,
+          configuration: configuration,
+          skip_codesigning: true,
+          clean: true,
+          export_method: "development",
+          export_team_id: team_id,
+          skip_package_ipa: true,
+          archive_path: archive_path
+        )
+      end
+
+      def self.description
+        "Fastlane plugin for Emerge to generate iOS snapshots"
+      end
+
+      def self.authors
+        ["Emerge Tools"]
+      end
+
+      def self.return_value
+        "If successful, returns the upload id of the generated snapshot build"
+      end
+
+      def self.details
+        ""
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :api_token,
+                                       env_name: "EMERGE_API_TOKEN",
+                                       description: "An API token for Emerge",
+                                       optional: false,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :scheme,
+                                       description: "The scheme of your app to build",
+                                       optional: false,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :configuration,
+                                       description: "The configuration of your app to use",
+                                       optional: false,
+                                       default_value: "Debug",
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :team_id,
+                                       env_name: "EXPORT_TEAM_ID",
+                                       description: "The Apple Team ID to use for exporting the archive. If not provided, we will try to use the team_id from the Appfile",
+                                       optional: true,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :config_path,
+                                       description: "Path to Emerge YAML config path",
+                                       optional: true,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :pr_number,
+                                       description: "The PR number that triggered this upload",
+                                       optional: true,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :branch,
+                                       description: "The current git branch",
+                                       optional: true,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :sha,
+                                       description: "The git SHA that triggered this build",
+                                       optional: true,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :base_sha,
+                                       description: "The git SHA of the base build",
+                                       optional: true,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :previous_sha,
+                                       description: "The git SHA of the commit right before this build's commit",
+                                       optional: true,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :repo_name,
+                                       description: "Full name of the respository this upload was triggered from. For example: EmergeTools/Emerge",
+                                       optional: true,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :gitlab_project_id,
+                                       description: "Id of the gitlab project this upload was triggered from",
+                                       optional: true,
+                                       type: Integer),
+          FastlaneCore::ConfigItem.new(key: :tag,
+                                       description: "String to label the build. Useful for grouping builds together in our dashboard, like development, default, or pull-request",
+                                       optional: true,
+                                       type: String)
+        ]
+      end
+
+      def self.is_supported?(platform)
+        platform == :ios
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/emerge/helper/emerge_helper.rb

@@ -0,0 +1,140 @@
+require 'fastlane_core/ui/ui'
+require 'faraday'
+
+module Fastlane
+  UI = FastlaneCore::UI unless Fastlane.const_defined?("UI")
+
+  class GitResult
+    attr_accessor :sha, :base_sha, :previous_sha, :branch, :pr_number, :repo_name
+
+    def initialize(sha:, base_sha:, previous_sha:, branch:, pr_number: nil, repo_name: nil)
+      @pr_number = pr_number
+      @sha = sha
+      @base_sha = base_sha
+      @previous_sha = previous_sha
+      @branch = branch
+      @repo_name = repo_name
+    end
+  end
+
+  module Helper
+    class EmergeHelper
+      API_URL = 'https://api.emergetools.com/upload'.freeze
+
+      def self.perform_upload(api_token, params, file_path)
+        cleaned_params = clean_params(params)
+        print_summary(cleaned_params)
+
+        upload_response = create_upload(api_token, cleaned_params)
+        handle_upload_response(api_token, upload_response, file_path)
+      rescue StandardError => e
+        UI.user_error!(e.message)
+      end
+
+      def self.make_git_params
+        git_result = if Helper::Github.is_supported_github_event?
+                       UI.message("Fetching Git info from Github event. This is what we get")
+                       UI.message("Github previous_sha: #{Helper::Github.previous_sha}")
+                       UI.message("Git previous_sha: #{Helper::Git.previous_sha}")
+                       UI.message("Ok for real going to fetch")
+                       GitResult.new(
+                         sha: Helper::Github.sha,
+                         base_sha: Helper::Github.base_sha,
+                         previous_sha: Helper::Github.previous_sha,
+                         branch: Helper::Github.branch,
+                         pr_number: Helper::Github.pr_number,
+                         repo_name: Helper::Github.repo_name
+                       )
+                     else
+                       UI.message("Fetching Git info from system Git")
+                       GitResult.new(
+                         sha: Helper::Git.sha,
+                         base_sha: Helper::Git.base_sha,
+                         previous_sha: Helper::Git.previous_sha,
+                         branch: Helper::Git.branch
+                       )
+                     end
+        UI.message("Got git result #{git_result.inspect}")
+        git_result
+      end
+
+      def self.copy_config(config_path, tmp_dir)
+        return if config_path.nil?
+
+        expanded_path = File.expand_path(config_path)
+        unless File.exist?(expanded_path)
+          UI.error("No config file found at path '#{expanded_path}'.\nUploading without config file")
+          return
+        end
+
+        emerge_config_path = "#{tmp_dir}/emerge_config.yaml"
+        FileUtils.cp(expanded_path, emerge_config_path)
+      end
+
+      private_class_method
+
+      def self.clean_params(params)
+        params.reject { |_, v| v.nil? }
+      end
+
+      def self.print_summary(params)
+        FastlaneCore::PrintTable.print_values(
+          config: params,
+          hide_keys: [],
+          title: "Summary for Emerge Upload #{Fastlane::Emerge::VERSION}"
+        )
+      end
+
+      def self.create_upload(api_token, params)
+        response = Faraday.post(API_URL, params.to_json, headers(api_token, params, 'application/json'))
+        parse_response(response)
+      end
+
+      def self.headers(api_token, params, content_type)
+        {
+          'Content-Type' => content_type,
+          'X-API-Token' => api_token,
+          'User-Agent' => "fastlane-plugin-nico/#{Fastlane::Emerge::VERSION}"
+        }
+      end
+
+      def self.parse_response(response)
+        case response.status
+        when 200
+          JSON.parse(response.body)
+        when 400
+          error_message = JSON.parse(response.body)['errorMessage']
+          raise "Invalid parameters: #{error_message}"
+        when 401, 403
+          raise 'Invalid API token'
+        else
+          raise "Creating upload failed with status #{response.status}"
+        end
+      end
+
+      def self.handle_upload_response(api_token, response, file_path)
+        upload_url = response.fetch('uploadURL')
+        upload_id = response.fetch('upload_id')
+
+        warning = response.dig('warning')
+        if warning
+          UI.important(warning)
+        end
+
+        UI.message('Starting zip file upload')
+        upload_file(api_token, upload_url, file_path)
+        upload_id
+      end
+
+      def self.upload_file(api_token, upload_url, file_path)
+        response = Faraday.put(upload_url) do |req|
+          req.headers = headers(api_token, nil, 'application/zip')
+          req.headers['Content-Length'] = File.size(file_path).to_s
+          req.body = Faraday::UploadIO.new(file_path, 'application/zip')
+        end
+
+        raise "Uploading zip file failed #{response.status}" unless response.status == 200
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/emerge/helper/git.rb

@@ -0,0 +1,106 @@
+require 'fastlane_core/print_table'
+require 'open3'
+
+module Fastlane
+  module Helper
+    module Git
+      def self.branch
+        shell_command = "git rev-parse --abbrev-ref HEAD"
+        UI.command(shell_command)
+        stdout, _, status = Open3.capture3(shell_command)
+        unless status.success?
+          UI.error("Failed to get the current branch name")
+          return nil
+        end
+
+        branch_name = stdout.strip
+        if branch_name == "HEAD"
+          # We're in a detached HEAD state
+          # Find all branches that contains the current HEAD commit
+          #
+          # Example output:
+          # * (HEAD detached at dec13a5)
+          # telkins/detached-test
+          # remotes/origin/telkins/detached-test
+          #
+          # So far I've seen this output be fairly stable
+          # If the input is invalid for whatever reason, sed/awk will return an empty string
+          shell_command = "git branch -a --contains HEAD | sed -n 2p | awk '{ printf $1 }'"
+          UI.command(shell_command)
+          head_stdout, _, head_status = Open3.capture3(shell_command)
+
+          unless head_status.success?
+            UI.error("Failed to get the current branch name for detached HEAD")
+            return nil
+          end
+
+          branch_name = head_stdout.strip
+        end
+
+        branch_name == "HEAD" ? nil : branch_name
+      end
+
+      def self.sha
+        shell_command = "git rev-parse HEAD"
+        UI.command(shell_command)
+        stdout, _, status = Open3.capture3(shell_command)
+        stdout.strip if status.success?
+      end
+
+      def self.base_sha
+        current_branch = branch
+        remote_head = remote_head_branch
+        return nil if current_branch.nil? || remote_head.nil?
+
+        shell_command = "git merge-base #{remote_head} #{current_branch}"
+        UI.command(shell_command)
+        stdout, _, status = Open3.capture3(shell_command)
+        return nil if stdout.strip.empty? || !status.success?
+        current_sha = sha
+        stdout.strip == current_sha ? nil : stdout.strip
+      end
+
+      def self.previous_sha
+        shell_command = "git rev-parse HEAD^"
+        UI.command(shell_command)
+        stdout, _, status = Open3.capture3(shell_command)
+        stdout.strip if status.success?
+      end
+
+      def self.primary_remote
+        remote = remote()
+        return nil if remote.nil?
+        remote.include?("origin") ? "origin" : remote.first
+      end
+
+      def self.remote_head_branch(remote = primary_remote)
+        return nil if remote.nil?
+        shell_command = "git remote show #{remote}"
+        UI.command(shell_command)
+        stdout, _, status = Open3.capture3(shell_command)
+        return nil if stdout.nil? || !status.success?
+        stdout
+          .split("\n")
+          .map(&:strip)
+          .find { |line| line.start_with?("HEAD branch: ") }
+          &.split(' ')
+          &.last
+      end
+
+      def self.remote_url(remote = primary_remote)
+        return nil if remote.nil?
+        shell_command = "git config --get remote.#{remote}.url"
+        UI.command(shell_command)
+        stdout, _, status = Open3.capture3(shell_command)
+        stdout if status.success?
+      end
+
+      def self.remote
+        shell_command = "git remote"
+        UI.command(shell_command)
+        stdout, _, status = Open3.capture3(shell_command)
+        stdout.split("\n") if status.success?
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/emerge/helper/github.rb

@@ -0,0 +1,88 @@
+require 'json'
+require 'fastlane_core/print_table'
+require_relative 'git'
+
+module Fastlane
+  module Helper
+    module Github
+      GITHUB_EVENT_PR = "pull_request".freeze
+      GITHUB_EVENT_PUSH = "push".freeze
+
+      def self.event_name
+        ENV['GITHUB_EVENT_NAME']
+      end
+
+      def self.is_supported_github_event?
+        UI.message("GitHub event name: #{event_name}")
+        is_pull_request? || is_push?
+      end
+
+      def self.is_pull_request?
+        event_name == GITHUB_EVENT_PR
+      end
+
+      def self.is_push?
+        event_name == GITHUB_EVENT_PUSH
+      end
+
+      def self.sha
+        if is_push?
+          ENV['GITHUB_SHA']
+        elsif is_pull_request?
+          github_event_data.dig(:pull_request, :head, :sha)
+        end
+      end
+
+      def self.base_sha
+        if is_pull_request?
+          github_event_data.dig(:pull_request, :base, :sha)
+        end
+      end
+
+      def self.previous_sha
+        if is_push?
+          github_event_data.dig(:before)
+        else
+          shell_command = "git rev-parse HEAD^"
+          UI.command(shell_command)
+          stdout, _, status = Open3.capture3(shell_command)
+          stdout.strip if status.success?
+        end
+      end
+
+      def self.pr_number
+        is_pull_request? ? github_event_data.dig(:number) : nil
+      end
+
+      def self.branch
+        is_pull_request? ? github_event_data.dig(:pull_request, :head, :ref) : Git.branch
+      end
+
+      def self.repo_owner
+        github_event_data.dig(:repository, :owner, :login)
+      end
+
+      def self.repo_name
+        github_event_data.dig(:repository, :full_name)
+      end
+
+      private_class_method
+
+      def self.github_event_data
+        github_event_path = ENV['GITHUB_EVENT_PATH']
+        UI.error!("GITHUB_EVENT_PATH is not set") if github_event_path.nil?
+
+        unless File.exist?(github_event_path)
+          UI.error!("File #{github_event_path} doesn't exist")
+        end
+
+        file_content = File.read(github_event_path)
+        file_json = JSON.parse(file_content, symbolize_names: true)
+        if ENV['DEBUG']
+          UI.message("Parsed GitHub event data: #{file_json.inspect}")
+        end
+        file_json
+      end
+    end
+  end
+end

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

@@ -0,0 +1,5 @@
+module Fastlane
+  module Emerge
+    VERSION = "0.10.6"
+  end
+end

data/lib/fastlane/plugin/emerge.rb

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

metadata

@@ -0,0 +1,193 @@
+--- !ruby/object:Gem::Specification
+name: fastlane-plugin-nico
+version: !ruby/object:Gem::Version
+  version: 0.10.6
+platform: ruby
+authors:
+- Nico Testing
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-10-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !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: 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: 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: 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: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.49.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.49.1
+- !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'
+- !ruby/object:Gem::Dependency
+  name: fastlane
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.170.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.170.0
+description:
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/fastlane/plugin/emerge.rb
+- lib/fastlane/plugin/emerge/actions/emerge_action.rb
+- lib/fastlane/plugin/emerge/actions/emerge_comment_action.rb
+- lib/fastlane/plugin/emerge/actions/emerge_order_file_action.rb
+- lib/fastlane/plugin/emerge/actions/emerge_snapshot_action.rb
+- lib/fastlane/plugin/emerge/helper/emerge_helper.rb
+- lib/fastlane/plugin/emerge/helper/git.rb
+- lib/fastlane/plugin/emerge/helper/github.rb
+- lib/fastlane/plugin/emerge/version.rb
+homepage: https://github.com/EmergeTools/fastlane-plugin-emerge
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.21
+signing_key:
+specification_version: 4
+summary: Fastlane plugin for Emerge
+test_files: []