fastlane_hotfix 2.165.0

data/fastlane/lib/fastlane/actions/danger.rb

@@ -0,0 +1,131 @@
+module Fastlane
+  module Actions
+    class DangerAction < Action
+      def self.run(params)
+        Actions.verify_gem!('danger')
+        cmd = []
+
+        cmd << 'bundle exec' if params[:use_bundle_exec] && shell_out_should_use_bundle_exec?
+        cmd << 'danger'
+        cmd << '--verbose' if params[:verbose]
+
+        danger_id = params[:danger_id]
+        dangerfile = params[:dangerfile]
+        base = params[:base]
+        head = params[:head]
+        pr = params[:pr]
+        cmd << "--danger_id=#{danger_id}" if danger_id
+        cmd << "--dangerfile=#{dangerfile}" if dangerfile
+        cmd << "--fail-on-errors=true" if params[:fail_on_errors]
+        cmd << "--new-comment" if params[:new_comment]
+        cmd << "--remove-previous-comments" if params[:remove_previous_comments]
+        cmd << "--base=#{base}" if base
+        cmd << "--head=#{head}" if head
+        cmd << "pr #{pr}" if pr
+
+        ENV['DANGER_GITHUB_API_TOKEN'] = params[:github_api_token] if params[:github_api_token]
+
+        Actions.sh(cmd.join(' '))
+      end
+
+      def self.description
+        "Runs `danger` for the project"
+      end
+
+      def self.details
+        [
+          "Formalize your Pull Request etiquette.",
+          "More information: [https://github.com/danger/danger](https://github.com/danger/danger)."
+        ].join("\n")
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :use_bundle_exec,
+                                       env_name: "FL_DANGER_USE_BUNDLE_EXEC",
+                                       description: "Use bundle exec when there is a Gemfile presented",
+                                       is_string: false,
+                                       default_value: true),
+          FastlaneCore::ConfigItem.new(key: :verbose,
+                                       env_name: "FL_DANGER_VERBOSE",
+                                       description: "Show more debugging information",
+                                       is_string: false,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :danger_id,
+                                       env_name: "FL_DANGER_ID",
+                                       description: "The identifier of this Danger instance",
+                                       is_string: true,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :dangerfile,
+                                       env_name: "FL_DANGER_DANGERFILE",
+                                       description: "The location of your Dangerfile",
+                                       is_string: true,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :github_api_token,
+                                       env_name: "FL_DANGER_GITHUB_API_TOKEN",
+                                       description: "GitHub API token for danger",
+                                       sensitive: true,
+                                       is_string: true,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :fail_on_errors,
+                                       env_name: "FL_DANGER_FAIL_ON_ERRORS",
+                                       description: "Should always fail the build process, defaults to false",
+                                       is_string: false,
+                                       optional: true,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :new_comment,
+                                       env_name: "FL_DANGER_NEW_COMMENT",
+                                       description: "Makes Danger post a new comment instead of editing its previous one",
+                                       is_string: false,
+                                       optional: true,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :remove_previous_comments,
+                                       env_name: "FL_DANGER_REMOVE_PREVIOUS_COMMENT",
+                                       description: "Makes Danger remove all previous comment and create a new one in the end of the list",
+                                       is_string: false,
+                                       optional: true,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :base,
+                                       env_name: "FL_DANGER_BASE",
+                                       description: "A branch/tag/commit to use as the base of the diff. [master|dev|stable]",
+                                       is_string: true,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :head,
+                                       env_name: "FL_DANGER_HEAD",
+                                       description: "A branch/tag/commit to use as the head. [master|dev|stable]",
+                                       is_string: true,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :pr,
+                                       env_name: "FL_DANGER_PR",
+                                       description: "Run danger on a specific pull request. e.g. \"https://github.com/danger/danger/pull/518\"",
+                                       is_string: true,
+                                       optional: true)
+        ]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.example_code
+        [
+          'danger',
+          'danger(
+            danger_id: "unit-tests",
+            dangerfile: "tests/MyOtherDangerFile",
+            github_api_token: ENV["GITHUB_API_TOKEN"],
+            verbose: true
+          )'
+        ]
+      end
+
+      def self.category
+        :misc
+      end
+
+      def self.authors
+        ["KrauseFx"]
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/debug.rb

@@ -0,0 +1,32 @@
+module Fastlane
+  module Actions
+    class DebugAction < Action
+      def self.run(params)
+        puts("Lane Context".green)
+        puts(Actions.lane_context)
+      end
+
+      def self.description
+        "Print out an overview of the lane context values"
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.example_code
+        [
+          'debug'
+        ]
+      end
+
+      def self.category
+        :misc
+      end
+
+      def self.author
+        "KrauseFx"
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/default_platform.rb

@@ -0,0 +1,47 @@
+module Fastlane
+  module Actions
+    module SharedValues
+      DEFAULT_PLATFORM = :DEFAULT_PLATFORM
+    end
+
+    class DefaultPlatformAction < Action
+      def self.run(params)
+        UI.user_error!("You forgot to pass the default platform") if params.first.nil?
+
+        platform = params.first.to_sym
+
+        SupportedPlatforms.verify!(platform)
+
+        Actions.lane_context[SharedValues::DEFAULT_PLATFORM] = platform
+      end
+
+      def self.description
+        "Defines a default platform to not have to specify the platform"
+      end
+
+      def self.output
+        [
+          ['DEFAULT_PLATFORM', 'The default platform']
+        ]
+      end
+
+      def self.example_code
+        [
+          'default_platform(:android)'
+        ]
+      end
+
+      def self.category
+        :misc
+      end
+
+      def self.author
+        "KrauseFx"
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/delete_keychain.rb

@@ -0,0 +1,68 @@
+require 'shellwords'
+
+module Fastlane
+  module Actions
+    class DeleteKeychainAction < Action
+      def self.run(params)
+        original = Actions.lane_context[Actions::SharedValues::ORIGINAL_DEFAULT_KEYCHAIN]
+
+        if params[:keychain_path]
+          if File.exist?(params[:keychain_path])
+            keychain_path = params[:keychain_path]
+          else
+            UI.user_error!("Unable to find the specified keychain.")
+          end
+        elsif params[:name]
+          keychain_path = FastlaneCore::Helper.keychain_path(params[:name])
+        else
+          UI.user_error!("You either have to set :name or :keychain_path")
+        end
+
+        Fastlane::Actions.sh("security default-keychain -s #{original}", log: false) unless original.nil?
+        Fastlane::Actions.sh("security delete-keychain #{keychain_path.shellescape}", log: false)
+      end
+
+      def self.details
+        "Keychains can be deleted after being created with `create_keychain`"
+      end
+
+      def self.description
+        "Delete keychains and remove them from the search list"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :name,
+                                       env_name: "KEYCHAIN_NAME",
+                                       description: "Keychain name",
+                                       conflicting_options: [:keychain_path],
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :keychain_path,
+                                       env_name: "KEYCHAIN_PATH",
+                                       description: "Keychain path",
+                                       conflicting_options: [:name],
+                                       optional: true)
+        ]
+      end
+
+      def self.example_code
+        [
+          'delete_keychain(name: "KeychainName")',
+          'delete_keychain(keychain_path: "/keychains/project.keychain")'
+        ]
+      end
+
+      def self.category
+        :misc
+      end
+
+      def self.authors
+        ["gin0606", "koenpunt"]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/deliver.rb

@@ -0,0 +1,14 @@
+module Fastlane
+  module Actions
+    require 'fastlane/actions/upload_to_app_store'
+    class DeliverAction < UploadToAppStoreAction
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Alias for the `upload_to_app_store` action"
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/deploygate.rb

@@ -0,0 +1,210 @@
+module Fastlane
+  module Actions
+    module SharedValues
+      DEPLOYGATE_URL = :DEPLOYGATE_URL
+      DEPLOYGATE_REVISION = :DEPLOYGATE_REVISION # auto increment revision number
+      DEPLOYGATE_APP_INFO = :DEPLOYGATE_APP_INFO # contains app revision, bundle identifier, etc.
+    end
+
+    class DeploygateAction < Action
+      DEPLOYGATE_URL_BASE = 'https://deploygate.com'
+
+      def self.is_supported?(platform)
+        [:ios, :android].include?(platform)
+      end
+
+      def self.upload_build(api_token, user_name, binary, options)
+        require 'faraday'
+        require 'faraday_middleware'
+
+        connection = Faraday.new(url: DEPLOYGATE_URL_BASE, request: { timeout: 120 }) do |builder|
+          builder.request(:multipart)
+          builder.request(:json)
+          builder.response(:json, content_type: /\bjson$/)
+          builder.use(FaradayMiddleware::FollowRedirects)
+          builder.adapter(:net_http)
+        end
+
+        options.update({
+          token: api_token,
+          file: Faraday::UploadIO.new(binary, 'application/octet-stream'),
+          message: options[:message] || ''
+        })
+        options[:disable_notify] = 'yes' if options[:disable_notify]
+
+        connection.post("/api/users/#{user_name}/apps", options)
+      rescue Faraday::TimeoutError
+        UI.crash!("Timed out while uploading build. Check https://deploygate.com/ to see if the upload was completed.")
+      end
+
+      def self.run(options)
+        # Available options: https://deploygate.com/docs/api
+        UI.success('Starting with app upload to DeployGate... this could take some time ⏳')
+
+        api_token = options[:api_token]
+        user_name = options[:user]
+        binary = options[:ipa] || options[:apk]
+        upload_options = options.values.select do |key, _|
+          [:message, :distribution_key, :release_note, :disable_notify, :distribution_name].include?(key)
+        end
+
+        UI.user_error!('missing `ipa` and `apk`. deploygate action needs least one.') unless binary
+
+        return binary if Helper.test?
+
+        response = self.upload_build(api_token, user_name, binary, upload_options)
+        if parse_response(response)
+          UI.message("DeployGate URL: #{Actions.lane_context[SharedValues::DEPLOYGATE_URL]}")
+          UI.success("Build successfully uploaded to DeployGate as revision \##{Actions.lane_context[SharedValues::DEPLOYGATE_REVISION]}!")
+        else
+          UI.user_error!("Error when trying to upload app to DeployGate")
+        end
+      end
+
+      def self.parse_response(response)
+        if response.body && response.body.key?('error')
+
+          if response.body['error']
+            UI.error("Error uploading to DeployGate: #{response.body['message']}")
+            help_message(response)
+            return
+          else
+            res = response.body['results']
+            url = DEPLOYGATE_URL_BASE + res['path']
+
+            Actions.lane_context[SharedValues::DEPLOYGATE_URL] = url
+            Actions.lane_context[SharedValues::DEPLOYGATE_REVISION] = res['revision']
+            Actions.lane_context[SharedValues::DEPLOYGATE_APP_INFO] = res
+          end
+        else
+          UI.error("Error uploading to DeployGate: #{response.body}")
+          return
+        end
+        true
+      end
+      private_class_method :parse_response
+
+      def self.help_message(response)
+        message =
+          case response.body['message']
+          when 'you are not authenticated'
+            'Invalid API Token specified.'
+          when 'application create error: permit'
+            'Access denied: May be trying to upload to wrong user or updating app you join as a tester?'
+          when 'application create error: limit'
+            'Plan limit: You have reached to the limit of current plan or your plan was expired.'
+          end
+        UI.error(message) if message
+      end
+      private_class_method :help_message
+
+      def self.description
+        "Upload a new build to [DeployGate](https://deploygate.com/)"
+      end
+
+      def self.details
+        [
+          "You can retrieve your username and API token on [your settings page](https://deploygate.com/settings).",
+          "More information about the available options can be found in the [DeployGate Push API document](https://deploygate.com/docs/api)."
+        ].join("\n")
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :api_token,
+                                       env_name: "DEPLOYGATE_API_TOKEN",
+                                       description: "Deploygate API Token",
+                                       sensitive: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("No API Token for DeployGate given, pass using `api_token: 'token'`") unless value.to_s.length > 0
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :user,
+                                       env_name: "DEPLOYGATE_USER",
+                                       description: "Target username or organization name",
+                                       verify_block: proc do |value|
+                                         UI.user_error!("No User for DeployGate given, pass using `user: 'user'`") unless value.to_s.length > 0
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :ipa,
+                                       env_name: "DEPLOYGATE_IPA_PATH",
+                                       description: "Path to your IPA file. Optional if you use the _gym_ or _xcodebuild_ action",
+                                       default_value: Actions.lane_context[SharedValues::IPA_OUTPUT_PATH],
+                                       default_value_dynamic: true,
+                                       optional: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Couldn't find ipa file at path '#{value}'") unless File.exist?(value)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :apk,
+                                       env_name: "DEPLOYGATE_APK_PATH",
+                                       description: "Path to your APK file",
+                                       default_value: Actions.lane_context[SharedValues::GRADLE_APK_OUTPUT_PATH],
+                                       default_value_dynamic: true,
+                                       optional: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Couldn't find apk file at path '#{value}'") unless File.exist?(value)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :message,
+                                       env_name: "DEPLOYGATE_MESSAGE",
+                                       description: "Release Notes",
+                                       default_value: "No changelog provided"),
+          FastlaneCore::ConfigItem.new(key: :distribution_key,
+                                       optional: true,
+                                       env_name: "DEPLOYGATE_DISTRIBUTION_KEY",
+                                       sensitive: true,
+                                       description: "Target Distribution Key"),
+          FastlaneCore::ConfigItem.new(key: :release_note,
+                                       optional: true,
+                                       env_name: "DEPLOYGATE_RELEASE_NOTE",
+                                       description: "Release note for distribution page"),
+          FastlaneCore::ConfigItem.new(key: :disable_notify,
+                                       optional: true,
+                                       is_string: false,
+                                       default_value: false,
+                                       env_name: "DEPLOYGATE_DISABLE_NOTIFY",
+                                       description: "Disables Push notification emails"),
+          FastlaneCore::ConfigItem.new(key: :distribution_name,
+                                       optional: true,
+                                       is_string: true,
+                                       env_name: "DEPLOYGATE_DISTRIBUTION_NAME",
+                                       description: "Target Distribution Name")
+        ]
+      end
+
+      def self.output
+        [
+          ['DEPLOYGATE_URL', 'URL of the newly uploaded build'],
+          ['DEPLOYGATE_REVISION', 'auto incremented revision number'],
+          ['DEPLOYGATE_APP_INFO', 'Contains app revision, bundle identifier, etc.']
+        ]
+      end
+
+      def self.example_code
+        [
+          'deploygate(
+            api_token: "...",
+            user: "target username or organization name",
+            ipa: "./ipa_file.ipa",
+            message: "Build #{lane_context[SharedValues::BUILD_NUMBER]}",
+            distribution_key: "(Optional) Target Distribution Key",
+            distribution_name: "(Optional) Target Distribution Name"
+          )',
+          'deploygate(
+            api_token: "...",
+            user: "target username or organization name",
+            apk: "./apk_file.apk",
+            message: "Build #{lane_context[SharedValues::BUILD_NUMBER]}",
+            distribution_key: "(Optional) Target Distribution Key",
+            distribution_name: "(Optional) Target Distribution Name"
+          )'
+        ]
+      end
+
+      def self.category
+        :beta
+      end
+
+      def self.authors
+        ["tnj", "tomorrowkey"]
+      end
+    end
+  end
+end