fastlane_hotfix 2.165.0

data/fastlane/lib/fastlane/actions/testflight.rb

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

data/fastlane/lib/fastlane/actions/tryouts.rb

@@ -0,0 +1,149 @@
+module Fastlane
+  module Actions
+    module SharedValues
+      # Contains all the data returned from the Tryouts API. See http://tryouts.readthedocs.org/en/latest/releases.html#create-release
+      TRYOUTS_BUILD_INFORMATION = :TRYOUTS_BUILD_INFORMATION
+    end
+    class TryoutsAction < Action
+      TRYOUTS_API_BUILD_RELEASE_TEMPLATE = "https://api.tryouts.io/v1/applications/%s/releases/"
+
+      def self.run(params)
+        UI.success('Upload to Tryouts has been started. This may take some time.')
+
+        response = self.upload_build(params)
+
+        case response.status
+        when 200...300
+          Actions.lane_context[SharedValues::TRYOUTS_BUILD_INFORMATION] = response.body
+          UI.success('Build successfully uploaded to Tryouts!')
+          UI.message("Release download url: #{response.body['download_url']}") if response.body["download_url"]
+        else
+          UI.user_error!("Error when trying to upload build file to Tryouts: #{response.body}")
+        end
+      end
+
+      def self.upload_build(params)
+        require 'faraday'
+        require 'faraday_middleware'
+
+        url = TRYOUTS_API_BUILD_RELEASE_TEMPLATE % params[:app_id]
+        connection = Faraday.new(url) do |builder|
+          builder.request(:multipart)
+          builder.request(:url_encoded)
+          builder.response(:json, content_type: /\bjson$/)
+          builder.use(FaradayMiddleware::FollowRedirects)
+          builder.adapter(:net_http)
+        end
+
+        options = {}
+        options[:build] = Faraday::UploadIO.new(params[:build_file], 'application/octet-stream')
+
+        if params[:notes_path]
+          options[:notes] = File.read(params[:notes_path])
+        elsif params[:notes]
+          options[:notes] = params[:notes]
+        end
+
+        options[:notify] = params[:notify].to_s
+        options[:status] = params[:status].to_s
+
+        post_request = connection.post do |req|
+          req.headers['Authorization'] = params[:api_token]
+          req.body = options
+        end
+
+        post_request.on_complete do |env|
+          yield(env[:status], env[:body]) if block_given?
+        end
+      end
+
+      def self.description
+        "Upload a new build to [Tryouts](https://tryouts.io/)"
+      end
+
+      def self.details
+        "More information: [http://tryouts.readthedocs.org/en/latest/releases.html#create-release](http://tryouts.readthedocs.org/en/latest/releases.html#create-release)"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :app_id,
+                                     env_name: "TRYOUTS_APP_ID",
+                                     description: "Tryouts application hash",
+                                     verify_block: proc do |value|
+                                       UI.user_error!("No application identifier for Tryouts given, pass using `app_id: 'application id'`") unless value && !value.empty?
+                                     end),
+          FastlaneCore::ConfigItem.new(key: :api_token,
+                                     env_name: "TRYOUTS_API_TOKEN",
+                                     sensitive: true,
+                                     description: "API Token (api_key:api_secret) for Tryouts Access",
+                                     verify_block: proc do |value|
+                                       UI.user_error!("No API token for Tryouts given, pass using `api_token: 'token'`") unless value && !value.empty?
+                                     end),
+          FastlaneCore::ConfigItem.new(key: :build_file,
+                                     env_name: "TRYOUTS_BUILD_FILE",
+                                     description: "Path to your IPA or APK file. Optional if you use the _gym_ or _xcodebuild_ action",
+                                     default_value: Actions.lane_context[SharedValues::IPA_OUTPUT_PATH],
+                                       default_value_dynamic: true,
+                                     verify_block: proc do |value|
+                                       UI.user_error!("Couldn't find build file at path '#{value}'") unless File.exist?(value)
+                                     end),
+          FastlaneCore::ConfigItem.new(key: :notes,
+                                     env_name: "TRYOUTS_NOTES",
+                                     description: "Release notes",
+                                     is_string: true,
+                                     optional: true),
+          FastlaneCore::ConfigItem.new(key: :notes_path,
+                                     env_name: "TRYOUTS_NOTES_PATH",
+                                     description: "Release notes text file path. Overrides the :notes parameter",
+                                     verify_block: proc do |value|
+                                       UI.user_error!("Couldn't find notes file at path '#{value}'") unless File.exist?(value)
+                                     end,
+                                     optional: true),
+          FastlaneCore::ConfigItem.new(key: :notify,
+                                     env_name: "TRYOUTS_NOTIFY",
+                                     description: "Notify testers? 0 for no",
+                                     is_string: false,
+                                     default_value: 1),
+          FastlaneCore::ConfigItem.new(key: :status,
+                                     env_name: "TRYOUTS_STATUS",
+                                     description: "2 to make your release public. Release will be distributed to available testers. 1 to make your release private. Release won't be distributed to testers. This also prevents release from showing up for SDK update",
+                                     verify_block: proc do |value|
+                                       available_options = ["1", "2"]
+                                       UI.user_error!("'#{value}' is not a valid 'status' value. Available options are #{available_options.join(', ')}") unless available_options.include?(value.to_s)
+                                     end,
+                                     is_string: false,
+                                     default_value: 2)
+        ]
+      end
+
+      def self.example_code
+        [
+          'tryouts(
+            api_token: "...",
+            app_id: "application-id",
+            build_file: "test.ipa",
+          )'
+        ]
+      end
+
+      def self.category
+        :beta
+      end
+
+      def self.output
+        [
+          ['TRYOUTS_BUILD_INFORMATION', 'Contains release info like :application_name, :download_url. See http://tryouts.readthedocs.org/en/latest/releases.html#create-release']
+        ]
+      end
+
+      def self.authors
+        ["alicertel"]
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :android].include?(platform)
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/twitter.rb

@@ -0,0 +1,89 @@
+module Fastlane
+  module Actions
+    class TwitterAction < Action
+      def self.run(params)
+        Actions.verify_gem!("twitter")
+        require 'twitter'
+        client = Twitter::REST::Client.new do |config|
+          config.consumer_key        = params[:consumer_key]
+          config.consumer_secret     = params[:consumer_secret]
+          config.access_token        = params[:access_token]
+          config.access_token_secret = params[:access_token_secret]
+        end
+        client.update(params[:message])
+        UI.message(['[TWITTER]', "Successfully tweeted ", params[:message]].join(': '))
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Post a tweet on [Twitter.com](https://twitter.com)"
+      end
+
+      def self.details
+        "Post a tweet on Twitter. Requires you to setup an app on [twitter.com](https://twitter.com) and obtain `consumer` and `access_token`."
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :consumer_key,
+                                       env_name: "FL_TW_CONSUMER_KEY",
+                                       description: "Consumer Key",
+                                       sensitive: true,
+                                       is_string: true,
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :consumer_secret,
+                                       env_name: "FL_TW_CONSUMER_SECRET",
+                                       sensitive: true,
+                                       description: "Consumer Secret",
+                                       is_string: true,
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :access_token,
+                                       env_name: "FL_TW_ACCESS_TOKEN",
+                                       sensitive: true,
+                                       description: "Access Token",
+                                       is_string: true,
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :access_token_secret,
+                                       env_name: "FL_TW_ACCESS_TOKEN_SECRET",
+                                       sensitive: true,
+                                       description: "Access Token Secret",
+                                       is_string: true,
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :message,
+                                       env_name: "FL_TW_MESSAGE",
+                                       description: "The tweet",
+                                       is_string: true,
+                                       optional: false)
+
+        ]
+      end
+
+      def self.authors
+        ["hjanuschka"]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.example_code
+        [
+          'twitter(
+            access_token: "XXXX",
+            access_token_secret: "xxx",
+            consumer_key: "xxx",
+            consumer_secret: "xxx",
+            message: "You rock!"
+          )'
+        ]
+      end
+
+      def self.category
+        :notifications
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/typetalk.rb

@@ -0,0 +1,93 @@
+module Fastlane
+  module Actions
+    class TypetalkAction < Action
+      def self.run(params)
+        options = {
+            message: nil,
+            note_path: nil,
+            success: true,
+            topic_id: nil,
+            typetalk_token: nil
+        }.merge(params || {})
+
+        [:message, :topic_id, :typetalk_token].each do |key|
+          UI.user_error!("No #{key} given.") unless options[key]
+        end
+
+        emoticon = (options[:success] ? ':smile:' : ':rage:')
+        message = "#{emoticon} #{options[:message]}"
+
+        note_path = File.expand_path(options[:note_path]) if options[:note_path]
+        if note_path && File.exist?(note_path)
+          contents = File.read(note_path)
+          message += "\n\n```\n#{contents}\n```"
+        end
+
+        topic_id = options[:topic_id]
+        typetalk_token = options[:typetalk_token]
+
+        self.post_to_typetalk(message, topic_id, typetalk_token)
+
+        UI.success('Successfully sent Typetalk notification')
+      end
+
+      def self.post_to_typetalk(message, topic_id, typetalk_token)
+        require 'net/http'
+        require 'uri'
+
+        uri = URI.parse("https://typetalk.in/api/v1/topics/#{topic_id}")
+        response = Net::HTTP.post_form(uri, { 'message' => message,
+                                             'typetalkToken' => typetalk_token })
+
+        self.check_response(response)
+      end
+
+      def self.check_response(response)
+        case response.code.to_i
+        when 200, 204
+          true
+        else
+          UI.user_error!("Could not sent Typetalk notification")
+        end
+      end
+
+      def self.description
+        "Post a message to [Typetalk](https://www.typetalk.com/)"
+      end
+
+      def self.available_options
+        [
+          ['message', 'The message to post'],
+          ['note_path', 'Path to an additional note'],
+          ['topic_id', 'Typetalk topic id'],
+          ['success', 'Successful build?'],
+          ['typetalk_token', 'typetalk token']
+        ]
+      end
+
+      def self.author
+        "Nulab Inc."
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.example_code
+        [
+          'typetalk(
+            message: "App successfully released!",
+            note_path: "ChangeLog.md",
+            topicId: 1,
+            success: true,
+            typetalk_token: "Your Typetalk Token"
+          )'
+        ]
+      end
+
+      def self.category
+        :notifications
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/unlock_keychain.rb

@@ -0,0 +1,132 @@
+module Fastlane
+  module Actions
+    class UnlockKeychainAction < Action
+      def self.run(params)
+        keychain_path = FastlaneCore::Helper.keychain_path(params[:path])
+        add_to_search_list = params[:add_to_search_list]
+        set_default = params[:set_default]
+        commands = []
+
+        # add to search list if not already added
+        if add_to_search_list == true || add_to_search_list == :add
+          commands << add_keychain_to_search_list(keychain_path)
+        elsif add_to_search_list == :replace
+          commands << replace_keychain_in_search_list(keychain_path)
+        end
+
+        # set default keychain
+        if set_default
+          commands << default_keychain(keychain_path)
+        end
+
+        escaped_path = keychain_path.shellescape
+        escaped_password = params[:password].shellescape
+
+        # Log the full path, useful for troubleshooting
+        UI.message("Unlocking keychain at path: #{escaped_path}")
+        # unlock given keychain and disable lock and timeout
+        commands << Fastlane::Actions.sh("security unlock-keychain -p #{escaped_password} #{escaped_path}", log: false)
+        commands << Fastlane::Actions.sh("security set-keychain-settings #{escaped_path}", log: false)
+        commands
+      end
+
+      def self.add_keychain_to_search_list(keychain_path)
+        keychains = Fastlane::Actions.sh("security list-keychains -d user", log: false).shellsplit
+
+        # add the keychain to the keychain list
+        unless keychains.include?(keychain_path)
+          keychains << keychain_path
+
+          Fastlane::Actions.sh("security list-keychains -s #{keychains.shelljoin}", log: false)
+        end
+      end
+
+      def self.replace_keychain_in_search_list(keychain_path)
+        Actions.lane_context[Actions::SharedValues::ORIGINAL_DEFAULT_KEYCHAIN] = Fastlane::Actions.sh("security default-keychain", log: false).strip
+        escaped_path = keychain_path.shellescape
+        Fastlane::Actions.sh("security list-keychains -s #{escaped_path}", log: false)
+      end
+
+      def self.default_keychain(keychain_path)
+        escaped_path = keychain_path.shellescape
+        Fastlane::Actions.sh("security default-keychain -s #{escaped_path}", log: false)
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Unlock a keychain"
+      end
+
+      def self.details
+        [
+          "Unlocks the given keychain file and adds it to the keychain search list.",
+          "Keychains can be replaced with `add_to_search_list: :replace`."
+        ].join("\n")
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :path,
+                                       env_name: "FL_UNLOCK_KEYCHAIN_PATH",
+                                       description: "Path to the keychain file",
+                                       default_value: "login",
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :password,
+                                       env_name: "FL_UNLOCK_KEYCHAIN_PASSWORD",
+                                       sensitive: true,
+                                       description: "Keychain password",
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :add_to_search_list,
+                                       env_name: "FL_UNLOCK_KEYCHAIN_ADD_TO_SEARCH_LIST",
+                                       description: "Add to keychain search list",
+                                       is_string: false,
+                                       default_value: true),
+          FastlaneCore::ConfigItem.new(key: :set_default,
+                                       env_name: "FL_UNLOCK_KEYCHAIN_SET_DEFAULT",
+                                       description: "Set as default keychain",
+                                       is_string: false,
+                                       default_value: false)
+
+        ]
+      end
+
+      def self.authors
+        ["xfreebird"]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.example_code
+        [
+          'unlock_keychain( # Unlock an existing keychain and add it to the keychain search list
+            path: "/path/to/KeychainName.keychain",
+            password: "mysecret"
+          )',
+          'unlock_keychain( # By default the keychain is added to the existing. To replace them with the selected keychain you may use `:replace`
+            path: "/path/to/KeychainName.keychain",
+            password: "mysecret",
+            add_to_search_list: :replace # To only add a keychain use `true` or `:add`.
+          )',
+          'unlock_keychain( # In addition, the keychain can be selected as a default keychain
+            path: "/path/to/KeychainName.keychain",
+            password: "mysecret",
+            set_default: true
+          )',
+          'unlock_keychain( # If the keychain file is located in the standard location `~/Library/Keychains`, then it is sufficient to provide the keychain file name, or file name with its suffix.
+            path: "KeychainName",
+            password: "mysecret"
+          )'
+        ]
+      end
+
+      def self.category
+        :misc
+      end
+    end
+  end
+end