fastlane_pricing_fix 2.212.1

data/fastlane/lib/fastlane/actions/get_push_certificate.rb

@@ -0,0 +1,87 @@
+module Fastlane
+  module Actions
+    class GetPushCertificateAction < Action
+      def self.run(params)
+        require 'pem'
+        require 'pem/options'
+        require 'pem/manager'
+
+        success_block = params[:new_profile]
+
+        PEM.config = params
+
+        if Helper.test?
+          profile_path = './test.pem'
+        else
+          profile_path = PEM::Manager.start
+        end
+
+        if success_block && profile_path
+          success_block.call(File.expand_path(profile_path)) if success_block
+        end
+      end
+
+      def self.description
+        "Ensure a valid push profile is active, creating a new one if needed (via _pem_)"
+      end
+
+      def self.author
+        "KrauseFx"
+      end
+
+      def self.details
+        sample = <<-SAMPLE.markdown_sample
+          ```ruby
+          get_push_certificate(
+            new_profile: proc do
+              # your upload code
+            end
+          )
+          ```
+        SAMPLE
+
+        [
+          "Additionally to the available options, you can also specify a block that only gets executed if a new profile was created. You can use it to upload the new profile to your server.",
+          "Use it like this:".markdown_preserve_newlines,
+          sample
+        ].join("\n")
+      end
+
+      def self.available_options
+        require 'pem'
+        require 'pem/options'
+
+        @options = PEM::Options.available_options
+        @options << FastlaneCore::ConfigItem.new(key: :new_profile,
+                                     description: "Block that is called if there is a new profile",
+                                     optional: true,
+                                     type: :string_callback)
+        @options
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include?(platform)
+      end
+
+      def self.example_code
+        [
+          'get_push_certificate',
+          'pem # alias for "get_push_certificate"',
+          'get_push_certificate(
+            force: true, # create a new profile, even if the old one is still valid
+            app_identifier: "net.sunapps.9", # optional app identifier,
+            save_private_key: true,
+            new_profile: proc do |profile_path| # this block gets called when a new profile was generated
+              puts profile_path # the absolute path to the new PEM file
+              # insert the code to upload the PEM file to the server
+            end
+          )'
+        ]
+      end
+
+      def self.category
+        :push
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/get_version_number.rb

@@ -0,0 +1,212 @@
+module Fastlane
+  module Actions
+    module SharedValues
+      VERSION_NUMBER ||= :VERSION_NUMBER # originally defined in IncrementVersionNumberAction
+    end
+
+    class GetVersionNumberAction < Action
+      require 'shellwords'
+
+      def self.run(params)
+        xcodeproj_path_or_dir = params[:xcodeproj] || '.'
+        xcodeproj_dir = File.extname(xcodeproj_path_or_dir) == ".xcodeproj" ? File.dirname(xcodeproj_path_or_dir) : xcodeproj_path_or_dir
+        target_name = params[:target]
+        configuration = params[:configuration]
+
+        # Get version_number
+        project = get_project!(xcodeproj_path_or_dir)
+        target = get_target!(project, target_name)
+        plist_file = get_plist!(xcodeproj_dir, target, configuration)
+        version_number = get_version_number_from_plist!(plist_file)
+
+        # Get from build settings (or project settings) if needed (ex: $(MARKETING_VERSION) is default in Xcode 11)
+        if version_number =~ /\$\(([\w\-]+)\)/
+          version_number = get_version_number_from_build_settings!(target, $1, configuration) || get_version_number_from_build_settings!(project, $1, configuration)
+
+        # ${MARKETING_VERSION} also works
+        elsif version_number =~ /\$\{([\w\-]+)\}/
+          version_number = get_version_number_from_build_settings!(target, $1, configuration) || get_version_number_from_build_settings!(project, $1, configuration)
+        end
+
+        # Error out if version_number is not set
+        if version_number.nil?
+          UI.user_error!("Unable to find Xcode build setting: #{$1}")
+        end
+
+        # Store the number in the shared hash
+        Actions.lane_context[SharedValues::VERSION_NUMBER] = version_number
+
+        # Return the version number because Swift might need this return value
+        return version_number
+      end
+
+      def self.get_project!(xcodeproj_path_or_dir)
+        require 'xcodeproj'
+        if File.extname(xcodeproj_path_or_dir) == ".xcodeproj"
+          project_path = xcodeproj_path_or_dir
+        else
+          project_path = Dir.glob("#{xcodeproj_path_or_dir}/*.xcodeproj").first
+        end
+
+        if project_path && File.exist?(project_path)
+          return Xcodeproj::Project.open(project_path)
+        else
+          UI.user_error!("Unable to find Xcode project at #{project_path || xcodeproj_path_or_dir}")
+        end
+      end
+
+      def self.get_target!(project, target_name)
+        targets = project.targets
+
+        # Prompt targets if no name
+        unless target_name
+
+          # Gets non-test targets
+          non_test_targets = targets.reject do |t|
+            # Not all targets respond to `test_target_type?`
+            t.respond_to?(:test_target_type?) && t.test_target_type?
+          end
+
+          # Returns if only one non-test target
+          if non_test_targets.count == 1
+            return targets.first
+          end
+
+          options = targets.map(&:name)
+          target_name = UI.select("What target would you like to use?", options)
+        end
+
+        # Find target
+        target = targets.find do |t|
+          t.name == target_name
+        end
+        UI.user_error!("Cannot find target named '#{target_name}'") unless target
+
+        target
+      end
+
+      def self.get_version_number_from_build_settings!(target, variable, configuration = nil)
+        target.build_configurations.each do |config|
+          if configuration.nil? || config.name == configuration
+            value = config.resolve_build_setting(variable)
+            return value if value
+          end
+        end
+
+        return nil
+      end
+
+      def self.get_plist!(folder, target, configuration = nil)
+        plist_files = target.resolved_build_setting("INFOPLIST_FILE", true)
+        plist_files_count = plist_files.values.compact.uniq.count
+
+        # Get plist file for specified configuration
+        # Or: Prompt for configuration if plist has different files in each configurations
+        # Else: Get first(only) plist value
+        if configuration
+          plist_file = plist_files[configuration]
+        elsif plist_files_count > 1
+          options = plist_files.keys
+          selected = UI.select("What build configuration would you like to use?", options)
+          plist_file = plist_files[selected]
+        elsif plist_files_count > 0
+          plist_file = plist_files.values.first
+        else
+          return nil
+        end
+
+        # $(SRCROOT) is the path of where the XcodeProject is
+        # We can just set this as empty string since we join with `folder` below
+        if plist_file.include?("$(SRCROOT)/")
+          plist_file.gsub!("$(SRCROOT)/", "")
+        end
+
+        # plist_file can be `Relative` or `Absolute` path.
+        # Make to `Absolute` path when plist_file is `Relative` path
+        unless File.exist?(plist_file)
+          plist_file = File.absolute_path(File.join(folder, plist_file))
+        end
+
+        UI.user_error!("Cannot find plist file: #{plist_file}") unless File.exist?(plist_file)
+
+        plist_file
+      end
+
+      def self.get_version_number_from_plist!(plist_file)
+        return '$(MARKETING_VERSION)' if plist_file.nil?
+
+        plist = Xcodeproj::Plist.read_from_path(plist_file)
+        UI.user_error!("Unable to read plist: #{plist_file}") unless plist
+
+        return '${MARKETING_VERSION}' if plist["CFBundleShortVersionString"].nil?
+        plist["CFBundleShortVersionString"]
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Get the version number of your project"
+      end
+
+      def self.details
+        "This action will return the current version number set on your project. It first looks in the plist and then for '$(MARKETING_VERSION)' in the build settings."
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :xcodeproj,
+                             env_name: "FL_VERSION_NUMBER_PROJECT",
+                             description: "Path to the Xcode project to read version number from, or its containing directory, optional. If omitted, or if a directory is passed instead, it will use the first Xcode project found within the given directory, or the project root directory if none is passed",
+                             optional: true,
+                             verify_block: proc do |value|
+                               UI.user_error!("Please pass the path to the project or its containing directory, not the workspace path") if value.end_with?(".xcworkspace")
+                               UI.user_error!("Could not find file or directory at path '#{File.expand_path(value)}'") unless File.exist?(value)
+                               UI.user_error!("Could not find Xcode project in directory at path '#{File.expand_path(value)}'") if File.extname(value) != ".xcodeproj" && Dir.glob("#{value}/*.xcodeproj").empty?
+                             end),
+          FastlaneCore::ConfigItem.new(key: :target,
+                             env_name: "FL_VERSION_NUMBER_TARGET",
+                             description: "Target name, optional. Will be needed if you have more than one non-test target to avoid being prompted to select one",
+                             optional: true),
+          FastlaneCore::ConfigItem.new(key: :configuration,
+                             env_name: "FL_VERSION_NUMBER_CONFIGURATION",
+                             description: "Configuration name, optional. Will be needed if you have altered the configurations from the default or your version number depends on the configuration selected",
+                             optional: true)
+        ]
+      end
+
+      def self.output
+        [
+          ['VERSION_NUMBER', 'The version number']
+        ]
+      end
+
+      def self.authors
+        ["Liquidsoul", "joshdholtz"]
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include?(platform)
+      end
+
+      def self.example_code
+        [
+          'version = get_version_number(xcodeproj: "Project.xcodeproj")',
+          'version = get_version_number(
+            xcodeproj: "Project.xcodeproj",
+            target: "App"
+          )'
+        ]
+      end
+
+      def self.return_type
+        :string
+      end
+
+      def self.category
+        :project
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/git_add.rb

@@ -0,0 +1,88 @@
+module Fastlane
+  module Actions
+    class GitAddAction < Action
+      def self.run(params)
+        should_escape = params[:shell_escape]
+
+        if params[:pathspec]
+          paths = params[:pathspec]
+          success_message = "Successfully added from \"#{paths}\" 💾."
+        elsif params[:path]
+          paths = params[:path].map do |p|
+            shell_escape(p, should_escape)
+          end.join(' ')
+          success_message = "Successfully added \"#{paths}\" 💾."
+        else
+          paths = "."
+          success_message = "Successfully added all files 💾."
+        end
+
+        result = Actions.sh("git add #{paths}", log: FastlaneCore::Globals.verbose?).chomp
+        UI.success(success_message)
+        return result
+      end
+
+      def self.shell_escape(path, should_escape)
+        path = path.shellescape if should_escape
+        path
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Directly add the given file or all files"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :path,
+                                       description: "The file(s) and path(s) you want to add",
+                                       type: Array,
+                                       conflicting_options: [:pathspec],
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :shell_escape,
+                                       description: "Shell escapes paths (set to false if using wildcards or manually escaping spaces in :path)",
+                                       type: Boolean,
+                                       default_value: true,
+                                       optional: true),
+          # Deprecated
+          FastlaneCore::ConfigItem.new(key: :pathspec,
+                                       description: "The pathspec you want to add files from",
+                                       conflicting_options: [:path],
+                                       optional: true,
+                                       deprecated: "Use `--path` instead")
+        ]
+      end
+
+      def self.return_value
+        nil
+      end
+
+      def self.authors
+        ["4brunu", "antondomashnev"]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.example_code
+        [
+          'git_add',
+          'git_add(path: "./version.txt")',
+          'git_add(path: ["./version.txt", "./changelog.txt"])',
+          'git_add(path: "./Frameworks/*", shell_escape: false)',
+          'git_add(path: ["*.h", "*.m"], shell_escape: false)',
+          'git_add(path: "./Frameworks/*", shell_escape: false)',
+          'git_add(path: "*.txt", shell_escape: false)'
+        ]
+      end
+
+      def self.category
+        :source_control
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/git_branch.rb

@@ -0,0 +1,55 @@
+module Fastlane
+  module Actions
+    class GitBranchAction < Action
+      def self.run(params)
+        branch = Actions.git_branch || ""
+        return "" if branch == "HEAD" # Backwards compatibility with the original (and documented) implementation
+        branch
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Returns the name of the current git branch, possibly as managed by CI ENV vars"
+      end
+
+      def self.details
+        "If no branch could be found, this action will return an empty string. This is a wrapper for the internal action Actions.git_branch"
+      end
+
+      def self.available_options
+        []
+      end
+
+      def self.output
+        [
+          ['GIT_BRANCH_ENV_VARS', 'The git branch environment variables']
+        ]
+      end
+
+      def self.authors
+        ["KrauseFx"]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.example_code
+        [
+          'git_branch'
+        ]
+      end
+
+      def self.return_type
+        :string
+      end
+
+      def self.category
+        :source_control
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/git_commit.rb

@@ -0,0 +1,80 @@
+module Fastlane
+  module Actions
+    class GitCommitAction < Action
+      def self.run(params)
+        paths = params[:path]
+        skip_git_hooks = params[:skip_git_hooks] ? ['--no-verify'] : []
+
+        if params[:allow_nothing_to_commit]
+          # Here we check if the path passed in parameter contains any modification
+          # and we skip the `git commit` command if there is none.
+          # That means you can have other files modified that are not in the path parameter
+          # and still make use of allow_nothing_to_commit.
+          repo_clean = Actions.sh('git', 'status', *paths, '--porcelain').empty?
+          UI.success("Nothing to commit, working tree clean ✅.") if repo_clean
+          return if repo_clean
+        end
+
+        result = Actions.sh('git', 'commit', '-m', params[:message], *paths, *skip_git_hooks)
+        UI.success("Successfully committed \"#{params[:path]}\" 💾.")
+        return result
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Directly commit the given file with the given message"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :path,
+                                       description: "The file(s) or directory(ies) you want to commit. You can pass an array of multiple file-paths or fileglobs \"*.txt\" to commit all matching files. The files already staged but not specified and untracked files won't be committed",
+                                       type: Array),
+          FastlaneCore::ConfigItem.new(key: :message,
+                                       description: "The commit message that should be used"),
+          FastlaneCore::ConfigItem.new(key: :skip_git_hooks,
+                                       description: "Set to true to pass `--no-verify` to git",
+                                       default_value: false,
+                                       type: Boolean,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :allow_nothing_to_commit,
+                                       description: "Set to true to allow commit without any git changes in the files you want to commit",
+                                       default_value: false,
+                                       type: Boolean,
+                                       optional: true)
+        ]
+      end
+
+      def self.output
+      end
+
+      def self.return_value
+        nil
+      end
+
+      def self.authors
+        ["KrauseFx"]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.example_code
+        [
+          'git_commit(path: "./version.txt", message: "Version Bump")',
+          'git_commit(path: ["./version.txt", "./changelog.txt"], message: "Version Bump")',
+          'git_commit(path: ["./*.txt", "./*.md"], message: "Update documentation")',
+          'git_commit(path: ["./*.txt", "./*.md"], message: "Update documentation", skip_git_hooks: true)'
+        ]
+      end
+
+      def self.category
+        :source_control
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/git_pull.rb

@@ -0,0 +1,58 @@
+module Fastlane
+  module Actions
+    class GitPullAction < Action
+      def self.run(params)
+        commands = []
+
+        unless params[:only_tags]
+          command = "git pull"
+          command << " --rebase" if params[:rebase]
+          commands += ["#{command} &&"]
+        end
+
+        commands += ["git fetch --tags"]
+
+        Actions.sh(commands.join(' '))
+      end
+
+      def self.description
+        "Executes a simple git pull command"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :only_tags,
+                                       description: "Simply pull the tags, and not bring new commits to the current branch from the remote",
+                                       type: Boolean,
+                                       optional: true,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :rebase,
+                                       description: "Rebase on top of the remote branch instead of merge",
+                                       type: Boolean,
+                                       optional: true,
+                                       default_value: false)
+        ]
+      end
+
+      def self.authors
+        ["KrauseFx", "JaviSoto"]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.example_code
+        [
+          'git_pull',
+          'git_pull(only_tags: true) # only the tags, no commits',
+          'git_pull(rebase: true) # use --rebase with pull'
+        ]
+      end
+
+      def self.category
+        :source_control
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/git_remote_branch.rb

@@ -0,0 +1,57 @@
+module Fastlane
+  module Actions
+    class GitRemoteBranchAction < Action
+      def self.run(params)
+        Actions.git_remote_branch_name(params[:remote_name])
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Returns the name of the current git remote default branch"
+      end
+
+      def self.details
+        "If no default remote branch could be found, this action will return nil. This is a wrapper for the internal action Actions.git_default_remote_branch_name"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :remote_name,
+                                       env_name: "FL_REMOTE_REPOSITORY_NAME",
+                                       description: "The remote repository to check",
+                                       optional: true)
+        ]
+      end
+
+      def self.output
+        []
+      end
+
+      def self.authors
+        ["SeanMcNeil"]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.example_code
+        [
+          'git_remote_branch # Query git for first available remote name',
+          'git_remote_branch(remote_name:"upstream") # Provide a remote name'
+        ]
+      end
+
+      def self.return_type
+        :string
+      end
+
+      def self.category
+        :source_control
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/git_submodule_update.rb

@@ -0,0 +1,60 @@
+module Fastlane
+  module Actions
+    class GitSubmoduleUpdateAction < Action
+      def self.run(params)
+        commands = ["git submodule update"]
+        commands += ["--init"] if params[:init]
+        commands += ["--recursive"] if params[:recursive]
+        Actions.sh(commands.join(' '))
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Executes a git submodule update command"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :recursive,
+                                       description: "Should the submodules be updated recursively?",
+                                       type: Boolean,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :init,
+                                       description: "Should the submodules be initiated before update?",
+                                       type: Boolean,
+                                       default_value: false)
+        ]
+      end
+
+      def self.output
+      end
+
+      def self.return_value
+      end
+
+      def self.authors
+        ["braunico"]
+      end
+
+      def self.is_supported?(platform)
+        return true
+      end
+
+      def self.example_code
+        [
+          'git_submodule_update',
+          'git_submodule_update(recursive: true)',
+          'git_submodule_update(init: true)',
+          'git_submodule_update(recursive: true, init: true)'
+        ]
+      end
+
+      def self.category
+        :source_control
+      end
+    end
+  end
+end