fastlane_pricing_fix 2.212.1

data/fastlane/lib/fastlane/actions/spm.rb

@@ -0,0 +1,144 @@
+module Fastlane
+  module Actions
+    class SpmAction < Action
+      def self.run(params)
+        cmd = ["swift"]
+
+        cmd << (package_commands.include?(params[:command]) ? "package" : params[:command])
+        cmd << "--build-path #{params[:build_path]}" if params[:build_path]
+        cmd << "--package-path #{params[:package_path]}" if params[:package_path]
+        cmd << "--configuration #{params[:configuration]}" if params[:configuration]
+        cmd << "--disable-sandbox" if params[:disable_sandbox]
+        cmd << "--verbose" if params[:verbose]
+        cmd << params[:command] if package_commands.include?(params[:command])
+        cmd << "--enable-code-coverage" if params[:enable_code_coverage] && (params[:command] == 'generate-xcodeproj' || params[:command] == 'test')
+        if params[:xcconfig]
+          cmd << "--xcconfig-overrides #{params[:xcconfig]}"
+        end
+        if params[:xcpretty_output]
+          cmd += ["2>&1", "|", "xcpretty", "--#{params[:xcpretty_output]}"]
+          if params[:xcpretty_args]
+            cmd << (params[:xcpretty_args]).to_s
+          end
+          cmd = %w(set -o pipefail &&) + cmd
+        end
+
+        FastlaneCore::CommandExecutor.execute(command: cmd.join(" "),
+                                              print_all: true,
+                                              print_command: true)
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Runs Swift Package Manager on your project"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :command,
+                                       env_name: "FL_SPM_COMMAND",
+                                       description: "The swift command (one of: #{available_commands.join(', ')})",
+                                       default_value: "build",
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Please pass a valid command. Use one of the following: #{available_commands.join(', ')}") unless available_commands.include?(value)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :enable_code_coverage,
+                                       env_name: "FL_SPM_ENABLE_CODE_COVERAGE",
+                                       description: "Enables code coverage for the generated Xcode project when using the 'generate-xcodeproj' and the 'test' command",
+                                       type: Boolean,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :build_path,
+                                       env_name: "FL_SPM_BUILD_PATH",
+                                       description: "Specify build/cache directory [default: ./.build]",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :package_path,
+                                       env_name: "FL_SPM_PACKAGE_PATH",
+                                       description: "Change working directory before any other operation",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :xcconfig,
+                                       env_name: "FL_SPM_XCCONFIG",
+                                       description: "Use xcconfig file to override swift package generate-xcodeproj defaults",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :configuration,
+                                       short_option: "-c",
+                                       env_name: "FL_SPM_CONFIGURATION",
+                                       description: "Build with configuration (debug|release) [default: debug]",
+                                       optional: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Please pass a valid configuration: (debug|release)") unless valid_configurations.include?(value)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :disable_sandbox,
+                                       env_name: "FL_SPM_DISABLE_SANDBOX",
+                                       description: "Disable using the sandbox when executing subprocesses",
+                                       optional: true,
+                                       type: Boolean,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :xcpretty_output,
+                                       env_name: "FL_SPM_XCPRETTY_OUTPUT",
+                                       description: "Specifies the output type for xcpretty. eg. 'test', or 'simple'",
+                                       optional: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Please pass a valid xcpretty output type: (#{xcpretty_output_types.join('|')})") unless xcpretty_output_types.include?(value)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :xcpretty_args,
+                                       env_name: "FL_SPM_XCPRETTY_ARGS",
+                                       description: "Pass in xcpretty additional command line arguments (e.g. '--test --no-color' or '--tap --no-utf'), requires xcpretty_output to be specified also",
+                                       type: String,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :verbose,
+                                       short_option: "-v",
+                                       env_name: "FL_SPM_VERBOSE",
+                                       description: "Increase verbosity of informational output",
+                                       type: Boolean,
+                                       default_value: false)
+        ]
+      end
+
+      def self.authors
+        ["fjcaetano", "nxtstep"]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.example_code
+        [
+          'spm',
+          'spm(
+            command: "build",
+            build_path: "./build",
+            configuration: "release"
+          )',
+          'spm(
+            command: "generate-xcodeproj",
+            xcconfig: "Package.xcconfig"
+          )'
+        ]
+      end
+
+      def self.category
+        :building
+      end
+
+      def self.available_commands
+        %w(build test) + self.package_commands
+      end
+
+      def self.package_commands
+        %w(clean reset update resolve generate-xcodeproj init)
+      end
+
+      def self.valid_configurations
+        %w(debug release)
+      end
+
+      def self.xcpretty_output_types
+        %w(simple test knock tap)
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/ssh.rb

@@ -0,0 +1,157 @@
+module Fastlane
+  module Actions
+    module SharedValues
+      SSH_STDOUT_VALUE = :SSH_STDOUT_VALUE
+      SSH_STDERR_VALUE = :SSH_STDERR_VALUE
+    end
+
+    class SshAction < Action
+      def self.ssh_exec!(ssh, command, log = true)
+        stdout_data = ""
+        stderr_data = ""
+        exit_code = nil
+        exit_signal = nil
+        ssh.open_channel do |channel|
+          channel.exec(command) do |ch, success|
+            unless success
+              abort("FAILED: couldn't execute command (ssh.channel.exec)")
+            end
+            channel.on_data do |ch1, data|
+              stdout_data += data
+              UI.command_output(data) if log
+            end
+
+            channel.on_extended_data do |ch2, type, data|
+              # Only type 1 data is stderr (though no other types are defined by the standard)
+              # See http://net-ssh.github.io/net-ssh/Net/SSH/Connection/Channel.html#method-i-on_extended_data
+              stderr_data += data if type == 1
+            end
+
+            channel.on_request("exit-status") do |ch3, data|
+              exit_code = data.read_long
+            end
+
+            channel.on_request("exit-signal") do |ch4, data|
+              exit_signal = data.read_long
+            end
+          end
+        end
+
+        # Wait for all open channels to close
+        ssh.loop
+        { stdout: stdout_data, stderr: stderr_data, exit_code: exit_code, exit_signal: exit_signal }
+      end
+
+      def self.run(params)
+        Actions.verify_gem!('net-ssh')
+        require "net/ssh"
+
+        Actions.lane_context[SharedValues::SSH_STDOUT_VALUE] = ""
+        Actions.lane_context[SharedValues::SSH_STDERR_VALUE] = ""
+        stdout = ""
+        stderr = ""
+
+        Net::SSH.start(params[:host], params[:username], { port: params[:port].to_i, password: params[:password] }) do |ssh|
+          params[:commands].each do |cmd|
+            UI.command(cmd) if params[:log]
+            return_value = ssh_exec!(ssh, cmd, params[:log])
+            if return_value[:exit_code] != 0
+              UI.error("SSH Command failed '#{cmd}' Exit-Code: #{return_value[:exit_code]}")
+              UI.user_error!("SSH Command failed")
+            end
+
+            stderr << return_value[:stderr]
+            stdout << return_value[:stdout]
+          end
+        end
+        command_word = params[:commands].count == 1 ? "command" : "commands"
+        UI.success("Successfully executed #{params[:commands].count} #{command_word} on host #{params[:host]}")
+        Actions.lane_context[SharedValues::SSH_STDOUT_VALUE] = stdout
+        Actions.lane_context[SharedValues::SSH_STDERR_VALUE] = stderr
+        return { stdout: Actions.lane_context[SharedValues::SSH_STDOUT_VALUE], stderr: Actions.lane_context[SharedValues::SSH_STDERR_VALUE] }
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Allows remote command execution using ssh"
+      end
+
+      def self.details
+        "Lets you execute remote commands via ssh using username/password or ssh-agent. If one of the commands in command-array returns non 0, it fails."
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :username,
+                                       short_option: "-u",
+                                       env_name: "FL_SSH_USERNAME",
+                                       description: "Username"),
+          FastlaneCore::ConfigItem.new(key: :password,
+                                       short_option: "-p",
+                                       env_name: "FL_SSH_PASSWORD",
+                                       sensitive: true,
+                                       description: "Password",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :host,
+                                       short_option: "-H",
+                                       env_name: "FL_SSH_HOST",
+                                       description: "Hostname"),
+          FastlaneCore::ConfigItem.new(key: :port,
+                                       short_option: "-P",
+                                       env_name: "FL_SSH_PORT",
+                                       description: "Port",
+                                       optional: true,
+                                       default_value: "22"),
+          FastlaneCore::ConfigItem.new(key: :commands,
+                                       short_option: "-C",
+                                       env_name: "FL_SSH_COMMANDS",
+                                       description: "Commands",
+                                       optional: true,
+                                       type: Array),
+          FastlaneCore::ConfigItem.new(key: :log,
+                                       short_option: "-l",
+                                       env_name: "FL_SSH_LOG",
+                                       description: "Log commands and output",
+                                       optional: true,
+                                       default_value: true,
+                                       type: Boolean)
+        ]
+      end
+
+      def self.output
+        [
+          ['SSH_STDOUT_VALUE', 'Holds the standard output of all commands'],
+          ['SSH_STDERR_VALUE', 'Holds the standard error of all commands']
+        ]
+      end
+
+      def self.authors
+        ["hjanuschka"]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.example_code
+        [
+          'ssh(
+            host: "dev.januschka.com",
+            username: "root",
+            commands: [
+              "date",
+              "echo 1 > /tmp/file1"
+            ]
+          )'
+        ]
+      end
+
+      def self.category
+        :misc
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/supply.rb

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

data/fastlane/lib/fastlane/actions/swiftlint.rb

@@ -0,0 +1,242 @@
+module Fastlane
+  module Actions
+    class SwiftlintAction < Action
+      def self.run(params)
+        if `which swiftlint`.to_s.length == 0 && params[:executable].nil? && !Helper.test?
+          UI.user_error!("You have to install swiftlint using `brew install swiftlint` or specify the executable path with the `:executable` option.")
+        end
+
+        version = swiftlint_version(executable: params[:executable])
+        if params[:mode] == :autocorrect && version < Gem::Version.new('0.5.0') && !Helper.test?
+          UI.user_error!("Your version of swiftlint (#{version}) does not support autocorrect mode.\nUpdate swiftlint using `brew update && brew upgrade swiftlint`")
+        end
+
+        # See 'Breaking' section release notes here: https://github.com/realm/SwiftLint/releases/tag/0.43.0
+        if params[:mode] == :autocorrect && version >= Gem::Version.new('0.43.0')
+          UI.deprecated("Your version of swiftlint (#{version}) has deprecated autocorrect mode, please start using fix mode in input param")
+          UI.important("For now, switching swiftlint mode `from :autocorrect to :fix` for you 😇")
+          params[:mode] = :fix
+        elsif params[:mode] == :fix && version < Gem::Version.new('0.43.0')
+          UI.important("Your version of swiftlint (#{version}) does not support fix mode.\nUpdate swiftlint using `brew update && brew upgrade swiftlint`")
+          UI.important("For now, switching swiftlint mode `from :fix to :autocorrect` for you 😇")
+          params[:mode] = :autocorrect
+        end
+
+        mode_format = params[:mode] == :fix ? "--" : ""
+        command = (params[:executable] || "swiftlint").dup
+        command << " #{mode_format}#{params[:mode]}"
+        command << optional_flags(params)
+
+        if params[:files]
+          if version < Gem::Version.new('0.5.1')
+            UI.user_error!("Your version of swiftlint (#{version}) does not support list of files as input.\nUpdate swiftlint using `brew update && brew upgrade swiftlint`")
+          end
+
+          files = params[:files].map.with_index(0) { |f, i| "SCRIPT_INPUT_FILE_#{i}=#{f.shellescape}" }.join(" ")
+          command = command.prepend("SCRIPT_INPUT_FILE_COUNT=#{params[:files].count} #{files} ")
+          command << " --use-script-input-files"
+        end
+
+        command << " > #{params[:output_file].shellescape}" if params[:output_file]
+
+        begin
+          Actions.sh(command)
+        rescue
+          handle_swiftlint_error(params[:ignore_exit_status], $?.exitstatus)
+          raise if params[:raise_if_swiftlint_error]
+        end
+      end
+
+      def self.optional_flags(params)
+        command = ""
+        command << " --path #{params[:path].shellescape}" if params[:path]
+        command << supported_option_switch(params, :strict, "0.9.2", true)
+        command << " --config #{params[:config_file].shellescape}" if params[:config_file]
+        command << " --reporter #{params[:reporter]}" if params[:reporter]
+        command << supported_option_switch(params, :quiet, "0.9.0", true)
+        command << supported_option_switch(params, :format, "0.11.0", true) if params[:mode] == :autocorrect
+        command << supported_no_cache_option(params) if params[:no_cache]
+        command << " --compiler-log-path #{params[:compiler_log_path].shellescape}" if params[:compiler_log_path]
+        return command
+      end
+
+      # Get current SwiftLint version
+      def self.swiftlint_version(executable: nil)
+        binary = executable || 'swiftlint'
+        Gem::Version.new(`#{binary} version`.chomp)
+      end
+
+      def self.supported_no_cache_option(params)
+        if [:autocorrect, :fix, :lint].include?(params[:mode])
+          return " --no-cache"
+        else
+          return ""
+        end
+      end
+
+      # Return "--option" switch if option is on and current SwiftLint version is greater or equal than min version.
+      # Return "" otherwise.
+      def self.supported_option_switch(params, option, min_version, can_ignore = false)
+        return "" unless params[option]
+        version = swiftlint_version(executable: params[:executable])
+        if version < Gem::Version.new(min_version)
+          message = "Your version of swiftlint (#{version}) does not support '--#{option}' option.\nUpdate swiftlint to #{min_version} or above using `brew update && brew upgrade swiftlint`"
+          message += "\nThe option will be ignored." if can_ignore
+          can_ignore ? UI.important(message) : UI.user_error!(message)
+          ""
+        else
+          " --#{option}"
+        end
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Run swift code validation using SwiftLint"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :mode,
+                                       env_name: "FL_SWIFTLINT_MODE",
+                                       description: "SwiftLint mode: :lint, :fix, :autocorrect or :analyze",
+                                       type: Symbol,
+                                       default_value: :lint,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :path,
+                                       env_name: "FL_SWIFTLINT_PATH",
+                                       description: "Specify path to lint",
+                                       optional: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Couldn't find path '#{File.expand_path(value)}'") unless File.exist?(value)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :output_file,
+                                       env_name: "FL_SWIFTLINT_OUTPUT_FILE",
+                                       description: 'Path to output SwiftLint result',
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :config_file,
+                                       env_name: "FL_SWIFTLINT_CONFIG_FILE",
+                                       description: 'Custom configuration file of SwiftLint',
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :strict,
+                                       env_name: "FL_SWIFTLINT_STRICT",
+                                       description: 'Fail on warnings? (true/false)',
+                                       default_value: false,
+                                       type: Boolean,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :files,
+                                       env_name: "FL_SWIFTLINT_FILES",
+                                       description: 'List of files to process',
+                                       type: Array,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :ignore_exit_status,
+                                       env_name: "FL_SWIFTLINT_IGNORE_EXIT_STATUS",
+                                       description: "Ignore the exit status of the SwiftLint command, so that serious violations \
+                                                    don't fail the build (true/false)",
+                                       default_value: false,
+                                       type: Boolean,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :raise_if_swiftlint_error,
+                                       env_name: "FL_SWIFTLINT_RAISE_IF_SWIFTLINT_ERROR",
+                                       description: "Raises an error if swiftlint fails, so you can fail CI/CD jobs if necessary \
+                                                    (true/false)",
+                                       default_value: false,
+                                       type: Boolean,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :reporter,
+                                       env_name: "FL_SWIFTLINT_REPORTER",
+                                       description: "Choose output reporter. Available: xcode, json, csv, checkstyle, codeclimate, \
+                                                     junit, html, emoji, sonarqube, markdown, github-actions-logging",
+                                       optional: true,
+                                       verify_block: proc do |value|
+                                         available = ['xcode', 'json', 'csv', 'checkstyle', 'codeclimate', 'junit', 'html', 'emoji', 'sonarqube', 'markdown', 'github-actions-logging']
+                                         UI.important("Known 'reporter' values are '#{available.join("', '")}'. If you're receiving errors from swiftlint related to the reporter, make sure the reporter identifier you're using is correct and it's supported by your version of swiftlint.") unless available.include?(value)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :quiet,
+                                       env_name: "FL_SWIFTLINT_QUIET",
+                                       description: "Don't print status logs like 'Linting <file>' & 'Done linting'",
+                                       default_value: false,
+                                       type: Boolean,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :executable,
+                                       env_name: "FL_SWIFTLINT_EXECUTABLE",
+                                       description: "Path to the `swiftlint` executable on your machine",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :format,
+                                       env_name: "FL_SWIFTLINT_FORMAT",
+                                       description: "Format code when mode is :autocorrect",
+                                       default_value: false,
+                                       type: Boolean,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :no_cache,
+                                       env_name: "FL_SWIFTLINT_NO_CACHE",
+                                       description: "Ignore the cache when mode is :autocorrect or :lint",
+                                       default_value: false,
+                                       type: Boolean,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :compiler_log_path,
+                                       env_name: "FL_SWIFTLINT_COMPILER_LOG_PATH",
+                                       description: "Compiler log path when mode is :analyze",
+                                       optional: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Couldn't find compiler_log_path '#{File.expand_path(value)}'") unless File.exist?(value)
+                                       end)
+        ]
+      end
+
+      def self.output
+      end
+
+      def self.return_value
+      end
+
+      def self.authors
+        ["KrauseFx"]
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include?(platform)
+      end
+
+      def self.example_code
+        [
+          'swiftlint(
+            mode: :lint,                          # SwiftLint mode: :lint (default) or :autocorrect
+            path: "/path/to/lint",                 # Specify path to lint (optional)
+            output_file: "swiftlint.result.json", # The path of the output file (optional)
+            config_file: ".swiftlint-ci.yml",     # The path of the configuration file (optional)
+            files: [                              # List of files to process (optional)
+              "AppDelegate.swift",
+              "path/to/project/Model.swift"
+            ],
+            raise_if_swiftlint_error: true,      # Allow fastlane to raise an error if swiftlint fails
+            ignore_exit_status: true              # Allow fastlane to continue even if SwiftLint returns a non-zero exit status
+
+          )'
+        ]
+      end
+
+      def self.category
+        :testing
+      end
+
+      def self.handle_swiftlint_error(ignore_exit_status, exit_status)
+        if ignore_exit_status
+          failure_suffix = 'which would normally fail the build.'
+          secondary_message = 'fastlane will continue because the `ignore_exit_status` option was used! 🙈'
+        else
+          failure_suffix = 'which represents a failure.'
+          secondary_message = 'If you want fastlane to continue anyway, use the `ignore_exit_status` option. 🙈'
+        end
+
+        UI.important("")
+        UI.important("SwiftLint finished with exit code #{exit_status}, #{failure_suffix}")
+        UI.important(secondary_message)
+        UI.important("")
+        UI.user_error!("SwiftLint finished with errors (exit code: #{exit_status})") unless ignore_exit_status
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/sync_code_signing.rb

@@ -0,0 +1,114 @@
+module Fastlane
+  module Actions
+    module SharedValues
+      MATCH_PROVISIONING_PROFILE_MAPPING = :MATCH_PROVISIONING_PROFILE_MAPPING
+      SIGH_PROFILE_TYPE ||= :SIGH_PROFILE_TYPE # originally defined in GetProvisioningProfileAction
+    end
+
+    class SyncCodeSigningAction < Action
+      def self.run(params)
+        require 'match'
+
+        params.load_configuration_file("Matchfile")
+
+        # Only set :api_key from SharedValues if :api_key_path isn't set (conflicting options)
+        unless params[:api_key_path]
+          params[:api_key] ||= Actions.lane_context[SharedValues::APP_STORE_CONNECT_API_KEY]
+        end
+
+        Match::Runner.new.run(params)
+
+        define_profile_type(params)
+        define_provisioning_profile_mapping(params)
+      end
+
+      def self.define_profile_type(params)
+        profile_type = "app-store"
+        profile_type = "ad-hoc" if params[:type] == 'adhoc'
+        profile_type = "development" if params[:type] == 'development'
+        profile_type = "enterprise" if params[:type] == 'enterprise'
+
+        UI.message("Setting Provisioning Profile type to '#{profile_type}'")
+
+        Actions.lane_context[SharedValues::SIGH_PROFILE_TYPE] = profile_type
+      end
+
+      # Maps the bundle identifier to the appropriate provisioning profile
+      # This is used in the _gym_ action as part of the export options
+      # e.g.
+      #
+      #   export_options: {
+      #     provisioningProfiles: { "me.themoji.app.beta": "match AppStore me.themoji.app.beta" }
+      #   }
+      #
+      def self.define_provisioning_profile_mapping(params)
+        mapping = Actions.lane_context[SharedValues::MATCH_PROVISIONING_PROFILE_MAPPING] || {}
+
+        # Array (...) to make sure it's an Array, Ruby is magic, try this
+        #   Array(1)      # => [1]
+        #   Array([1, 2]) # => [1, 2]
+        Array(params[:app_identifier]).each do |app_identifier|
+          env_variable_name = Match::Utils.environment_variable_name_profile_name(app_identifier: app_identifier,
+                                                                                            type: Match.profile_type_sym(params[:type]),
+                                                                                        platform: params[:platform])
+
+          if params[:derive_catalyst_app_identifier]
+            app_identifier = "maccatalyst.#{app_identifier}"
+          end
+
+          mapping[app_identifier] = ENV[env_variable_name]
+        end
+
+        Actions.lane_context[SharedValues::MATCH_PROVISIONING_PROFILE_MAPPING] = mapping
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Easily sync your certificates and profiles across your team (via _match_)"
+      end
+
+      def self.details
+        "More information: https://docs.fastlane.tools/actions/match/"
+      end
+
+      def self.available_options
+        require 'match'
+        Match::Options.available_options
+      end
+
+      def self.output
+        [
+          ['MATCH_PROVISIONING_PROFILE_MAPPING', 'The match provisioning profile mapping'],
+          ['SIGH_PROFILE_TYPE', 'The profile type, can be app-store, ad-hoc, development, enterprise, can be used in `build_app` as a default value for `export_method`']
+        ]
+      end
+
+      def self.return_value
+      end
+
+      def self.authors
+        ["KrauseFx"]
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include?(platform)
+      end
+
+      def self.example_code
+        [
+          'sync_code_signing(type: "appstore", app_identifier: "tools.fastlane.app")',
+          'sync_code_signing(type: "development", readonly: true)',
+          'sync_code_signing(app_identifier: ["tools.fastlane.app", "tools.fastlane.sleepy"])',
+          'match   # alias for "sync_code_signing"'
+        ]
+      end
+
+      def self.category
+        :code_signing
+      end
+    end
+  end
+end