fastlane_pricing_fix 2.212.1

data/fastlane/lib/fastlane/actions/ensure_bundle_exec.rb

@@ -0,0 +1,59 @@
+module Fastlane
+  module Actions
+    module SharedValues
+    end
+
+    # Raises an exception and stop the lane execution if not using bundle exec to run fastlane
+    class EnsureBundleExecAction < Action
+      def self.run(params)
+        return if PluginManager.new.gemfile_path.nil?
+        if FastlaneCore::Helper.bundler?
+          UI.success("Using bundled fastlane ✅")
+        else
+          UI.user_error!("fastlane detected a Gemfile in the current directory. However, it seems like you didn't use `bundle exec`. Use `bundle exec fastlane #{ARGV.join(' ')}` instead.")
+        end
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Raises an exception if not using `bundle exec` to run fastlane"
+      end
+
+      def self.details
+        [
+          "This action will check if you are using `bundle exec` to run fastlane.",
+          "You can put it into `before_all` to make sure that fastlane is ran using the `bundle exec fastlane` command."
+        ].join("\n")
+      end
+
+      def self.available_options
+        []
+      end
+
+      def self.output
+        []
+      end
+
+      def self.author
+        ['rishabhtayal']
+      end
+
+      def self.example_code
+        [
+          "ensure_bundle_exec"
+        ]
+      end
+
+      def self.category
+        :misc
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/ensure_env_vars.rb

@@ -0,0 +1,54 @@
+module Fastlane
+  module Actions
+    class EnsureEnvVarsAction < Action
+      def self.run(params)
+        variables = params[:env_vars]
+        missing_variables = variables.select { |variable| ENV[variable].to_s.strip.empty? }
+
+        UI.user_error!("Missing environment variable(s) '#{missing_variables.join('\', \'')}'") unless missing_variables.empty?
+
+        is_one = variables.length == 1
+        UI.success("Environment variable#{is_one ? '' : 's'} '#{variables.join('\', \'')}' #{is_one ? 'is' : 'are'} set!")
+      end
+
+      def self.description
+        'Raises an exception if the specified env vars are not set'
+      end
+
+      def self.details
+        'This action will check if some environment variables are set.'
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :env_vars,
+                                       description: 'The environment variables names that should be checked',
+                                       type: Array,
+                                       verify_block: proc do |value|
+                                         UI.user_error!('Specify at least one environment variable name') if value.empty?
+                                       end)
+        ]
+      end
+
+      def self.authors
+        ['revolter']
+      end
+
+      def self.example_code
+        [
+          'ensure_env_vars(
+            env_vars: [\'GITHUB_USER_NAME\', \'GITHUB_API_TOKEN\']
+          )'
+        ]
+      end
+
+      def self.category
+        :misc
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/ensure_git_branch.rb

@@ -0,0 +1,68 @@
+module Fastlane
+  module Actions
+    module SharedValues
+    end
+
+    # Raises an exception and stop the lane execution if the repo is not on a specific branch
+    class EnsureGitBranchAction < Action
+      def self.run(params)
+        branch = params[:branch]
+        branch_expr = /#{branch}/
+        if Actions.git_branch =~ branch_expr
+          UI.success("Git branch matches `#{branch}`, all good! 💪")
+        else
+          UI.user_error!("Git is not on a branch matching `#{branch}`. Current branch is `#{Actions.git_branch}`! Please ensure the repo is checked out to the correct branch.")
+        end
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Raises an exception if not on a specific git branch"
+      end
+
+      def self.details
+        [
+          "This action will check if your git repo is checked out to a specific branch.",
+          "You may only want to make releases from a specific branch, so `ensure_git_branch` will stop a lane if it was accidentally executed on an incorrect branch."
+        ].join("\n")
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :branch,
+                                       env_name: "FL_ENSURE_GIT_BRANCH_NAME",
+                                       description: "The branch that should be checked for. String that can be either the full name of the branch or a regex e.g. `^feature\/.*$` to match",
+                                       default_value: 'master')
+        ]
+      end
+
+      def self.output
+        []
+      end
+
+      def self.author
+        ['dbachrach', 'Liquidsoul']
+      end
+
+      def self.example_code
+        [
+          "ensure_git_branch # defaults to `master` branch",
+          "ensure_git_branch(
+            branch: 'develop'
+          )"
+        ]
+      end
+
+      def self.category
+        :source_control
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/ensure_git_status_clean.rb

@@ -0,0 +1,102 @@
+module Fastlane
+  module Actions
+    module SharedValues
+      GIT_REPO_WAS_CLEAN_ON_START = :GIT_REPO_WAS_CLEAN_ON_START
+    end
+
+    # Raises an exception and stop the lane execution if the repo is not in a clean state
+    class EnsureGitStatusCleanAction < Action
+      def self.run(params)
+        if params[:ignored]
+          ignored_mode = params[:ignored]
+          ignored_mode = 'no' if ignored_mode == 'none'
+          repo_status = Actions.sh("git status --porcelain --ignored='#{ignored_mode}'")
+        else
+          repo_status = Actions.sh("git status --porcelain")
+        end
+
+        repo_clean = repo_status.empty?
+
+        if repo_clean
+          UI.success('Git status is clean, all good! 💪')
+          Actions.lane_context[SharedValues::GIT_REPO_WAS_CLEAN_ON_START] = true
+        else
+          error_message = "Git repository is dirty! Please ensure the repo is in a clean state by committing/stashing/discarding all changes first."
+          error_message += "\nUncommitted changes:\n#{repo_status}" if params[:show_uncommitted_changes]
+          if params[:show_diff]
+            repo_diff = Actions.sh("git diff")
+            error_message += "\nGit diff: \n#{repo_diff}"
+          end
+          UI.user_error!(error_message)
+        end
+      end
+
+      def self.description
+        "Raises an exception if there are uncommitted git changes"
+      end
+
+      def self.details
+        [
+          "A sanity check to make sure you are working in a repo that is clean.",
+          "Especially useful to put at the beginning of your Fastfile in the `before_all` block, if some of your other actions will touch your filesystem, do things to your git repo, or just as a general reminder to save your work.",
+          "Also needed as a prerequisite for some other actions like `reset_git_repo`."
+        ].join("\n")
+      end
+
+      def self.output
+        [
+          ['GIT_REPO_WAS_CLEAN_ON_START', 'Stores the fact that the git repo was clean at some point']
+        ]
+      end
+
+      def self.author
+        ["lmirosevic", "antondomashnev"]
+      end
+
+      def self.example_code
+        [
+          'ensure_git_status_clean'
+        ]
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :show_uncommitted_changes,
+                                       env_name: "FL_ENSURE_GIT_STATUS_CLEAN_SHOW_UNCOMMITTED_CHANGES",
+                                       description: "The flag whether to show uncommitted changes if the repo is dirty",
+                                       optional: true,
+                                       default_value: false,
+                                       type: Boolean),
+          FastlaneCore::ConfigItem.new(key: :show_diff,
+                                       env_name: "FL_ENSURE_GIT_STATUS_CLEAN_SHOW_DIFF",
+                                       description: "The flag whether to show the git diff if the repo is dirty",
+                                       optional: true,
+                                       default_value: false,
+                                       type: Boolean),
+          FastlaneCore::ConfigItem.new(key: :ignored,
+                                       env_name: "FL_ENSURE_GIT_STATUS_CLEAN_IGNORED_FILE",
+                                       description: [
+                                         "The handling mode of the ignored files. The available options are: `'traditional'`, `'none'` (default) and `'matching'`.",
+                                         "Specifying `'none'` to this parameter is the same as not specifying the parameter at all, which means that no ignored file will be used to check if the repo is dirty or not.",
+                                         "Specifying `'traditional'` or `'matching'` causes some ignored files to be used to check if the repo is dirty or not (more info in the official docs: https://git-scm.com/docs/git-status#Documentation/git-status.txt---ignoredltmodegt)"
+                                       ].join(" "),
+                                       optional: true,
+                                       verify_block: proc do |value|
+                                         mode = value.to_s
+                                         modes = %w(traditional none matching)
+
+                                         UI.user_error!("Unsupported mode, must be: #{modes}") unless modes.include?(mode)
+                                       end)
+        ]
+      end
+
+      def self.category
+        :source_control
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/ensure_no_debug_code.rb

@@ -0,0 +1,133 @@
+module Fastlane
+  module Actions
+    class EnsureNoDebugCodeAction < Action
+      def self.run(params)
+        command = "grep -RE '#{params[:text]}' '#{File.absolute_path(params[:path])}'"
+
+        extensions = []
+        extensions << params[:extension] unless params[:extension].nil?
+
+        if params[:extensions]
+          params[:extensions].each do |extension|
+            extension.delete!('.') if extension.include?(".")
+            extensions << extension
+          end
+        end
+
+        if extensions.count > 1
+          command << " --include=\\*.{#{extensions.join(',')}}"
+        elsif extensions.count > 0
+          command << " --include=\\*.#{extensions.join(',')}"
+        end
+
+        command << " --exclude #{params[:exclude]}" if params[:exclude]
+
+        if params[:exclude_dirs]
+          params[:exclude_dirs].each do |dir|
+            command << " --exclude-dir #{dir.shellescape}"
+          end
+        end
+
+        return command if Helper.test?
+
+        UI.important(command)
+        results = `#{command}` # we don't use `sh` as the return code of grep is wrong for some reason
+
+        # Example Output
+        #   ./fastlane.gemspec:  spec.add_development_dependency 'my_word'
+        #   ./Gemfile.lock:    my_word (0.10.1)
+
+        found = []
+        results.split("\n").each do |current_raw|
+          found << current_raw.strip
+        end
+
+        UI.user_error!("Found debug code '#{params[:text]}': \n\n#{found.join("\n")}") if found.count > 0
+        UI.message("No debug code found in code base 🐛")
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Ensures the given text is nowhere in the code base"
+      end
+
+      def self.details
+        [
+          "You don't want any debug code to slip into production.",
+          "This can be used to check if there is any debug code still in your codebase or if you have things like `// TO DO` or similar."
+        ].join("\n")
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :text,
+                                       env_name: "FL_ENSURE_NO_DEBUG_CODE_TEXT",
+                                       description: "The text that must not be in the code base"),
+          FastlaneCore::ConfigItem.new(key: :path,
+                                       env_name: "FL_ENSURE_NO_DEBUG_CODE_PATH",
+                                       description: "The directory containing all the source files",
+                                       default_value: ".",
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Couldn't find the folder at '#{File.absolute_path(value)}'") unless File.directory?(value)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :extension,
+                                       env_name: "FL_ENSURE_NO_DEBUG_CODE_EXTENSION",
+                                       description: "The extension that should be searched for",
+                                       optional: true,
+                                       verify_block: proc do |value|
+                                         value.delete!('.') if value.include?(".")
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :extensions,
+                                       env_name: "FL_ENSURE_NO_DEBUG_CODE_EXTENSIONS",
+                                       description: "An array of file extensions that should be searched for",
+                                       optional: true,
+                                       type: Array),
+          FastlaneCore::ConfigItem.new(key: :exclude,
+                                       env_name: "FL_ENSURE_NO_DEBUG_CODE_EXCLUDE",
+                                       description: "Exclude a certain pattern from the search",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :exclude_dirs,
+                                       env_name: "FL_ENSURE_NO_DEBUG_CODE_EXCLUDE_DIRS",
+                                       description: "An array of dirs that should not be included in the search",
+                                       optional: true,
+                                       type: Array)
+        ]
+      end
+
+      def self.output
+        []
+      end
+
+      def self.authors
+        ["KrauseFx"]
+      end
+
+      def self.example_code
+        [
+          'ensure_no_debug_code(text: "// TODO")',
+          'ensure_no_debug_code(text: "Log.v",
+                          extension: "java")',
+          'ensure_no_debug_code(text: "NSLog",
+                               path: "./lib",
+                          extension: "m")',
+          'ensure_no_debug_code(text: "(^#define DEBUG|NSLog)",
+                               path: "./lib",
+                          extension: "m")',
+          'ensure_no_debug_code(text: "<<<<<<",
+                         extensions: ["m", "swift", "java"])'
+        ]
+      end
+
+      def self.category
+        :misc
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/ensure_xcode_version.rb

@@ -0,0 +1,124 @@
+module Fastlane
+  module Actions
+    class EnsureXcodeVersionAction < Action
+      def self.run(params)
+        Actions.verify_gem!('xcode-install')
+        required_version = params[:version]
+        strict = params[:strict]
+
+        if required_version.to_s.length == 0
+          # The user didn't provide an Xcode version, let's see
+          # if the current project has a `.xcode-version` file
+          #
+          # The code below can be improved to also consider
+          # the directory of the Xcode project
+          xcode_version_paths = Dir.glob(".xcode-version")
+
+          if xcode_version_paths.first
+            UI.verbose("Loading required version from #{xcode_version_paths.first}")
+            required_version = File.read(xcode_version_paths.first).strip
+          else
+            UI.user_error!("No version: provided when calling the `ensure_xcode_version` action")
+          end
+        end
+
+        selected_version = sh("xcversion selected").match(/^Xcode (.*)$/)[1]
+
+        begin
+          selected_version = Gem::Version.new(selected_version)
+          required_version = Gem::Version.new(required_version)
+        rescue ArgumentError => ex
+          UI.user_error!("Invalid version number provided, make sure it's valid: #{ex}")
+        end
+
+        if strict == true
+          if selected_version == required_version
+            success(selected_version)
+          else
+            error(selected_version, required_version)
+          end
+        else
+          required_version_numbers = required_version.to_s.split(".")
+          selected_version_numbers = selected_version.to_s.split(".")
+
+          required_version_numbers.each_with_index do |required_version_number, index|
+            selected_version_number = selected_version_numbers[index]
+            next unless required_version_number != selected_version_number
+            error(selected_version, required_version)
+            break
+          end
+
+          success(selected_version)
+        end
+      end
+
+      def self.success(selected_version)
+        UI.success("Selected Xcode version is correct: #{selected_version}")
+      end
+
+      def self.error(selected_version, required_version)
+        UI.message("Selected Xcode version is not correct: #{selected_version}. You expected #{required_version}.")
+        UI.message("To correct this, use: `xcode_select(version: #{required_version})`.")
+
+        UI.user_error!("Selected Xcode version doesn't match your requirement.\nExpected: Xcode #{required_version}\nActual: Xcode #{selected_version}\n")
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Ensure the right version of Xcode is used"
+      end
+
+      def self.details
+        [
+          "If building your app requires a specific version of Xcode, you can invoke this command before using gym.",
+          "For example, to ensure that a beta version of Xcode is not accidentally selected to build, which would make uploading to TestFlight fail.",
+          "You can either manually provide a specific version using `version:` or you make use of the `.xcode-version` file.",
+          "Using the `strict` parameter, you can either verify the full set of version numbers strictly (i.e. `11.3.1`) or only a subset of them (i.e. `11.3` or `11`)."
+        ].join("\n")
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :version,
+                                       env_name: "FL_ENSURE_XCODE_VERSION",
+                                       description: "Xcode version to verify that is selected",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :strict,
+                                       description: "Should the version be verified strictly (all 3 version numbers), or matching only the given version numbers (i.e. `11.3` == `11.3.x`)",
+                                       type: Boolean,
+                                       default_value: true)
+        ]
+      end
+
+      def self.output
+        [
+          ['FL_ENSURE_XCODE_VERSION', 'Xcode version to verify that is selected']
+        ]
+      end
+
+      def self.return_value
+      end
+
+      def self.authors
+        ["JaviSoto", "KrauseFx"]
+      end
+
+      def self.example_code
+        [
+          'ensure_xcode_version(version: "12.5")'
+        ]
+      end
+
+      def self.category
+        :building
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include?(platform)
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/environment_variable.rb

@@ -0,0 +1,69 @@
+module Fastlane
+  module Actions
+    class EnvironmentVariableAction < Action
+      def self.run(params)
+        values_to_set = params[:set]
+        value_to_get = params[:get]
+        value_to_remove = params[:remove]
+
+        # clear out variables that were removed
+        ENV[value_to_remove] = nil unless value_to_remove.nil?
+
+        # if we have to set variables, do that now
+        unless values_to_set.nil?
+          values_to_set.each do |key, value|
+            ENV[key] = value
+          end
+        end
+
+        # finally, get the variable we requested
+        return ENV[value_to_get] unless value_to_get.nil?
+
+        # if no variable is requested, just return empty string
+        return ""
+      end
+
+      def self.author
+        "taquitos"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :set,
+                                       env_name: 'FL_ENVIRONMENT_VARIABLE_SET',
+                                       description: 'Set the environment variables named',
+                                       optional: true,
+                                       type: Hash),
+          FastlaneCore::ConfigItem.new(key: :get,
+                                       env_name: 'FL_ENVIRONMENT_VARIABLE_GET',
+                                       description: 'Get the environment variable named',
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :remove,
+                                       env_name: 'FL_ENVIRONMENT_VARIABLE_REMOVE',
+                                       description: 'Remove the environment variable named',
+                                       optional: true)
+        ]
+      end
+
+      def self.description
+        "Sets/gets env vars for Fastlane.swift. Don't use in ruby, use `ENV[key] = val`"
+      end
+
+      def self.step_text
+        nil
+      end
+
+      def self.category
+        :misc
+      end
+
+      def self.return_type
+        :string
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+    end
+  end
+end