fastlane-plugin-emerge 0.7.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d4d089c7870b5c71f07b01d99df92996471d9050ab6fd4b0f6c3290648dcd404
-  data.tar.gz: a98f1c7796d0e21d0a2d7dcbadc20e11d3e2de626e1441da4947610e8433d468
+  metadata.gz: 0d2c3b1e6fa8f6246418040883cdbdf868dd54058e363f1c6de46a4f63646543
+  data.tar.gz: 0f601eeb52b1041210eb5620ab44bf18c233be7d3b873c320cf2aae0d4f4fc78
 SHA512:
-  metadata.gz: 7afe4c7adc02c46fa4193dbed344afc716877d26ca00849f6dce44bdd73e7da8458221aa875e9b9290aeec36c2e08fa2036e71d08581af4de74cb848779fdffe
-  data.tar.gz: 3fb17574090d31c7088b5afb3e0f9161e627ba777de779887b7d34ee45ea6094d3439bde09851087035d3c2face7be1caf173fb5228e5b81496f412b80d27aa0
+  metadata.gz: ea622f13cae0b3f362687e1cadb631ca17f35c5330f23d1475c9185c4b8a166a6fbc992d5e19dd79846f7fe0a6823ea9b8aed00dbcf60a1ff7070236eea18ba5
+  data.tar.gz: 0c448cfd0fda4d20031e25101f41c7835c22a507c26e39337a83ad7868259d6c348b7a3e1bfacf0212ec6d60ebc323c13bbdfe9e5b4f9feebb9f10428b2760db

data/README.md

@@ -12,24 +12,60 @@ fastlane add_plugin emerge
 
 ## About Emerge
 
-Fastlane plugin for 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.
 
-## Run tests for this plugin
+## Usage
 
-To run both the tests, and code style validation, run
+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.
 
-```
-rake
-```
+```ruby
+# Your EMERGE_API_TOKEN is available on your Emerge profile page: https://www.emergetools.com/profile
+ENV['EMERGE_API_TOKEN'] = 'COPIED_FROM_EMERGETOOLS_PROFILE'
 
-To automatically fix many of the styling issues, use
+platform {:ios} do
+  lane :app_size do
+    emerge()
+  end
+end
 ```
-rubocop -a
+
+For a full list of available parameters run `fastlane action emerge`.
+
+## 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`, and `repo_name` for the best experience.
+
+For example:
+
+- `sha`: `pr-branch-commit-1`
+- `base_sha`: `main-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 submit it to this repository.
+For any other issues and feedback about this plugin, please open a [GitHub issue](https://github.com/EmergeTools/fastlane-plugin-emerge/issues).
 
 ## Troubleshooting
 

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

@@ -1,6 +1,8 @@
 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'
@@ -16,11 +18,12 @@ module Fastlane
         if file_path.nil?
           file_path = Dir.glob("#{lane_context[SharedValues::SCAN_DERIVED_DATA_PATH]}/Build/Products/Debug-iphonesimulator/*.app").first
         end
-        pr_number = params[:pr_number]
-        branch = params[:branch]
-        sha = params[:sha] || params[:build_id]
-        base_sha = params[:base_sha] || params[:base_build_id]
-        repo_name = params[:repo_name]
+        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
+        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]
@@ -47,7 +50,7 @@ module Fastlane
                 FileUtils.cp(l, linkmap_folder)
               end
             end
-            copy_config(config_path, "#{d}/archive.xcarchive")
+            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)
@@ -70,7 +73,7 @@ module Fastlane
               FileUtils.cp(l, linkmap_folder)
             end
           end
-          copy_config(config_path, file_path)
+          Helper::EmergeHelper.copy_config(config_path, file_path)
           Actions::ZipAction.run(
             path: file_path,
             output_path: zip_path,
@@ -85,62 +88,18 @@ module Fastlane
           return
         end
 
-        filename = File.basename(file_path)
-        url = 'https://api.emergetools.com/upload'
         params = {
-          filename: filename
+          prNumber: pr_number,
+          branch: branch,
+          sha: sha,
+          baseSha: base_sha,
+          repoName: repo_name,
+          gitlabProjectId: gitlab_project_id,
+          orderFileVersion: order_file_version,
+          tag: tag || "default"
         }
-        if pr_number
-          params[:prNumber] = pr_number
-        end
-        if branch
-          params[:branch] = branch
-        end
-        if sha
-          params[:sha] = sha
-        end
-        if base_sha
-          params[:baseSha] = base_sha
-        end
-        if repo_name
-          params[:repoName] = repo_name
-        end
-        if gitlab_project_id
-          params[:gitlabProjectId] = gitlab_project_id
-        end
-        if order_file_version
-          params[:orderFileVersion] = order_file_version
-        end
-        params[:tag] = tag || "default"
-        FastlaneCore::PrintTable.print_values(
-          config: params,
-          hide_keys: [],
-          title: "Summary for Emerge #{Fastlane::Emerge::VERSION}"
-        )
-        resp = Faraday.post(
-          url,
-          params.to_json,
-          'Content-Type' => 'application/json', 'X-API-Token' => api_token, 'User-Agent' => "fastlane-plugin-emerge/#{Fastlane::Emerge::VERSION}"
-        )
-        case resp.status
-        when 200
-          json = JSON.parse(resp.body)
-          upload_id = json["upload_id"]
-          upload_url = json["uploadURL"]
-          warning = json["warning"]
-          if warning
-            UI.important(warning)
-          end
-          return Helper::EmergeHelper.perform_upload(upload_url, upload_id, file_path)
-        when 403
-          UI.error("Invalid API token")
-        when 400
-          UI.error("Invalid parameters")
-          json = JSON.parse(resp.body)
-          UI.error("Error: #{json['errorMessage']}")
-        else
-          UI.error("Upload failed")
-        end
+        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}")
       end
 
       def self.copy_dsyms(from, to)
@@ -150,19 +109,6 @@ module Fastlane
         end
       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
-
       def self.description
         "Fastlane plugin for Emerge"
       end
@@ -172,11 +118,10 @@ module Fastlane
       end
 
       def self.return_value
-        # If your method provides a return value, you can describe here what it does
+        "If successful, returns the upload id of the generated build"
       end
 
       def self.details
-        # Optional:
         ""
       end
 
@@ -246,10 +191,6 @@ module Fastlane
       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, :mac, :android].include?(platform)
         platform == :ios
       end
     end

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

@@ -0,0 +1,155 @@
+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
+        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,
+            output_path: zip_file_path,
+            exclude: [],
+            include: []
+          )
+
+          params = {
+            appIdSuffix: 'snapshots',
+            prNumber: pr_number,
+            branch: branch,
+            sha: sha,
+            baseSha: base_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: :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

@@ -4,23 +4,130 @@ require 'faraday'
 module Fastlane
   UI = FastlaneCore::UI unless Fastlane.const_defined?("UI")
 
+  class GitResult
+    attr_accessor :sha, :base_sha, :branch, :pr_number, :repo_name
+
+    def initialize(sha:, base_sha:, branch:, pr_number: nil, repo_name: nil)
+      @pr_number = pr_number
+      @sha = sha
+      @base_sha = base_sha
+      @branch = branch
+      @repo_name = repo_name
+    end
+  end
+
   module Helper
     class EmergeHelper
-      def self.perform_upload(upload_url, upload_id, file_path)
-        UI.message("Starting upload")
-        response = Faraday.put(upload_url) do |req|
-          req.headers['Content-Type'] = 'application/zip'
-          req.headers['Content-Length'] = "#{File.size(file_path)}"
-          req.body = Faraday::UploadIO.new(file_path, 'application/zip')
+      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")
+                       GitResult.new(
+                         sha: Helper::Github.sha,
+                         base_sha: Helper::Github.base_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,
+                         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-emerge/#{Fastlane::Emerge::VERSION}"
+        }
+      end
+
+      def self.parse_response(response)
         case response.status
         when 200
-          UI.success("Your app is processing, you can find the results at https://emergetools.com/build/#{upload_id}")
-          return upload_id
+          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
-          UI.error("Upload failed")
+          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
-        return nil
+
+        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

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

@@ -0,0 +1,66 @@
+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)
+        stdout.strip if status.success?
+      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
+        shell_command = "git merge-base #{remote_head_branch} #{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.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,77 @@
+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.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

@@ -1,5 +1,5 @@
 module Fastlane
   module Emerge
-    VERSION = "0.7.0"
+    VERSION = "0.9.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fastlane-plugin-emerge
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Emerge Tools, Inc
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-03-06 00:00:00.000000000 Z
+date: 2024-03-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -162,7 +162,10 @@ files:
 - 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:
@@ -183,7 +186,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
+rubygems_version: 3.3.25
 signing_key:
 specification_version: 4
 summary: Fastlane plugin for Emerge