fastlane_pricing_fix 2.212.1

data/fastlane/lib/fastlane/actions/carthage.rb

@@ -0,0 +1,238 @@
+module Fastlane
+  module Actions
+    class CarthageAction < Action
+      # rubocop:disable Metrics/PerceivedComplexity
+      def self.run(params)
+        validate(params)
+
+        cmd = [params[:executable]]
+        command_name = params[:command]
+        cmd << command_name
+
+        if command_name == "archive" && params[:frameworks].count > 0
+          cmd.concat(params[:frameworks])
+        # "update", "build" and "bootstrap" are the only commands that support "--derived-data" parameter
+        elsif ["update", "build", "bootstrap"].include?(command_name)
+          cmd.concat(params[:dependencies]) if params[:dependencies].count > 0
+          cmd << "--derived-data #{params[:derived_data].shellescape}" if params[:derived_data]
+        end
+
+        cmd << "--output #{params[:output]}" if params[:output]
+        cmd << "--use-ssh" if params[:use_ssh]
+        cmd << "--use-submodules" if params[:use_submodules]
+        cmd << "--use-netrc" if params[:use_netrc]
+        cmd << "--no-use-binaries" if params[:use_binaries] == false
+        cmd << "--no-checkout" if params[:no_checkout] == true
+        cmd << "--no-build" if params[:no_build] == true
+        cmd << "--no-skip-current" if params[:no_skip_current] == true
+        cmd << "--verbose" if params[:verbose] == true
+        cmd << "--platform #{params[:platform]}" if params[:platform]
+        cmd << "--configuration #{params[:configuration]}" if params[:configuration]
+        cmd << "--toolchain #{params[:toolchain]}" if params[:toolchain]
+        cmd << "--project-directory #{params[:project_directory]}" if params[:project_directory]
+        cmd << "--cache-builds" if params[:cache_builds]
+        cmd << "--new-resolver" if params[:new_resolver]
+        cmd << "--log-path #{params[:log_path]}" if params[:log_path]
+        cmd << "--use-xcframeworks" if params[:use_xcframeworks]
+        cmd << "--archive" if params[:archive]
+
+        Actions.sh(cmd.join(' '))
+      end
+      # rubocop:enable Metrics/PerceivedComplexity
+
+      def self.validate(params)
+        command_name = params[:command]
+        if command_name != "archive" && params[:frameworks].count > 0
+          UI.user_error!("Frameworks option is available only for 'archive' command.")
+        end
+        if command_name != "archive" && params[:output]
+          UI.user_error!("Output option is available only for 'archive' command.")
+        end
+
+        if params[:log_path] && !%w(build bootstrap update).include?(command_name)
+          UI.user_error!("Log path option is available only for 'build', 'bootstrap', and 'update' command.")
+        end
+
+        if params[:use_xcframeworks] && !%w(build bootstrap update).include?(command_name)
+          UI.user_error!("Use XCFrameworks option is available only for 'build', 'bootstrap', and 'update' command.")
+        end
+
+        if command_name != "build" && params[:archive]
+          UI.user_error!("Archive option is available only for 'build' command.")
+        end
+      end
+
+      def self.description
+        "Runs `carthage` for your project"
+      end
+
+      def self.available_commands
+        %w(build bootstrap update archive)
+      end
+
+      def self.available_platforms
+        %w(all iOS Mac tvOS watchOS)
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :command,
+                                       env_name: "FL_CARTHAGE_COMMAND",
+                                       description: "Carthage command (one of: #{available_commands.join(', ')})",
+                                       default_value: 'bootstrap',
+                                       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: :dependencies,
+                                       description: "Carthage dependencies to update, build or bootstrap",
+                                       default_value: [],
+                                       type: Array),
+          FastlaneCore::ConfigItem.new(key: :use_ssh,
+                                       env_name: "FL_CARTHAGE_USE_SSH",
+                                       description: "Use SSH for downloading GitHub repositories",
+                                       type: Boolean,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :use_submodules,
+                                       env_name: "FL_CARTHAGE_USE_SUBMODULES",
+                                       description: "Add dependencies as Git submodules",
+                                       type: Boolean,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :use_netrc,
+                                       env_name: "FL_CARTHAGE_USE_NETRC",
+                                       description: "Use .netrc for downloading frameworks",
+                                       type: Boolean,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :use_binaries,
+                                       env_name: "FL_CARTHAGE_USE_BINARIES",
+                                       description: "Check out dependency repositories even when prebuilt frameworks exist",
+                                       type: Boolean,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :no_checkout,
+                                       env_name: "FL_CARTHAGE_NO_CHECKOUT",
+                                       description: "When bootstrapping Carthage do not checkout",
+                                       type: Boolean,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :no_build,
+                                       env_name: "FL_CARTHAGE_NO_BUILD",
+                                       description: "When bootstrapping Carthage do not build",
+                                       type: Boolean,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :no_skip_current,
+                                       env_name: "FL_CARTHAGE_NO_SKIP_CURRENT",
+                                       description: "Don't skip building the Carthage project (in addition to its dependencies)",
+                                       type: Boolean,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :derived_data,
+                                       env_name: "FL_CARTHAGE_DERIVED_DATA",
+                                       description: "Use derived data folder at path",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :verbose,
+                                       env_name: "FL_CARTHAGE_VERBOSE",
+                                       description: "Print xcodebuild output inline",
+                                       type: Boolean,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :platform,
+                                       env_name: "FL_CARTHAGE_PLATFORM",
+                                       description: "Define which platform to build for",
+                                       optional: true,
+                                       verify_block: proc do |value|
+                                         value.split(',').each do |platform|
+                                           UI.user_error!("Please pass a valid platform. Use one of the following: #{available_platforms.join(', ')}") unless available_platforms.map(&:downcase).include?(platform.downcase)
+                                         end
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :cache_builds,
+                                       env_name: "FL_CARTHAGE_CACHE_BUILDS",
+                                       description: "By default Carthage will rebuild a dependency regardless of whether it's the same resolved version as before. Passing the --cache-builds will cause carthage to avoid rebuilding a dependency if it can",
+                                       type: Boolean,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :frameworks,
+                                       description: "Framework name or names to archive, could be applied only along with the archive command",
+                                       default_value: [],
+                                       type: Array),
+          FastlaneCore::ConfigItem.new(key: :output,
+                                       description: "Output name for the archive, could be applied only along with the archive command. Use following format *.framework.zip",
+                                       optional: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Please pass a valid string for output. Use following format *.framework.zip") unless value.end_with?("framework.zip")
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :configuration,
+                                       env_name: "FL_CARTHAGE_CONFIGURATION",
+                                       description: "Define which build configuration to use when building",
+                                       optional: true,
+                                       verify_block: proc do |value|
+                                         if value.chomp(' ').empty?
+                                           UI.user_error!("Please pass a valid build configuration. You can review the list of configurations for this project using the command: xcodebuild -list")
+                                         end
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :toolchain,
+                                       env_name: "FL_CARTHAGE_TOOLCHAIN",
+                                       description: "Define which xcodebuild toolchain to use when building",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :project_directory,
+                                       env_name: "FL_CARTHAGE_PROJECT_DIRECTORY",
+                                       description: "Define the directory containing the Carthage project",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :new_resolver,
+                                       env_name: "FL_CARTHAGE_NEW_RESOLVER",
+                                       description: "Use new resolver when resolving dependency graph",
+                                       optional: true,
+                                       type: Boolean),
+          FastlaneCore::ConfigItem.new(key: :log_path,
+                                       env_name: "FL_CARTHAGE_LOG_PATH",
+                                       description: "Path to the xcode build output",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :use_xcframeworks,
+                                       env_name: "FL_CARTHAGE_USE_XCFRAMEWORKS",
+                                       description: "Create xcframework bundles instead of one framework per platform (requires Xcode 12+)",
+                                       type: Boolean,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :archive,
+                                       env_name: "FL_CARTHAGE_ARCHIVE",
+                                       description: "Archive built frameworks from the current project",
+                                       type: Boolean,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :executable,
+                                       env_name: "FL_CARTHAGE_EXECUTABLE",
+                                       description: "Path to the `carthage` executable on your machine",
+                                       default_value: 'carthage')
+        ]
+      end
+
+      def self.example_code
+        [
+          'carthage',
+          'carthage(
+            frameworks: ["MyFramework1", "MyFramework2"],   # Specify which frameworks to archive (only for the archive command)
+            output: "MyFrameworkBundle.framework.zip",      # Specify the output archive name (only for the archive command)
+            command: "bootstrap",                           # One of: build, bootstrap, update, archive. (default: bootstrap)
+            dependencies: ["Alamofire", "Notice"],          # Specify which dependencies to update or build (only for update, build and bootstrap commands)
+            use_ssh: false,                                 # Use SSH for downloading GitHub repositories.
+            use_submodules: false,                          # Add dependencies as Git submodules.
+            use_binaries: true,                             # Check out dependency repositories even when prebuilt frameworks exist
+            no_build: false,                                # When bootstrapping Carthage do not build
+            no_skip_current: false,                         # Don\'t skip building the current project (only for frameworks)
+            verbose: false,                                 # Print xcodebuild output inline
+            platform: "all",                                # Define which platform to build for (one of ‘all’, ‘Mac’, ‘iOS’, ‘watchOS’, ‘tvOS‘, or comma-separated values of the formers except for ‘all’)
+            configuration: "Release",                       # Build configuration to use when building
+            cache_builds: true,                             # By default Carthage will rebuild a dependency regardless of whether its the same resolved version as before.
+            toolchain: "com.apple.dt.toolchain.Swift_2_3",  # Specify the xcodebuild toolchain
+            new_resolver: false,                            # Use the new resolver to resolve dependency graph
+            log_path: "carthage.log"                        # Path to the xcode build output
+          )'
+        ]
+      end
+
+      def self.category
+        :building
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include?(platform)
+      end
+
+      def self.authors
+        ["bassrock", "petester42", "jschmid", "JaviSoto", "uny", "phatblat", "bfcrampton", "antondomashnev", "gbrhaz"]
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/cert.rb

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

data/fastlane/lib/fastlane/actions/changelog_from_git_commits.rb

@@ -0,0 +1,188 @@
+module Fastlane
+  module Actions
+    module SharedValues
+      FL_CHANGELOG ||= :FL_CHANGELOG
+    end
+
+    class ChangelogFromGitCommitsAction < Action
+      def self.run(params)
+        if params[:commits_count]
+          UI.success("Collecting the last #{params[:commits_count]} Git commits")
+        else
+          if params[:between]
+            if params[:between].kind_of?(String) && params[:between].include?(",") # :between is string
+              from, to = params[:between].split(",", 2)
+            elsif params[:between].kind_of?(Array)
+              from, to = params[:between]
+            end
+          else
+            from = Actions.last_git_tag_name(params[:match_lightweight_tag], params[:tag_match_pattern])
+            UI.verbose("Found the last Git tag: #{from}")
+            to = 'HEAD'
+          end
+          UI.success("Collecting Git commits between #{from} and #{to}")
+        end
+
+        # Normally it is not good practice to take arbitrary input and convert it to a symbol
+        # because prior to Ruby 2.2, symbols are never garbage collected. However, we've
+        # already validated that the input matches one of our allowed values, so this is OK
+        merge_commit_filtering = params[:merge_commit_filtering].to_sym
+
+        # We want to be specific and exclude nil for this comparison
+        if params[:include_merges] == false
+          merge_commit_filtering = :exclude_merges
+        end
+
+        params[:path] = './' unless params[:path]
+
+        Dir.chdir(params[:path]) do
+          if params[:commits_count]
+            changelog = Actions.git_log_last_commits(params[:pretty], params[:commits_count], merge_commit_filtering, params[:date_format], params[:ancestry_path])
+          else
+            changelog = Actions.git_log_between(params[:pretty], from, to, merge_commit_filtering, params[:date_format], params[:ancestry_path])
+          end
+
+          changelog = changelog.gsub("\n\n", "\n") if changelog # as there are duplicate newlines
+          Actions.lane_context[SharedValues::FL_CHANGELOG] = changelog
+
+          if params[:quiet] == false
+            puts("")
+            puts(changelog)
+            puts("")
+          end
+
+          changelog
+        end
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Collect git commit messages into a changelog"
+      end
+
+      def self.details
+        "By default, messages will be collected back to the last tag, but the range can be controlled"
+      end
+
+      def self.output
+        [
+          ['FL_CHANGELOG', 'The changelog string generated from the collected git commit messages']
+        ]
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :between,
+                                       env_name: 'FL_CHANGELOG_FROM_GIT_COMMITS_BETWEEN',
+                                       description: 'Array containing two Git revision values between which to collect messages, you mustn\'t use it with :commits_count key at the same time',
+                                       optional: true,
+                                       type: Array, # allow Array, String both
+                                       conflicting_options: [:commits_count],
+                                       verify_block: proc do |value|
+                                         UI.user_error!(":between must not contain nil values") if value.any?(&:nil?)
+                                         UI.user_error!(":between must be an array of size 2") unless (value || []).size == 2
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :commits_count,
+                                       env_name: 'FL_CHANGELOG_FROM_GIT_COMMITS_COUNT',
+                                       description: 'Number of commits to include in changelog, you mustn\'t use it with :between key at the same time',
+                                       optional: true,
+                                       conflicting_options: [:between],
+                                       type: Integer,
+                                       verify_block: proc do |value|
+                                         UI.user_error!(":commits_count must be >= 1") unless value.to_i >= 1
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :path,
+                                       env_name: 'FL_CHANGELOG_FROM_GIT_COMMITS_PATH',
+                                       description: 'Path of the git repository',
+                                       optional: true,
+                                       default_value: './'),
+          FastlaneCore::ConfigItem.new(key: :pretty,
+                                       env_name: 'FL_CHANGELOG_FROM_GIT_COMMITS_PRETTY',
+                                       description: 'The format applied to each commit while generating the collected value',
+                                       optional: true,
+                                       default_value: '%B'),
+          FastlaneCore::ConfigItem.new(key: :date_format,
+                                       env_name: 'FL_CHANGELOG_FROM_GIT_COMMITS_DATE_FORMAT',
+                                       description: 'The date format applied to each commit while generating the collected value',
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :ancestry_path,
+                                       env_name: 'FL_CHANGELOG_FROM_GIT_COMMITS_ANCESTRY_PATH',
+                                       description: 'Whether or not to use ancestry-path param',
+                                       optional: true,
+                                       default_value: false,
+                                       type: Boolean),
+          FastlaneCore::ConfigItem.new(key: :tag_match_pattern,
+                                       env_name: 'FL_CHANGELOG_FROM_GIT_COMMITS_TAG_MATCH_PATTERN',
+                                       description: 'A glob(7) pattern to match against when finding the last git tag',
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :match_lightweight_tag,
+                                       env_name: 'FL_CHANGELOG_FROM_GIT_COMMITS_MATCH_LIGHTWEIGHT_TAG',
+                                       description: 'Whether or not to match a lightweight tag when searching for the last one',
+                                       optional: true,
+                                       default_value: true,
+                                       type: Boolean),
+          FastlaneCore::ConfigItem.new(key: :quiet,
+                                       env_name: 'FL_CHANGELOG_FROM_GIT_COMMITS_TAG_QUIET',
+                                       description: 'Whether or not to disable changelog output',
+                                       optional: true,
+                                       default_value: false,
+                                       type: Boolean),
+          FastlaneCore::ConfigItem.new(key: :include_merges,
+                                       deprecated: "Use `:merge_commit_filtering` instead",
+                                       env_name: 'FL_CHANGELOG_FROM_GIT_COMMITS_INCLUDE_MERGES',
+                                       description: "Whether or not to include any commits that are merges",
+                                       optional: true,
+                                       type: Boolean,
+                                       verify_block: proc do |value|
+                                         UI.important("The :include_merges option is deprecated. Please use :merge_commit_filtering instead") unless value.nil?
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :merge_commit_filtering,
+                                       env_name: 'FL_CHANGELOG_FROM_GIT_COMMITS_MERGE_COMMIT_FILTERING',
+                                       description: "Controls inclusion of merge commits when collecting the changelog. Valid values: #{GIT_MERGE_COMMIT_FILTERING_OPTIONS.map { |o| "'#{o}'" }.join(', ')}",
+                                       optional: true,
+                                       default_value: 'include_merges',
+                                       verify_block: proc do |value|
+                                         matches_option = GIT_MERGE_COMMIT_FILTERING_OPTIONS.any? { |opt| opt.to_s == value }
+                                         UI.user_error!("Valid values for :merge_commit_filtering are #{GIT_MERGE_COMMIT_FILTERING_OPTIONS.map { |o| "'#{o}'" }.join(', ')}") unless matches_option
+                                       end)
+        ]
+      end
+
+      def self.return_value
+        "Returns a String containing your formatted git commits"
+      end
+
+      def self.return_type
+        :string
+      end
+
+      def self.author
+        ['mfurtak', 'asfalcone', 'SiarheiFedartsou', 'allewun']
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.example_code
+        [
+          'changelog_from_git_commits',
+          'changelog_from_git_commits(
+            between: ["7b092b3", "HEAD"],            # Optional, lets you specify a revision/tag range between which to collect commit info
+            pretty: "- (%ae) %s",                    # Optional, lets you provide a custom format to apply to each commit when generating the changelog text
+            date_format: "short",                    # Optional, lets you provide an additional date format to dates within the pretty-formatted string
+            match_lightweight_tag: false,            # Optional, lets you ignore lightweight (non-annotated) tags when searching for the last tag
+            merge_commit_filtering: "exclude_merges" # Optional, lets you filter out merge commits
+          )'
+        ]
+      end
+
+      def self.category
+        :source_control
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/chatwork.rb

@@ -0,0 +1,95 @@
+module Fastlane
+  module Actions
+    module SharedValues
+    end
+
+    class ChatworkAction < Action
+      def self.run(options)
+        require 'net/http'
+        require 'uri'
+
+        emoticon = (options[:success] ? '(dance)' : ';(')
+
+        uri = URI.parse("https://api.chatwork.com/v2/rooms/#{options[:roomid]}/messages")
+        https = Net::HTTP.new(uri.host, uri.port)
+        https.use_ssl = true
+
+        req = Net::HTTP::Post.new(uri.request_uri)
+        req['X-ChatWorkToken'] = options[:api_token]
+        req.set_form_data({
+          'body' => "[info][title]Notification from fastlane[/title]#{emoticon} #{options[:message]}[/info]"
+        })
+
+        response = https.request(req)
+        case response.code.to_i
+        when 200..299
+          UI.success('Successfully sent notification to ChatWork right now 📢')
+        else
+          require 'json'
+          json = JSON.parse(response.body)
+          UI.user_error!("HTTP Error: #{response.code} #{json['errors']}")
+        end
+      end
+
+      def self.description
+        "Send a success/error message to [ChatWork](https://go.chatwork.com/)"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :api_token,
+                                       env_name: "CHATWORK_API_TOKEN",
+                                       description: "ChatWork API Token",
+                                       sensitive: true,
+                                       code_gen_sensitive: true,
+                                       verify_block: proc do |value|
+                                         unless value.to_s.length > 0
+                                           UI.error("Please add 'ENV[\"CHATWORK_API_TOKEN\"] = \"your token\"' to your Fastfile's `before_all` section.")
+                                           UI.user_error!("No CHATWORK_API_TOKEN given.")
+                                         end
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :message,
+                                       env_name: "FL_CHATWORK_MESSAGE",
+                                       description: "The message to post on ChatWork"),
+          FastlaneCore::ConfigItem.new(key: :roomid,
+                                       env_name: "FL_CHATWORK_ROOMID",
+                                       description: "The room ID",
+                                       type: Integer),
+          FastlaneCore::ConfigItem.new(key: :success,
+                                       env_name: "FL_CHATWORK_SUCCESS",
+                                       description: "Was this build successful? (true/false)",
+                                       optional: true,
+                                       default_value: true,
+                                       type: Boolean)
+        ]
+      end
+
+      def self.author
+        "astronaughts"
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.details
+        "Information on how to obtain an API token: [http://developer.chatwork.com/ja/authenticate.html](http://developer.chatwork.com/ja/authenticate.html)"
+      end
+
+      def self.example_code
+        [
+          'chatwork(
+            message: "App successfully released!",
+            roomid: 12345,
+            success: true,
+            api_token: "Your Token"
+          )'
+        ]
+      end
+
+      def self.category
+        :notifications
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/check_app_store_metadata.rb

@@ -0,0 +1,62 @@
+module Fastlane
+  module Actions
+    module SharedValues
+    end
+
+    class CheckAppStoreMetadataAction < Action
+      def self.run(config)
+        # Only set :api_key from SharedValues if :api_key_path isn't set (conflicting options)
+        unless config[:api_key_path]
+          config[:api_key] ||= Actions.lane_context[SharedValues::APP_STORE_CONNECT_API_KEY]
+        end
+
+        require 'precheck'
+        Precheck.config = config
+        return Precheck::Runner.new.run
+      end
+
+      def self.description
+        "Check your app's metadata before you submit your app to review (via _precheck_)"
+      end
+
+      def self.details
+        "More information: https://fastlane.tools/precheck"
+      end
+
+      def self.available_options
+        require 'precheck/options'
+        Precheck::Options.available_options
+      end
+
+      def self.return_value
+        return "true if precheck passes, else, false"
+      end
+
+      def self.return_type
+        :bool
+      end
+
+      def self.authors
+        ["taquitos"]
+      end
+
+      def self.is_supported?(platform)
+        platform == :ios
+      end
+
+      def self.example_code
+        [
+          'check_app_store_metadata(
+            negative_apple_sentiment: [level: :skip], # Set to skip to not run the `negative_apple_sentiment` rule
+            curse_words: [level: :warn] # Set to warn to only warn on curse word check failures
+          )',
+          'precheck   # alias for "check_app_store_metadata"'
+        ]
+      end
+
+      def self.category
+        :app_store_connect
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/clean_build_artifacts.rb

@@ -0,0 +1,71 @@
+module Fastlane
+  module Actions
+    class CleanBuildArtifactsAction < Action
+      def self.run(options)
+        paths = [
+          Actions.lane_context[Actions::SharedValues::IPA_OUTPUT_PATH],
+          Actions.lane_context[Actions::SharedValues::DSYM_OUTPUT_PATH],
+          Actions.lane_context[Actions::SharedValues::CERT_FILE_PATH]
+        ]
+
+        paths += Actions.lane_context[Actions::SharedValues::SIGH_PROFILE_PATHS] || []
+        paths += Actions.lane_context[Actions::SharedValues::DSYM_PATHS] || []
+        paths = paths.uniq
+
+        paths.reject { |file| file.nil? || !File.exist?(file) }.each do |file|
+          if options[:exclude_pattern]
+            next if file.match(options[:exclude_pattern])
+          end
+
+          UI.verbose("Cleaning up '#{file}'")
+          File.delete(file)
+        end
+
+        Actions.lane_context[Actions::SharedValues::SIGH_PROFILE_PATHS] = nil
+        Actions.lane_context[Actions::SharedValues::DSYM_PATHS] = nil
+        Actions.lane_context[Actions::SharedValues::DSYM_LATEST_UPLOADED_DATE] = nil
+
+        UI.success('Cleaned up build artifacts 🐙')
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :exclude_pattern,
+                                       env_name: "FL_CLEAN_BUILD_ARTIFACTS_EXCLUDE_PATTERN",
+                                       description: "Exclude all files from clearing that match the given Regex pattern: e.g. '.*\.mobileprovision'",
+                                       optional: true)
+        ]
+      end
+
+      def self.description
+        "Deletes files created as result of running gym, cert, sigh or download_dsyms"
+      end
+
+      def self.details
+        [
+          "This action deletes the files that get created in your repo as a result of running the _gym_ and _sigh_ commands. It doesn't delete the `fastlane/report.xml` though, this is probably more suited for the .gitignore.",
+          "",
+          "Useful if you quickly want to send out a test build by dropping down to the command line and typing something like `fastlane beta`, without leaving your repo in a messy state afterwards."
+        ].join("\n")
+      end
+
+      def self.author
+        "lmirosevic"
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include?(platform)
+      end
+
+      def self.example_code
+        [
+          'clean_build_artifacts'
+        ]
+      end
+
+      def self.category
+        :misc
+      end
+    end
+  end
+end