fastlane-plugin-emerge 0.8.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e170856bceb03b9747e72d074ce9a96d124dfe6519e5bc9f47becffb39b1acea
-  data.tar.gz: 71d34166a5fa640ac3af5ec2763a8b373052e3da358c0dc68dce5ed4bb46bd32
+  metadata.gz: 6e0ee7bd40a5841bf9207de85fd19c9f49244b893680e7b60b19c811df754fcd
+  data.tar.gz: 4a6d7441344186fb1d8623574f732c70aeb25fd57d74ddbe388bf9d4d58e4fb4
 SHA512:
-  metadata.gz: '07929884d01b7ce42b2863dc9973768b2bb033da495e6d63c6dd09a66e63d6613e55c41a0845eff819afcd8689897d5c32c6099028e0059e2f12df9aed1470af'
-  data.tar.gz: a971a076cb1724adec271841883b49a0ecfac4fe245884076b64cc655f1fabf930af60830f76cf7dbd46005d6e28c5a16d01d716a6ae63133df8a7cf6a013f56
+  metadata.gz: 69c76da179be424cd8bd9faab5a0c90762de70bc8e2409e3084fb264b7c1d7a81c95671ff80c5f700ea6e9376f19b000b1e5f4f355cf2d3de74c759eb77290d6
+  data.tar.gz: 5a2c4c637ac3fc26abb5bb201178e56bd3bf0271f8eac43967074c07fe5f4bf93247c33c6947e7fb3f09dbc7806f2a8270d4a8c2a20f848edb9a959ad91f5ff0

data/README.md

@@ -12,24 +12,76 @@ 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. 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 :app_size do
+    # Make a signed release build via gym() and other tools
+    # and then call our `emerge()` action to upload the artifact to our API
+    emerge()
+  end
+end
 ```
-rake
-```
 
-To automatically fix many of the styling issues, use
+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
 ```
-rubocop -a
+
+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`, 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

@@ -50,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)
@@ -73,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,
@@ -88,62 +88,19 @@ 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,
+          appIdSuffix: params[:app_id_suffix],
+          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)
@@ -153,19 +110,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
@@ -243,6 +187,10 @@ module Fastlane
           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)
         ]
       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

@@ -18,21 +18,16 @@ module Fastlane
 
   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).to_s
-          req.body = Faraday::UploadIO.new(file_path, 'application/zip')
-        end
-        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
-        else
-          UI.error("Upload failed")
-        end
-        return nil
+      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
@@ -56,6 +51,84 @@ module Fastlane
         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
+          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/version.rb

@@ -1,5 +1,5 @@
 module Fastlane
   module Emerge
-    VERSION = "0.8.0"
+    VERSION = "0.10.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fastlane-plugin-emerge
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Emerge Tools, Inc
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-03-08 00:00:00.000000000 Z
+date: 2024-03-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -162,6 +162,7 @@ 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
@@ -185,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