fastlane_pricing_fix 2.212.1

data/fastlane/lib/fastlane/actions/prompt.rb

@@ -0,0 +1,118 @@
+module Fastlane
+  module Actions
+    class PromptAction < Action
+      def self.run(params)
+        if params[:boolean]
+          return params[:ci_input] unless UI.interactive?
+          return UI.confirm(params[:text])
+        end
+
+        UI.message(params[:text])
+
+        return params[:ci_input] unless UI.interactive?
+
+        if params[:multi_line_end_keyword]
+          # Multi line
+          end_tag = params[:multi_line_end_keyword]
+          UI.important("Submit inputs using \"#{params[:multi_line_end_keyword]}\"")
+          user_input = ""
+          loop do
+            line = STDIN.gets # returns `nil` if called at end of file
+            break unless line
+            end_tag_index = line.index(end_tag)
+            if end_tag_index.nil?
+              user_input << line
+            else
+              user_input << line.slice(0, end_tag_index)
+              user_input = user_input.strip
+              break
+            end
+          end
+        else
+          # Standard one line input
+          if params[:secure_text]
+            user_input = STDIN.noecho(&:gets).chomp while (user_input || "").length == 0
+          else
+            user_input = STDIN.gets.chomp.strip while (user_input || "").length == 0
+          end
+        end
+
+        return user_input
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Ask the user for a value or for confirmation"
+      end
+
+      def self.details
+        [
+          "You can use `prompt` to ask the user for a value or to just let the user confirm the next step.",
+          "When this is executed on a CI service, the passed `ci_input` value will be returned.",
+          "This action also supports multi-line inputs using the `multi_line_end_keyword` option."
+        ].join("\n")
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :text,
+                                       description: "The text that will be displayed to the user",
+                                       default_value: "Please enter some text: "),
+          FastlaneCore::ConfigItem.new(key: :ci_input,
+                                       description: "The default text that will be used when being executed on a CI service",
+                                       default_value: ''),
+          FastlaneCore::ConfigItem.new(key: :boolean,
+                                       description: "Is that a boolean question (yes/no)? This will add (y/n) at the end",
+                                       default_value: false,
+                                       type: Boolean),
+          FastlaneCore::ConfigItem.new(key: :secure_text,
+                                       description: "Is that a secure text (yes/no)?",
+                                       default_value: false,
+                                       type: Boolean),
+          FastlaneCore::ConfigItem.new(key: :multi_line_end_keyword,
+                                       description: "Enable multi-line inputs by providing an end text (e.g. 'END') which will stop the user input",
+                                       optional: true)
+        ]
+      end
+
+      def self.output
+        []
+      end
+
+      def self.authors
+        ["KrauseFx"]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.example_code
+        [
+          'changelog = prompt(text: "Changelog: ")',
+          'changelog = prompt(
+            text: "Changelog: ",
+            multi_line_end_keyword: "END"
+          )
+
+          pilot(changelog: changelog)'
+        ]
+      end
+
+      def self.sample_return_value
+        "User Content\nWithNewline"
+      end
+
+      def self.return_type
+        :string
+      end
+
+      def self.category
+        :misc
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/push_git_tags.rb

@@ -0,0 +1,76 @@
+module Fastlane
+  module Actions
+    class PushGitTagsAction < Action
+      def self.run(params)
+        command = [
+          'git',
+          'push',
+          params[:remote]
+        ]
+
+        if params[:tag]
+          command << "refs/tags/#{params[:tag].shellescape}"
+        else
+          command << '--tags'
+        end
+
+        # optionally add the force component
+        command << '--force' if params[:force]
+
+        result = Actions.sh(command.join(' '))
+        UI.success('Tags pushed to remote')
+        result
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Push local tags to the remote - this will only push tags"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :force,
+                                       env_name: "FL_PUSH_GIT_FORCE",
+                                       description: "Force push to remote",
+                                       type: Boolean,
+                                       default_value: false,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :remote,
+                                       env_name: "FL_GIT_PUSH_REMOTE",
+                                       description: "The remote to push tags to",
+                                       default_value: "origin",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :tag,
+                                       env_name: "FL_GIT_PUSH_TAG",
+                                       description: "The tag to push to remote",
+                                       optional: true)
+        ]
+      end
+
+      def self.author
+        ['vittoriom']
+      end
+
+      def self.details
+        "If you only want to push the tags and nothing else, you can use the `push_git_tags` action"
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.example_code
+        [
+          'push_git_tags'
+        ]
+      end
+
+      def self.category
+        :source_control
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/push_to_git_remote.rb

@@ -0,0 +1,138 @@
+module Fastlane
+  module Actions
+    # Push local changes to the remote branch
+    class PushToGitRemoteAction < Action
+      def self.run(params)
+        # Find the local git branch using HEAD or fallback to CI's ENV git branch if you're in detached HEAD state
+        local_git_branch = Actions.git_branch_name_using_HEAD
+        local_git_branch = Actions.git_branch unless local_git_branch && local_git_branch != "HEAD"
+
+        local_branch = params[:local_branch]
+        local_branch ||= local_git_branch.gsub(%r{#{params[:remote]}\/}, '') if local_git_branch
+        UI.user_error!('Failed to get the current branch.') unless local_branch
+
+        remote_branch = params[:remote_branch] || local_branch
+
+        # construct our command as an array of components
+        command = [
+          'git',
+          'push',
+          params[:remote],
+          "#{local_branch.shellescape}:#{remote_branch.shellescape}"
+        ]
+
+        # optionally add the tags component
+        command << '--tags' if params[:tags]
+
+        # optionally add the force component
+        command << '--force' if params[:force]
+
+        # optionally add the force component
+        command << '--force-with-lease' if params[:force_with_lease]
+
+        # optionally add the no-verify component
+        command << '--no-verify' if params[:no_verify]
+
+        # optionally add the set-upstream component
+        command << '--set-upstream' if params[:set_upstream]
+
+        # optionally add the --push_options components
+        params[:push_options].each { |push_option| command << "--push-option=#{push_option}" } if params[:push_options]
+
+        # execute our command
+        return command.join(' ') if Helper.test?
+
+        Actions.sh(command.join(' '))
+        UI.message('Successfully pushed to remote.')
+      end
+
+      def self.description
+        "Push local changes to the remote branch"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :local_branch,
+                                       env_name: "FL_GIT_PUSH_LOCAL_BRANCH",
+                                       description: "The local branch to push from. Defaults to the current branch",
+                                       default_value_dynamic: true,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :remote_branch,
+                                       env_name: "FL_GIT_PUSH_REMOTE_BRANCH",
+                                       description: "The remote branch to push to. Defaults to the local branch",
+                                       default_value_dynamic: true,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :force,
+                                       env_name: "FL_PUSH_GIT_FORCE",
+                                       description: "Force push to remote",
+                                       type: Boolean,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :force_with_lease,
+                                       env_name: "FL_PUSH_GIT_FORCE_WITH_LEASE",
+                                       description: "Force push with lease to remote",
+                                       type: Boolean,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :tags,
+                                       env_name: "FL_PUSH_GIT_TAGS",
+                                       description: "Whether tags are pushed to remote",
+                                       type: Boolean,
+                                       default_value: true),
+          FastlaneCore::ConfigItem.new(key: :remote,
+                                       env_name: "FL_GIT_PUSH_REMOTE",
+                                       description: "The remote to push to",
+                                       default_value: 'origin'),
+          FastlaneCore::ConfigItem.new(key: :no_verify,
+                                       env_name: "FL_GIT_PUSH_USE_NO_VERIFY",
+                                       description: "Whether or not to use --no-verify",
+                                       type: Boolean,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :set_upstream,
+                                       env_name: "FL_GIT_PUSH_USE_SET_UPSTREAM",
+                                       description: "Whether or not to use --set-upstream",
+                                       type: Boolean,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :push_options,
+                                       env_name: "FL_GIT_PUSH_PUSH_OPTION",
+                                       description: "Array of strings to be passed using the '--push-option' option",
+                                       type: Array,
+                                       default_value: [])
+        ]
+      end
+
+      def self.author
+        "lmirosevic"
+      end
+
+      def self.details
+        [
+          "Lets you push your local commits to a remote git repo. Useful if you make local changes such as adding a version bump commit (using `commit_version_bump`) or a git tag (using 'add_git_tag') on a CI server, and you want to push those changes back to your canonical/main repo.",
+          "If this is a new branch, use the `set_upstream` option to set the remote branch as upstream."
+        ].join("\n")
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.example_code
+        [
+          'push_to_git_remote # simple version. pushes "master" branch to "origin" remote',
+          'push_to_git_remote(
+            remote: "origin",         # optional, default: "origin"
+            local_branch: "develop",  # optional, aliased by "branch", default is set to current branch
+            remote_branch: "develop", # optional, default is set to local_branch
+            force: true,              # optional, default: false
+            force_with_lease: true,   # optional, default: false
+            tags: false,              # optional, default: true
+            no_verify: true,          # optional, default: false
+            set_upstream: true        # optional, default: false
+          )'
+        ]
+      end
+
+      def self.category
+        :source_control
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/puts.rb

@@ -0,0 +1,67 @@
+module Fastlane
+  module Actions
+    class PutsAction < Action
+      def self.run(params)
+        # display text from the message param (most likely coming from Swift)
+        # if called like `puts 'hi'` then params won't be a configuration item, so we have to check
+        if params.kind_of?(FastlaneCore::Configuration) && params[:message]
+          UI.message(params[:message])
+          return
+        end
+
+        # no parameter included in the call means treat this like a normal fastlane ruby call
+        UI.message(params.join(' '))
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Prints out the given text"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :message,
+                                       env_name: "FL_PUTS_MESSAGE",
+                                       description: "Message to be printed out",
+                                       optional: true)
+        ]
+      end
+
+      def self.authors
+        ["KrauseFx"]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.alias_used(action_alias, params)
+        if !params.kind_of?(FastlaneCore::Configuration) || params[:message].nil?
+          UI.important("#{action_alias} called, please use 'puts' instead!")
+        end
+      end
+
+      def self.aliases
+        ["println", "echo"]
+      end
+
+      # We don't want to show this as step
+      def self.step_text
+        nil
+      end
+
+      def self.example_code
+        [
+          'puts "Hi there"'
+        ]
+      end
+
+      def self.category
+        :misc
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/read_podspec.rb

@@ -0,0 +1,90 @@
+module Fastlane
+  module Actions
+    module SharedValues
+      READ_PODSPEC_JSON = :READ_PODSPEC_JSON
+    end
+
+    class ReadPodspecAction < Action
+      def self.run(params)
+        Actions.verify_gem!('cocoapods')
+
+        path = params[:path]
+
+        require 'cocoapods-core'
+        spec = Pod::Spec.from_file(path).to_hash
+
+        UI.success("Reading podspec from file #{path}")
+
+        Actions.lane_context[SharedValues::READ_PODSPEC_JSON] = spec
+        return spec
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Loads a CocoaPods spec as JSON"
+      end
+
+      def self.details
+        [
+          "This can be used for only specifying a version string in your podspec - and during your release process you'd read it from the podspec by running `version = read_podspec['version']` at the beginning of your lane.",
+          "Loads the specified (or the first found) podspec in the folder as JSON, so that you can inspect its `version`, `files` etc.",
+          "This can be useful when basing your release process on the version string only stored in one place - in the podspec.",
+          "As one of the first steps you'd read the podspec and its version and the rest of the workflow can use that version string (when e.g. creating a new git tag or a GitHub Release)."
+        ].join("\n")
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :path,
+                                       env_name: "FL_READ_PODSPEC_PATH",
+                                       description: "Path to the podspec to be read",
+                                       default_value: Dir['*.podspec*'].first,
+                                       default_value_dynamic: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("File #{value} not found") unless File.exist?(value)
+                                       end)
+        ]
+      end
+
+      def self.output
+        [
+          ['READ_PODSPEC_JSON', 'Podspec JSON payload']
+        ]
+      end
+
+      def self.authors
+        ["czechboy0"]
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include?(platform)
+      end
+
+      def self.example_code
+        [
+          'spec = read_podspec
+          version = spec["version"]
+          puts "Using Version #{version}"',
+          'spec = read_podspec(path: "./XcodeServerSDK.podspec")'
+        ]
+      end
+
+      def self.sample_return_value
+        {
+          'version' => 1.0
+        }
+      end
+
+      def self.return_type
+        :hash
+      end
+
+      def self.category
+        :misc
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/recreate_schemes.rb

@@ -0,0 +1,46 @@
+module Fastlane
+  module Actions
+    class RecreateSchemesAction < Action
+      def self.run(params)
+        require 'xcodeproj'
+
+        UI.message("Recreate schemes for project: #{params[:project]}")
+
+        project = Xcodeproj::Project.open(params[:project])
+        project.recreate_user_schemes
+      end
+
+      def self.description
+        "Recreate not shared Xcode project schemes"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(
+            key: :project,
+            env_name: "XCODE_PROJECT",
+            description: "The Xcode project"
+          )
+        ]
+      end
+
+      def self.authors
+        "jerolimov"
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include?(platform)
+      end
+
+      def self.example_code
+        [
+          'recreate_schemes(project: "./path/to/MyApp.xcodeproj")'
+        ]
+      end
+
+      def self.category
+        :project
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/register_device.rb

@@ -0,0 +1,148 @@
+require 'credentials_manager'
+
+module Fastlane
+  module Actions
+    class RegisterDeviceAction < Action
+      def self.is_supported?(platform)
+        platform == :ios
+      end
+
+      def self.run(params)
+        require 'spaceship'
+
+        name = params[:name]
+        platform = params[:platform]
+        udid = params[:udid]
+
+        platform = Spaceship::ConnectAPI::BundleIdPlatform.map(platform)
+
+        if (api_token = Spaceship::ConnectAPI::Token.from(hash: params[:api_key], filepath: params[:api_key_path]))
+          UI.message("Creating authorization token for App Store Connect API")
+          Spaceship::ConnectAPI.token = api_token
+        elsif !Spaceship::ConnectAPI.token.nil?
+          UI.message("Using existing authorization token for App Store Connect API")
+        else
+          UI.message("Login to App Store Connect (#{params[:username]})")
+          credentials = CredentialsManager::AccountManager.new(user: params[:username])
+          Spaceship::ConnectAPI.login(credentials.user, credentials.password, use_portal: true, use_tunes: false)
+          UI.message("Login successful")
+        end
+
+        begin
+          Spaceship::ConnectAPI::Device.find_or_create(udid, name: name, platform: platform)
+        rescue => ex
+          UI.error(ex.to_s)
+          UI.crash!("Failed to register new device (name: #{name}, platform: #{platform}, UDID: #{udid})")
+        end
+
+        UI.success("Successfully registered new device")
+        return udid
+      end
+
+      def self.description
+        "Registers a new device to the Apple Dev Portal"
+      end
+
+      def self.available_options
+        user = CredentialsManager::AppfileConfig.try_fetch_value(:apple_dev_portal_id)
+        user ||= CredentialsManager::AppfileConfig.try_fetch_value(:apple_id)
+        platform = Actions.lane_context[Actions::SharedValues::PLATFORM_NAME].to_s
+
+        [
+          FastlaneCore::ConfigItem.new(key: :name,
+                                       env_name: "FL_REGISTER_DEVICE_NAME",
+                                       description: "Provide the name of the device to register as"),
+          FastlaneCore::ConfigItem.new(key: :platform,
+                                       env_name: "FL_REGISTER_DEVICE_PLATFORM",
+                                       description: "Provide the platform of the device to register as (ios, mac)",
+                                       optional: true,
+                                       default_value: platform.empty? ? "ios" : platform,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("The platform can only be ios or mac") unless %('ios', 'mac').include?(value)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :udid,
+                                       env_name: "FL_REGISTER_DEVICE_UDID",
+                                       description: "Provide the UDID of the device to register as"),
+          FastlaneCore::ConfigItem.new(key: :api_key_path,
+                                       env_names: ["FL_REGISTER_DEVICE_API_KEY_PATH", "APP_STORE_CONNECT_API_KEY_PATH"],
+                                       description: "Path to your App Store Connect API Key JSON file (https://docs.fastlane.tools/app-store-connect-api/#using-fastlane-api-key-json-file)",
+                                       optional: true,
+                                       conflicting_options: [:api_key],
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Couldn't find API key JSON file at path '#{value}'") unless File.exist?(value)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :api_key,
+                                       env_names: ["FL_REGISTER_DEVICE_API_KEY", "APP_STORE_CONNECT_API_KEY"],
+                                       description: "Your App Store Connect API Key information (https://docs.fastlane.tools/app-store-connect-api/#using-fastlane-api-key-hash-option)",
+                                       type: Hash,
+                                       default_value: Fastlane::Actions.lane_context[Fastlane::Actions::SharedValues::APP_STORE_CONNECT_API_KEY],
+                                       default_value_dynamic: true,
+                                       optional: true,
+                                       sensitive: true,
+                                       conflicting_options: [:api_key_path]),
+          FastlaneCore::ConfigItem.new(key: :team_id,
+                                     env_name: "REGISTER_DEVICE_TEAM_ID",
+                                     code_gen_sensitive: true,
+                                     default_value: CredentialsManager::AppfileConfig.try_fetch_value(:team_id),
+                                       default_value_dynamic: true,
+                                     description: "The ID of your Developer Portal team if you're in multiple teams",
+                                     optional: true,
+                                     verify_block: proc do |value|
+                                       ENV["FASTLANE_TEAM_ID"] = value.to_s
+                                     end),
+          FastlaneCore::ConfigItem.new(key: :team_name,
+                                       env_name: "REGISTER_DEVICE_TEAM_NAME",
+                                       description: "The name of your Developer Portal team if you're in multiple teams",
+                                       optional: true,
+                                       code_gen_sensitive: true,
+                                       default_value: CredentialsManager::AppfileConfig.try_fetch_value(:team_name),
+                                       default_value_dynamic: true,
+                                       verify_block: proc do |value|
+                                         ENV["FASTLANE_TEAM_NAME"] = value.to_s
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :username,
+                                       env_name: "DELIVER_USER",
+                                       description: "Optional: Your Apple ID",
+                                       optional: true,
+                                       default_value: user,
+                                       default_value_dynamic: true)
+        ]
+      end
+
+      def self.details
+        [
+          "This will register an iOS device with the Developer Portal so that you can include it in your provisioning profiles.",
+          "This is an optimistic action, in that it will only ever add a device to the member center. If the device has already been registered within the member center, it will be left alone in the member center.",
+          "The action will connect to the Apple Developer Portal using the username you specified in your `Appfile` with `apple_id`, but you can override it using the `:username` option."
+        ].join("\n")
+      end
+
+      def self.author
+        "pvinis"
+      end
+
+      def self.example_code
+        [
+          'register_device(
+            name: "Luka iPhone 6",
+            udid: "1234567890123456789012345678901234567890"
+          ) # Simply provide the name and udid of the device',
+          'register_device(
+            name: "Luka iPhone 6",
+            udid: "1234567890123456789012345678901234567890",
+            team_id: "XXXXXXXXXX",         # Optional, if you"re a member of multiple teams, then you need to pass the team ID here.
+            username: "luka@goonbee.com"   # Optional, lets you override the Apple Member Center username.
+          )'
+        ]
+      end
+
+      def self.return_type
+        :string
+      end
+
+      def self.category
+        :code_signing
+      end
+    end
+  end
+end