fastlane-security-patched 2.216.0

data/fastlane/lib/fastlane/actions/get_managed_play_store_publishing_rights.rb

@@ -0,0 +1,117 @@
+module Fastlane
+  module Actions
+    class GetManagedPlayStorePublishingRightsAction < Action
+      def self.run(params)
+        unless params[:json_key] || params[:json_key_data]
+          UI.important("To not be asked about this value, you can specify it using 'json_key'")
+          json_key_path = UI.input("The service account json file used to authenticate with Google: ")
+          json_key_path = File.expand_path(json_key_path)
+
+          UI.user_error!("Could not find service account json file at path '#{json_key_path}'") unless File.exist?(json_key_path)
+          params[:json_key] = json_key_path
+        end
+
+        FastlaneCore::PrintTable.print_values(
+          config: params,
+          mask_keys: [:json_key_data],
+          title: "Summary for get_managed_play_store_publishing_rights"
+        )
+
+        if (keyfile = params[:json_key])
+          json_key_data = File.open(keyfile, 'rb').read
+        else
+          json_key_data = params[:json_key_data]
+        end
+
+        # Login
+        credentials = JSON.parse(json_key_data)
+        callback_uri = 'https://fastlane.github.io/managed_google_play-callback/callback.html'
+        require 'addressable/uri'
+        continueUrl = Addressable::URI.encode(callback_uri)
+        uri = "https://play.google.com/apps/publish/delegatePrivateApp?service_account=#{credentials['client_email']}&continueUrl=#{continueUrl}"
+
+        UI.message("To obtain publishing rights for custom apps on Managed Play Store, open the following URL and log in:")
+        UI.message("")
+        UI.important(uri)
+        UI.message("([Cmd/Ctrl] + [Left click] lets you open this URL in many consoles/terminals/shells)")
+        UI.message("")
+        UI.message("After successful login you will be redirected to a page which outputs some information that is required for usage of the `create_app_on_managed_play_store` action.")
+
+        return uri
+      end
+
+      def self.description
+        "Obtain publishing rights for custom apps on Managed Google Play Store"
+      end
+
+      def self.authors
+        ["janpio"]
+      end
+
+      def self.return_value
+        "An URI to obtain publishing rights for custom apps on Managed Play Store"
+      end
+
+      def self.details
+        [
+          'If you haven\'t done so before, start by following the first two steps of Googles ["Get started with custom app publishing"](https://developers.google.com/android/work/play/custom-app-api/get-started) -> ["Preliminary setup"](https://developers.google.com/android/work/play/custom-app-api/get-started#preliminary_setup) instructions:',
+          '"[Enable the Google Play Custom App Publishing API](https://developers.google.com/android/work/play/custom-app-api/get-started#enable_the_google_play_custom_app_publishing_api)" and "[Create a service account](https://developers.google.com/android/work/play/custom-app-api/get-started#create_a_service_account)".',
+          'You need the "service account\'s private key file" to continue.',
+          'Run the action and supply the "private key file" to it as the `json_key` parameter. The command will output a URL to visit. After logging in you are redirected to a page that outputs your "Developer Account ID" - take note of that, you will need it to be able to use [`create_app_on_managed_play_store`](https://docs.fastlane.tools/actions/create_app_on_managed_play_store/).'
+        ].join("\n")
+      end
+
+      def self.example_code
+        [
+          'get_managed_play_store_publishing_rights(
+            json_key: "path/to/your/json/key/file"
+          )
+          # it is probably easier to execute this action directly in the command line:
+          # $ fastlane run get_managed_play_store_publishing_rights'
+        ]
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :json_key,
+                                       env_name: "SUPPLY_JSON_KEY",
+                                       short_option: "-j",
+                                       conflicting_options: [:json_key_data],
+                                       optional: true, # optional until it is possible specify either json_key OR json_key_data are required
+                                       description: "The path to a file containing service account JSON, used to authenticate with Google",
+                                       code_gen_sensitive: true,
+                                       default_value: CredentialsManager::AppfileConfig.try_fetch_value(:json_key_file),
+                                       default_value_dynamic: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Could not find service account json file at path '#{File.expand_path(value)}'") unless File.exist?(File.expand_path(value))
+                                         UI.user_error!("'#{value}' doesn't seem to be a JSON file") unless FastlaneCore::Helper.json_file?(File.expand_path(value))
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :json_key_data,
+                                       env_name: "SUPPLY_JSON_KEY_DATA",
+                                       short_option: "-c",
+                                       conflicting_options: [:json_key],
+                                       optional: true,
+                                       description: "The raw service account JSON data used to authenticate with Google",
+                                       code_gen_sensitive: true,
+                                       default_value: CredentialsManager::AppfileConfig.try_fetch_value(:json_key_data_raw),
+                                       default_value_dynamic: true,
+                                       verify_block: proc do |value|
+                                         begin
+                                           JSON.parse(value)
+                                         rescue JSON::ParserError
+                                           UI.user_error!("Could not parse service account json: JSON::ParseError")
+                                         end
+                                       end)
+        ]
+      end
+
+      def self.is_supported?(platform)
+        [:android].include?(platform)
+      end
+
+      def self.category
+        :misc
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/get_provisioning_profile.rb

@@ -0,0 +1,109 @@
+module Fastlane
+  module Actions
+    module SharedValues
+      SIGH_PROFILE_PATH = :SIGH_PROFILE_PATH
+      SIGH_PROFILE_PATHS = :SIGH_PROFILE_PATHS
+      SIGH_UDID = :SIGH_UDID # deprecated
+      SIGH_UUID = :SIGH_UUID
+      SIGH_NAME = :SIGH_NAME
+      SIGH_PROFILE_TYPE ||= :SIGH_PROFILE_TYPE
+    end
+
+    class GetProvisioningProfileAction < Action
+      def self.run(values)
+        require 'sigh'
+        require 'credentials_manager/appfile_config'
+
+        # Only set :api_key from SharedValues if :api_key_path isn't set (conflicting options)
+        unless values[:api_key_path]
+          values[:api_key] ||= Actions.lane_context[SharedValues::APP_STORE_CONNECT_API_KEY]
+        end
+
+        Sigh.config = values # we already have the finished config
+
+        path = Sigh::Manager.start
+
+        Actions.lane_context[SharedValues::SIGH_PROFILE_PATH] = path # absolute path
+        Actions.lane_context[SharedValues::SIGH_PROFILE_PATHS] ||= []
+        Actions.lane_context[SharedValues::SIGH_PROFILE_PATHS] << path
+
+        uuid = ENV["SIGH_UUID"] || ENV["SIGH_UDID"] # the UUID of the profile
+        name = ENV["SIGH_NAME"] # the name of the profile
+        Actions.lane_context[SharedValues::SIGH_UUID] = Actions.lane_context[SharedValues::SIGH_UDID] = uuid if uuid
+        Actions.lane_context[SharedValues::SIGH_NAME] = Actions.lane_context[SharedValues::SIGH_NAME] = name if name
+
+        set_profile_type(values, ENV["SIGH_PROFILE_ENTERPRISE"])
+
+        return uuid # returs uuid of profile
+      end
+
+      def self.set_profile_type(values, enterprise)
+        profile_type = "app-store"
+        profile_type = "ad-hoc" if values[:adhoc]
+        profile_type = "development" if values[:development]
+        profile_type = "developer-id" if values[:developer_id]
+        profile_type = "enterprise" if enterprise
+
+        UI.message("Setting Provisioning Profile type to '#{profile_type}'")
+
+        Actions.lane_context[SharedValues::SIGH_PROFILE_TYPE] = profile_type
+      end
+
+      def self.description
+        "Generates a provisioning profile, saving it in the current folder (via _sigh_)"
+      end
+
+      def self.author
+        "KrauseFx"
+      end
+
+      # rubocop:disable Lint/MissingKeysOnSharedArea
+      def self.output
+        [
+          ['SIGH_PROFILE_PATH', 'A path in which certificates, key and profile are exported'],
+          ['SIGH_PROFILE_PATHS', 'Paths in which certificates, key and profile are exported'],
+          ['SIGH_UUID', 'UUID (Universally Unique IDentifier) of a provisioning profile'],
+          ['SIGH_NAME', 'The name of the profile'],
+          ['SIGH_PROFILE_TYPE', 'The profile type, can be app-store, ad-hoc, development, enterprise, developer-id, can be used in `build_app` as a default value for `export_method`']
+        ]
+      end
+
+      def self.return_value
+        "The UUID of the profile sigh just fetched/generated"
+      end
+
+      def self.return_type
+        :string
+      end
+
+      def self.details
+        "**Note**: It is recommended to use [match](https://docs.fastlane.tools/actions/match/) according to the [codesigning.guide](https://codesigning.guide) for generating and maintaining your provisioning profiles. Use _sigh_ directly only if you want full control over what's going on and know more about codesigning."
+      end
+
+      def self.available_options
+        require 'sigh'
+        Sigh::Options.available_options
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include?(platform)
+      end
+
+      def self.example_code
+        [
+          'get_provisioning_profile',
+          'sigh # alias for "get_provisioning_profile"',
+          'get_provisioning_profile(
+            adhoc: true,
+            force: true,
+            filename: "myFile.mobileprovision"
+          )'
+        ]
+      end
+
+      def self.category
+        :code_signing
+      end
+    end
+  end
+end

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. If `FL_GIT_BRANCH_DONT_USE_ENV_VARS` is `true`, it'll ignore CI ENV vars. 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