fastlane_hotfix 2.187.0

data/fastlane/lib/fastlane/actions/appstore.rb

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

data/fastlane/lib/fastlane/actions/apteligent.rb

@@ -0,0 +1,106 @@
+module Fastlane
+  module Actions
+    class ApteligentAction < Action
+      def self.run(params)
+        command = []
+        command << "curl"
+        command += upload_options(params)
+        command << upload_url(params[:app_id].shellescape)
+
+        # Fastlane::Actions.sh has buffering issues, no progress bar is shown in real time
+        # will reanable it when it is fixed
+        # result = Fastlane::Actions.sh(command.join(' '), log: false)
+        shell_command = command.join(' ')
+        return shell_command if Helper.test?
+        result = Actions.sh(shell_command)
+        fail_on_error(result)
+      end
+
+      def self.fail_on_error(result)
+        if result != "200"
+          UI.crash!("Server error, failed to upload the dSYM file.")
+        else
+          UI.success('dSYM successfully uploaded to Apteligent!')
+        end
+      end
+
+      def self.upload_url(app_id)
+        "https://api.crittercism.com/api_beta/dsym/#{app_id}"
+      end
+
+      def self.dsym_path(params)
+        file_path = params[:dsym]
+        file_path ||= Actions.lane_context[SharedValues::DSYM_OUTPUT_PATH] || ENV[SharedValues::DSYM_OUTPUT_PATH.to_s]
+        file_path ||= Actions.lane_context[SharedValues::DSYM_ZIP_PATH] || ENV[SharedValues::DSYM_ZIP_PATH.to_s]
+
+        if file_path
+          expanded_file_path = File.expand_path(file_path)
+          UI.user_error!("Couldn't find file at path '#{expanded_file_path}'") unless File.exist?(expanded_file_path)
+          return expanded_file_path
+        else
+          UI.user_error!("Couldn't find dSYM file")
+        end
+      end
+
+      def self.upload_options(params)
+        file_path = dsym_path(params).shellescape
+
+        # rubocop: disable Style/FormatStringToken
+        options = []
+        options << "--write-out %{http_code} --silent --output /dev/null"
+        options << "-F dsym=@#{file_path}"
+        options << "-F key=#{params[:api_key].shellescape}"
+        options
+        # rubocop: enable Style/FormatStringToken
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Upload dSYM file to [Apteligent (Crittercism)](http://www.apteligent.com/)"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :dsym,
+                                       env_name: "FL_APTELIGENT_FILE",
+                                       description: "dSYM.zip file to upload to Apteligent",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :app_id,
+                                       env_name: "FL_APTELIGENT_APP_ID",
+                                       description: "Apteligent App ID key e.g. 569f5c87cb99e10e00c7xxxx",
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :api_key,
+                                       env_name: "FL_APTELIGENT_API_KEY",
+                                       sensitive: true,
+                                       code_gen_sensitive: true,
+                                       description: "Apteligent App API key e.g. IXPQIi8yCbHaLliqzRoo065tH0lxxxxx",
+                                       optional: false)
+        ]
+      end
+
+      def self.authors
+        ["Mo7amedFouad"]
+      end
+
+      def self.is_supported?(platform)
+        platform == :ios
+      end
+
+      def self.example_code
+        [
+          'apteligent(
+            app_id: "...",
+            api_key: "..."
+          )'
+        ]
+      end
+
+      def self.category
+        :beta
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/artifactory.rb

@@ -0,0 +1,189 @@
+module Fastlane
+  module Actions
+    module SharedValues
+      ARTIFACTORY_DOWNLOAD_URL = :ARTIFACTORY_DOWNLOAD_URL
+      ARTIFACTORY_DOWNLOAD_SIZE = :ARTIFACTORY_DOWNLOAD_SIZE
+    end
+
+    class ArtifactoryAction < Action
+      def self.run(params)
+        Actions.verify_gem!('artifactory')
+
+        require 'artifactory'
+
+        UI.user_error!("Cannot connect to Artifactory - 'username' was provided but it's missing 'password'") if params[:username] && !params[:password]
+        UI.user_error!("Cannot connect to Artifactory - 'password' was provided but it's missing 'username'") if !params[:username] && params[:password]
+        UI.user_error!("Cannot connect to Artifactory - either 'api_key', or 'username' and 'password' must be provided") if !params[:api_key] && !params[:username]
+        file_path = File.absolute_path(params[:file])
+
+        if File.exist?(file_path)
+          client = connect_to_artifactory(params)
+          artifact = Artifactory::Resource::Artifact.new
+          artifact.client = client
+          artifact.local_path = file_path
+          artifact.checksums = {
+              "sha1" => Digest::SHA1.file(file_path),
+              "md5" => Digest::MD5.file(file_path)
+          }
+          UI.message("Uploading file: #{artifact.local_path} ...")
+          upload = artifact.upload(params[:repo], params[:repo_path], params[:properties])
+
+          Actions.lane_context[SharedValues::ARTIFACTORY_DOWNLOAD_URL] = upload.uri
+          Actions.lane_context[SharedValues::ARTIFACTORY_DOWNLOAD_SIZE] = upload.size
+
+          UI.message("Uploaded Artifact:")
+          UI.message("Repo: #{upload.repo}")
+          UI.message("URI: #{upload.uri}")
+          UI.message("Size: #{upload.size}")
+          UI.message("SHA1: #{upload.sha1}")
+        else
+          UI.message("File not found: '#{file_path}'")
+        end
+      end
+
+      def self.connect_to_artifactory(params)
+        config_keys = [:endpoint, :username, :password, :api_key, :ssl_pem_file, :ssl_verify, :proxy_username, :proxy_password, :proxy_address, :proxy_port, :read_timeout]
+        config = params.values.select do |key|
+          config_keys.include?(key)
+        end
+        Artifactory::Client.new(config)
+      end
+
+      def self.description
+        'This action uploads an artifact to artifactory'
+      end
+
+      def self.details
+        'Connect to the artifactory server using either a username/password or an api_key'
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.author
+        ["koglinjg", "tommeier"]
+      end
+
+      def self.output
+        [
+          ['ARTIFACTORY_DOWNLOAD_URL', 'The download url for file uploaded'],
+          ['ARTIFACTORY_DOWNLOAD_SIZE', 'The reported file size for file uploaded']
+        ]
+      end
+
+      def self.example_code
+        [
+          'artifactory(
+            username: "username",
+            password: "password",
+            endpoint: "https://artifactory.example.com/artifactory/",
+            file: "example.ipa",                                # File to upload
+            repo: "mobile_artifacts",                           # Artifactory repo
+            repo_path: "/ios/appname/example-major.minor.ipa"   # Path to place the artifact including its filename
+          )',
+          'artifactory(
+            api_key: "api_key",
+            endpoint: "https://artifactory.example.com/artifactory/",
+            file: "example.ipa",                                # File to upload
+            repo: "mobile_artifacts",                           # Artifactory repo
+            repo_path: "/ios/appname/example-major.minor.ipa"   # Path to place the artifact including its filename
+          )'
+        ]
+      end
+
+      def self.category
+        :misc
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :file,
+                                       env_name: "FL_ARTIFACTORY_FILE",
+                                       description: "File to be uploaded to artifactory",
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :repo,
+                                       env_name: "FL_ARTIFACTORY_REPO",
+                                       description: "Artifactory repo to put the file in",
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :repo_path,
+                                       env_name: "FL_ARTIFACTORY_REPO_PATH",
+                                       description: "Path to deploy within the repo, including filename",
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :endpoint,
+                                       env_name: "FL_ARTIFACTORY_ENDPOINT",
+                                       description: "Artifactory endpoint",
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :username,
+                                       env_name: "FL_ARTIFACTORY_USERNAME",
+                                       description: "Artifactory username",
+                                       optional: true,
+                                       conflicting_options: [:api_key],
+                                       conflict_block: proc do |value|
+                                         UI.user_error!("You can't use option '#{value.key}' along with 'username'")
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :password,
+                                       env_name: "FL_ARTIFACTORY_PASSWORD",
+                                       description: "Artifactory password",
+                                       sensitive: true,
+                                       code_gen_sensitive: true,
+                                       optional: true,
+                                       conflicting_options: [:api_key],
+                                       conflict_block: proc do |value|
+                                         UI.user_error!("You can't use option '#{value.key}' along with 'password'")
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :api_key,
+                                       env_name: "FL_ARTIFACTORY_API_KEY",
+                                       description: "Artifactory API key",
+                                       sensitive: true,
+                                       code_gen_sensitive: true,
+                                       optional: true,
+                                       conflicting_options: [:username, :password],
+                                       conflict_block: proc do |value|
+                                         UI.user_error!("You can't use option '#{value.key}' along with 'api_key'")
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :properties,
+                                       env_name: "FL_ARTIFACTORY_PROPERTIES",
+                                       description: "Artifact properties hash",
+                                       type: Hash,
+                                       default_value: {},
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :ssl_pem_file,
+                                       env_name: "FL_ARTIFACTORY_SSL_PEM_FILE",
+                                       description: "Location of pem file to use for ssl verification",
+                                       default_value: nil,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :ssl_verify,
+                                       env_name: "FL_ARTIFACTORY_SSL_VERIFY",
+                                       description: "Verify SSL",
+                                       type: Boolean,
+                                       default_value: true,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :proxy_username,
+                                       env_name: "FL_ARTIFACTORY_PROXY_USERNAME",
+                                       description: "Proxy username",
+                                       default_value: nil,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :proxy_password,
+                                       env_name: "FL_ARTIFACTORY_PROXY_PASSWORD",
+                                       description: "Proxy password",
+                                       sensitive: true,
+                                       code_gen_sensitive: true,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :proxy_address,
+                                       env_name: "FL_ARTIFACTORY_PROXY_ADDRESS",
+                                       description: "Proxy address",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :proxy_port,
+                                       env_name: "FL_ARTIFACTORY_PROXY_PORT",
+                                       description: "Proxy port",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :read_timeout,
+                                       env_name: "FL_ARTIFACTORY_READ_TIMEOUT",
+                                       description: "Read timeout",
+                                       optional: true)
+        ]
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/automatic_code_signing.rb

@@ -0,0 +1,220 @@
+require 'xcodeproj'
+module Fastlane
+  module Actions
+    class AutomaticCodeSigningAction < Action
+      def self.run(params)
+        UI.deprecated("The `automatic_code_signing` action has been deprecated,")
+        UI.deprecated("Please use `update_code_signing_settings` action instead.")
+        FastlaneCore::PrintTable.print_values(config: params, title: "Summary for Automatic Codesigning")
+        path = params[:path]
+        path = File.join(File.expand_path(path), "project.pbxproj")
+
+        project = Xcodeproj::Project.open(params[:path])
+        UI.user_error!("Could not find path to project config '#{path}'. Pass the path to your project (not workspace)!") unless File.exist?(path)
+        UI.message("Updating the Automatic Codesigning flag to #{params[:use_automatic_signing] ? 'enabled' : 'disabled'} for the given project '#{path}'")
+
+        unless project.root_object.attributes["TargetAttributes"]
+          UI.user_error!("Seems to be a very old project file format - please open your project file in a more recent version of Xcode")
+          return false
+        end
+
+        target_dictionary = project.targets.map { |f| { name: f.name, uuid: f.uuid, build_configuration_list: f.build_configuration_list } }
+        target_attributes = project.root_object.attributes["TargetAttributes"]
+        changed_targets = []
+
+        # make sure TargetAttributes exist for all targets
+        target_dictionary.each do |props|
+          unless target_attributes.key?(props[:uuid])
+            target_attributes[props[:uuid]] = {}
+          end
+        end
+
+        target_attributes.each do |target, sett|
+          found_target = target_dictionary.detect { |h| h[:uuid] == target }
+          if params[:targets]
+            # get target name
+            unless params[:targets].include?(found_target[:name])
+              UI.important("Skipping #{found_target[:name]} not selected (#{params[:targets].join(',')})")
+              next
+            end
+          end
+
+          style_value = params[:use_automatic_signing] ? 'Automatic' : 'Manual'
+          build_configuration_list = found_target[:build_configuration_list]
+          build_configuration_list.set_setting("CODE_SIGN_STYLE", style_value)
+          sett["ProvisioningStyle"] = style_value
+
+          if params[:team_id]
+            sett["DevelopmentTeam"] = params[:team_id]
+            build_configuration_list.set_setting("DEVELOPMENT_TEAM", params[:team_id])
+            UI.important("Set Team id to: #{params[:team_id]} for target: #{found_target[:name]}")
+          end
+          if params[:code_sign_identity]
+            build_configuration_list.set_setting("CODE_SIGN_IDENTITY", params[:code_sign_identity])
+
+            # We also need to update the value if it was overridden for a specific SDK
+            build_configuration_list.build_configurations.each do |build_configuration|
+              codesign_build_settings_keys = build_configuration.build_settings.keys.select { |key| key.to_s.match(/CODE_SIGN_IDENTITY.*/) }
+              codesign_build_settings_keys.each do |setting|
+                build_configuration_list.set_setting(setting, params[:code_sign_identity])
+              end
+            end
+            UI.important("Set Code Sign identity to: #{params[:code_sign_identity]} for target: #{found_target[:name]}")
+          end
+          if params[:profile_name]
+            build_configuration_list.set_setting("PROVISIONING_PROFILE_SPECIFIER", params[:profile_name])
+            UI.important("Set Provisioning Profile name to: #{params[:profile_name]} for target: #{found_target[:name]}")
+          end
+          # Since Xcode 8, this is no longer needed, you simply use PROVISIONING_PROFILE_SPECIFIER
+          if params[:profile_uuid]
+            build_configuration_list.set_setting("PROVISIONING_PROFILE", params[:profile_uuid])
+            UI.important("Set Provisioning Profile UUID to: #{params[:profile_uuid]} for target: #{found_target[:name]}")
+          end
+          if params[:bundle_identifier]
+            build_configuration_list.set_setting("PRODUCT_BUNDLE_IDENTIFIER", params[:bundle_identifier])
+            UI.important("Set Bundle identifier to: #{params[:bundle_identifier]} for target: #{found_target[:name]}")
+          end
+
+          changed_targets << found_target[:name]
+        end
+        project.save
+
+        if changed_targets.empty?
+          UI.important("None of the specified targets has been modified")
+          UI.important("available targets:")
+          target_dictionary.each do |target|
+            UI.important("\t* #{target[:name]}")
+          end
+        else
+          UI.success("Successfully updated project settings to use Code Sign Style = '#{params[:use_automatic_signing] ? 'Automatic' : 'Manual'}'")
+          UI.success("Modified Targets:")
+          changed_targets.each do |target|
+            UI.success("\t * #{target}")
+          end
+        end
+
+        params[:use_automatic_signing]
+      end
+
+      def self.alias_used(action_alias, params)
+        params[:use_automatic_signing] = true if action_alias == "enable_automatic_code_signing"
+      end
+
+      def self.aliases
+        ["enable_automatic_code_signing", "disable_automatic_code_signing"]
+      end
+
+      def self.description
+        "Configures Xcode's Codesigning options"
+      end
+
+      def self.details
+        "Configures Xcode's Codesigning options of all targets in the project"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :path,
+                                       env_name: "FL_PROJECT_SIGNING_PROJECT_PATH",
+                                       description: "Path to your Xcode project",
+                                       code_gen_sensitive: true,
+                                       default_value: Dir['*.xcodeproj'].first,
+                                       default_value_dynamic: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Path is invalid") unless File.exist?(File.expand_path(value))
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :use_automatic_signing,
+                                       env_name: "FL_PROJECT_USE_AUTOMATIC_SIGNING",
+                                       description: "Defines if project should use automatic signing",
+                                       type: Boolean,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :team_id,
+                                       env_name: "FASTLANE_TEAM_ID",
+                                       optional: true,
+                                       description: "Team ID, is used when upgrading project"),
+          FastlaneCore::ConfigItem.new(key: :targets,
+                                       env_name: "FL_PROJECT_SIGNING_TARGETS",
+                                       optional: true,
+                                       type: Array,
+                                       description: "Specify targets you want to toggle the signing mech. (default to all targets)"),
+          FastlaneCore::ConfigItem.new(key: :code_sign_identity,
+                                       env_name: "FL_CODE_SIGN_IDENTITY",
+                                       description: "Code signing identity type (iPhone Developer, iPhone Distribution)",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :profile_name,
+                                       env_name: "FL_PROVISIONING_PROFILE_SPECIFIER",
+                                       description: "Provisioning profile name to use for code signing",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :profile_uuid,
+                                       env_name: "FL_PROVISIONING_PROFILE",
+                                       description: "Provisioning profile UUID to use for code signing",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :bundle_identifier,
+                                       env_name: "FL_APP_IDENTIFIER",
+                                       description: "Application Product Bundle Identifier",
+                                       optional: true)
+        ]
+      end
+
+      def self.output
+      end
+
+      def self.example_code
+        [
+          '# enable automatic code signing
+          enable_automatic_code_signing',
+          'enable_automatic_code_signing(
+            path: "demo-project/demo/demo.xcodeproj"
+          )',
+          '# disable automatic code signing
+          disable_automatic_code_signing',
+          'disable_automatic_code_signing(
+            path: "demo-project/demo/demo.xcodeproj"
+          )',
+          '# also set team id
+          disable_automatic_code_signing(
+            path: "demo-project/demo/demo.xcodeproj",
+            team_id: "XXXX"
+          )',
+          '# Only specific targets
+          disable_automatic_code_signing(
+            path: "demo-project/demo/demo.xcodeproj",
+            use_automatic_signing: false,
+            targets: ["demo"]
+          )
+          ',
+          ' # via generic action
+          automatic_code_signing(
+            path: "demo-project/demo/demo.xcodeproj",
+            use_automatic_signing: false
+          )',
+          'automatic_code_signing(
+            path: "demo-project/demo/demo.xcodeproj",
+            use_automatic_signing: true
+          )'
+
+        ]
+      end
+
+      def self.category
+        :deprecated
+      end
+
+      def self.deprecated_notes
+        "Please use `update_code_signing_settings` action instead."
+      end
+
+      def self.return_value
+        "The current status (boolean) of codesigning after modification"
+      end
+
+      def self.authors
+        ["mathiasAichinger", "hjanuschka", "p4checo", "portellaa", "aeons"]
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include?(platform)
+      end
+    end
+  end
+end