fastlane-plugin-emerge 0.8.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e170856bceb03b9747e72d074ce9a96d124dfe6519e5bc9f47becffb39b1acea
-  data.tar.gz: 71d34166a5fa640ac3af5ec2763a8b373052e3da358c0dc68dce5ed4bb46bd32
+  metadata.gz: 0d2c3b1e6fa8f6246418040883cdbdf868dd54058e363f1c6de46a4f63646543
+  data.tar.gz: 0f601eeb52b1041210eb5620ab44bf18c233be7d3b873c320cf2aae0d4f4fc78
 SHA512:
-  metadata.gz: '07929884d01b7ce42b2863dc9973768b2bb033da495e6d63c6dd09a66e63d6613e55c41a0845eff819afcd8689897d5c32c6099028e0059e2f12df9aed1470af'
-  data.tar.gz: a971a076cb1724adec271841883b49a0ecfac4fe245884076b64cc655f1fabf930af60830f76cf7dbd46005d6e28c5a16d01d716a6ae63133df8a7cf6a013f56
+  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

@@ -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,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)
@@ -153,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

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.9.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.9.0
 platform: ruby
 authors:
 - Emerge Tools, Inc
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-03-08 00:00:00.000000000 Z
+date: 2024-03-20 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