fastlane-mercafacil 2.214.0

data/fastlane/lib/fastlane/actions/team_id.rb

@@ -0,0 +1,42 @@
+module Fastlane
+  module Actions
+    module SharedValues
+    end
+
+    class TeamIdAction < Action
+      def self.run(params)
+        params = nil unless params.kind_of?(Array)
+        team = (params || []).first
+        UI.user_error!("Please pass your Team ID (e.g. team_id 'Q2CBPK58CA')") unless team.to_s.length > 0
+
+        UI.message("Setting Team ID to '#{team}' for all build steps")
+
+        [:CERT_TEAM_ID, :SIGH_TEAM_ID, :PEM_TEAM_ID, :PRODUCE_TEAM_ID, :SIGH_TEAM_ID, :FASTLANE_TEAM_ID].each do |current|
+          ENV[current.to_s] = team
+        end
+      end
+
+      def self.author
+        "KrauseFx"
+      end
+
+      def self.description
+        "Specify the Team ID you want to use for the Apple Developer Portal"
+      end
+
+      def self.is_supported?(platform)
+        platform == :ios
+      end
+
+      def self.example_code
+        [
+          'team_id("Q2CBPK58CA")'
+        ]
+      end
+
+      def self.category
+        :misc
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/team_name.rb

@@ -0,0 +1,42 @@
+module Fastlane
+  module Actions
+    module SharedValues
+    end
+
+    class TeamNameAction < Action
+      def self.run(params)
+        params = nil unless params.kind_of?(Array)
+        team = (params || []).first
+        UI.user_error!("Please pass your Team Name (e.g. team_name 'Felix Krause')") unless team.to_s.length > 0
+
+        UI.message("Setting Team Name to '#{team}' for all build steps")
+
+        [:FASTLANE_TEAM_NAME, :PRODUCE_TEAM_NAME].each do |current|
+          ENV[current.to_s] = team
+        end
+      end
+
+      def self.description
+        "Set a team to use by its name"
+      end
+
+      def self.author
+        "KrauseFx"
+      end
+
+      def self.is_supported?(platform)
+        platform == :ios
+      end
+
+      def self.example_code
+        [
+          'team_name("Felix Krause")'
+        ]
+      end
+
+      def self.category
+        :misc
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/testfairy.rb

@@ -0,0 +1,284 @@
+module Fastlane
+  module Actions
+    module SharedValues
+      TESTFAIRY_BUILD_URL = :TESTFAIRY_BUILD_URL
+      TESTFAIRY_DOWNLOAD_URL = :TESTFAIRY_DOWNLOAD_URL
+      TESTFAIRY_LANDING_PAGE = :TESTFAIRY_LANDING_PAGE
+    end
+
+    class TestfairyAction < Action
+      def self.upload_build(upload_url, ipa, options, timeout)
+        require 'faraday'
+        require 'faraday_middleware'
+
+        UI.success("Uploading to #{upload_url}...")
+
+        connection = Faraday.new(url: upload_url) do |builder|
+          builder.request(:multipart)
+          builder.request(:url_encoded)
+          builder.request(:retry, max: 3, interval: 5)
+          builder.response(:json, content_type: /\bjson$/)
+          builder.use(FaradayMiddleware::FollowRedirects)
+          builder.adapter(:net_http)
+        end
+
+        options[:file] = Faraday::UploadIO.new(ipa, 'application/octet-stream') if ipa && File.exist?(ipa)
+
+        symbols_file = options.delete(:symbols_file)
+        if symbols_file
+          options[:symbols_file] = Faraday::UploadIO.new(symbols_file, 'application/octet-stream')
+        end
+
+        begin
+          connection.post do |req|
+            req.options.timeout = timeout
+            req.url("/api/upload/")
+            req.body = options
+          end
+        rescue Faraday::TimeoutError
+          UI.crash!("Uploading build to TestFairy timed out ⏳")
+        end
+      end
+
+      def self.run(params)
+        UI.success('Starting with ipa upload to TestFairy...')
+
+        metrics_to_client = lambda do |metrics|
+          metrics.map do |metric|
+            case metric
+            when :cpu, :memory, :network, :gps, :battery, :mic, :wifi
+              metric.to_s
+            when :phone_signal
+              'phone-signal'
+            else
+              UI.user_error!("Unknown metric: #{metric}")
+            end
+          end
+        end
+
+        options_to_client = lambda do |options|
+          options.map do |option|
+            case option.to_sym
+            when :shake, :anonymous
+              option.to_s
+            when :video_only_wifi
+              'video-only-wifi'
+            else
+              UI.user_error!("Unknown option: #{option}")
+            end
+          end
+        end
+
+        # Rejecting key `upload_url` and `timeout` as we don't need it in options
+        client_options = Hash[params.values.reject do |key, value|
+          [:upload_url, :timeout].include?(key)
+        end.map do |key, value|
+          case key
+          when :api_key
+            [key, value]
+          when :ipa
+            [key, value]
+          when :apk
+            [key, value]
+          when :symbols_file
+            [key, value]
+          when :testers_groups
+            [key, value.join(',')]
+          when :metrics
+            [key, metrics_to_client.call(value).join(',')]
+          when :comment
+            [key, value]
+          when :auto_update
+            ['auto-update', value]
+          when :notify
+            [key, value]
+          when :options
+            [key, options_to_client.call(value).join(',')]
+          when :custom
+            [key, value]
+          else
+            UI.user_error!("Unknown parameter: #{key}")
+          end
+        end]
+
+        path = params[:ipa] || params[:apk]
+        UI.user_error!("No ipa or apk were given") unless path
+
+        return path if Helper.test?
+
+        response = self.upload_build(params[:upload_url], path, client_options, params[:timeout])
+        if parse_response(response)
+          UI.success("Build URL: #{Actions.lane_context[SharedValues::TESTFAIRY_BUILD_URL]}")
+          UI.success("Download URL: #{Actions.lane_context[SharedValues::TESTFAIRY_DOWNLOAD_URL]}")
+          UI.success("Landing Page URL: #{Actions.lane_context[SharedValues::TESTFAIRY_LANDING_PAGE]}")
+          UI.success("Build successfully uploaded to TestFairy.")
+        else
+          UI.user_error!("Error when trying to upload ipa to TestFairy")
+        end
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.parse_response(response)
+        if response.body && response.body.key?('status') && response.body['status'] == 'ok'
+          build_url = response.body['build_url']
+          app_url = response.body['app_url']
+          landing_page_url = response.body['landing_page_url']
+
+          Actions.lane_context[SharedValues::TESTFAIRY_BUILD_URL] = build_url
+          Actions.lane_context[SharedValues::TESTFAIRY_DOWNLOAD_URL] = app_url
+          Actions.lane_context[SharedValues::TESTFAIRY_LANDING_PAGE] = landing_page_url
+
+          return true
+        else
+          UI.error("Error uploading to TestFairy: #{response.body}")
+
+          return false
+        end
+      end
+      private_class_method :parse_response
+
+      def self.description
+        'Upload a new build to [TestFairy](https://www.testfairy.com/)'
+      end
+
+      def self.details
+        "You can retrieve your API key on [your settings page](https://free.testfairy.com/settings/)"
+      end
+
+      def self.available_options
+        [
+          # required
+          FastlaneCore::ConfigItem.new(key: :api_key,
+                                       env_name: "FL_TESTFAIRY_API_KEY", # The name of the environment variable
+                                       description: "API Key for TestFairy", # a short description of this parameter
+                                       sensitive: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("No API key for TestFairy given, pass using `api_key: 'key'`") unless value.to_s.length > 0
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :ipa,
+                                       env_name: 'TESTFAIRY_IPA_PATH',
+                                       description: 'Path to your IPA file for iOS',
+                                       default_value: Actions.lane_context[SharedValues::IPA_OUTPUT_PATH],
+                                       default_value_dynamic: true,
+                                       optional: true,
+                                       conflicting_options: [:apk],
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Couldn't find ipa file at path '#{value}'") unless File.exist?(value)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :apk,
+                                       env_name: 'TESTFAIRY_APK_PATH',
+                                       description: 'Path to your APK file for Android',
+                                       default_value: Actions.lane_context[SharedValues::GRADLE_APK_OUTPUT_PATH],
+                                       default_value_dynamic: true,
+                                       optional: true,
+                                       conflicting_options: [:ipa],
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Couldn't find apk file at path '#{value}'") unless File.exist?(value)
+                                       end),
+          # optional
+          FastlaneCore::ConfigItem.new(key: :symbols_file,
+                                       optional: true,
+                                       env_name: "FL_TESTFAIRY_SYMBOLS_FILE",
+                                       description: "Symbols mapping file",
+                                       default_value: Actions.lane_context[SharedValues::DSYM_OUTPUT_PATH],
+                                       default_value_dynamic: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Couldn't find dSYM file at path '#{value}'") unless File.exist?(value)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :upload_url,
+                                       env_name: "FL_TESTFAIRY_UPLOAD_URL", # The name of the environment variable
+                                       description: "API URL for TestFairy", # a short description of this parameter
+                                       default_value: "https://upload.testfairy.com",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :testers_groups,
+                                       optional: true,
+                                       type: Array,
+                                       short_option: '-g',
+                                       env_name: "FL_TESTFAIRY_TESTERS_GROUPS",
+                                       description: "Array of tester groups to be notified",
+                                       default_value: []), # the default value is an empty list
+          FastlaneCore::ConfigItem.new(key: :metrics,
+                                       optional: true,
+                                       type: Array,
+                                       env_name: "FL_TESTFAIRY_METRICS",
+                                       description: "Array of metrics to record (cpu,memory,network,phone_signal,gps,battery,mic,wifi)",
+                                       default_value: []),
+          # max-duration
+          # video
+          # video-quality
+          # video-rate
+          FastlaneCore::ConfigItem.new(key: :comment,
+                                       optional: true,
+                                       env_name: "FL_TESTFAIRY_COMMENT",
+                                       description: "Additional release notes for this upload. This text will be added to email notifications",
+                                       default_value: 'No comment provided'), # the default value if the user didn't provide one
+          FastlaneCore::ConfigItem.new(key: :auto_update,
+                                       optional: true,
+                                       env_name: "FL_TESTFAIRY_AUTO_UPDATE",
+                                       description: "Allows an easy upgrade of all users to the current version. To enable set to 'on'",
+                                       default_value: 'off'),
+          # not well documented
+          FastlaneCore::ConfigItem.new(key: :notify,
+                                       optional: true,
+                                       env_name: "FL_TESTFAIRY_NOTIFY",
+                                       description: "Send email to testers",
+                                       default_value: 'off'),
+          FastlaneCore::ConfigItem.new(key: :options,
+                                       optional: true,
+                                       type: Array,
+                                       env_name: "FL_TESTFAIRY_OPTIONS",
+                                       description: "Array of options (shake,video_only_wifi,anonymous)",
+                                       default_value: []),
+          FastlaneCore::ConfigItem.new(key: :custom,
+                                       optional: true,
+                                       env_name: "FL_TESTFAIRY_CUSTOM",
+                                       description: "Array of custom options. Contact support@testfairy.com for more information",
+                                       default_value: ''),
+          FastlaneCore::ConfigItem.new(key: :timeout,
+                                       env_name: "FL_TESTFAIRY_TIMEOUT",
+                                       description: "Request timeout in seconds",
+                                       type: Integer,
+                                       optional: true)
+        ]
+      end
+
+      def self.example_code
+        [
+          'testfairy(
+            api_key: "...",
+            ipa: "./ipa_file.ipa",
+            comment: "Build #{lane_context[SharedValues::BUILD_NUMBER]}",
+          )',
+          'testfairy(
+            api_key: "...",
+            apk: "../build/app/outputs/apk/qa/release/app-qa-release.apk",
+            comment: "Build #{lane_context[SharedValues::BUILD_NUMBER]}",
+           )'
+        ]
+      end
+
+      def self.category
+        :beta
+      end
+
+      def self.output
+        [
+          ['TESTFAIRY_BUILD_URL', 'URL for the sessions of the newly uploaded build'],
+          ['TESTFAIRY_DOWNLOAD_URL', 'URL directly to the newly uploaded build'],
+          ['TESTFAIRY_LANDING_PAGE', 'URL of the build\'s landing page']
+        ]
+      end
+
+      def self.authors
+        ["taka0125", "tcurdt", "vijaysharm", "cdm2012"]
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :android].include?(platform)
+      end
+    end
+  end
+end

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/trainer.rb

@@ -0,0 +1,49 @@
+module Fastlane
+  module Actions
+    class TrainerAction < Action
+      def self.run(params)
+        require "trainer"
+
+        params[:path] = Actions.lane_context[Actions::SharedValues::SCAN_GENERATED_PLIST_FILE] if Actions.lane_context[Actions::SharedValues::SCAN_GENERATED_PLIST_FILE]
+        params[:path] ||= Actions.lane_context[Actions::SharedValues::SCAN_DERIVED_DATA_PATH] if Actions.lane_context[Actions::SharedValues::SCAN_DERIVED_DATA_PATH]
+
+        fail_build = params[:fail_build]
+        resulting_paths = Trainer::TestParser.auto_convert(params)
+        resulting_paths.each do |path, test_results|
+          UI.test_failure!("Unit tests failed") if fail_build && !test_results[:successful]
+        end
+
+        return resulting_paths
+      end
+
+      def self.description
+        "Convert the Xcode plist log to a JUnit report"
+      end
+
+      def self.detail
+        "Convert the Xcode plist log to a JUnit report. This will raise an exception if the tests failed"
+      end
+
+      def self.authors
+        ["KrauseFx"]
+      end
+
+      def self.return_value
+        "A hash with the key being the path of the generated file, the value being if the tests were successful"
+      end
+
+      def self.available_options
+        require 'trainer'
+        FastlaneCore::CommanderGenerator.new.generate(Trainer::Options.available_options)
+      end
+
+      def self.is_supported?(platform)
+        %i[ios mac].include?(platform)
+      end
+
+      def self.category
+        :testing
+      end
+    end
+  end
+end

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

@@ -0,0 +1,148 @@
+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",
+                                     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",
+                                     type: Integer,
+                                     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,
+                                     type: Integer,
+                                     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,84 @@
+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,
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :consumer_secret,
+                                       env_name: "FL_TW_CONSUMER_SECRET",
+                                       sensitive: true,
+                                       description: "Consumer Secret",
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :access_token,
+                                       env_name: "FL_TW_ACCESS_TOKEN",
+                                       sensitive: true,
+                                       description: "Access Token",
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :access_token_secret,
+                                       env_name: "FL_TW_ACCESS_TOKEN_SECRET",
+                                       sensitive: true,
+                                       description: "Access Token Secret",
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :message,
+                                       env_name: "FL_TW_MESSAGE",
+                                       description: "The tweet",
+                                       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