fastlane 2.178.0 → 2.182.0

data/fastlane/lib/fastlane/actions/sourcedocs.rb

@@ -0,0 +1,164 @@
+module Fastlane
+  module Actions
+    class SourcedocsAction < Action
+      def self.run(params)
+        UI.user_error!("You have to install sourcedocs using `brew install sourcedocs`") if `which sourcedocs`.to_s.length == 0 && !Helper.test?
+
+        command =  "sourcedocs generate"
+        command << " --all-modules" if params[:all_modules]
+        command << " --spm-module #{params[:spm_module]}" unless params[:spm_module].nil?
+        command << " --module-name #{params[:module_name]}" unless params[:module_name].nil?
+        command << " --link-beginning #{params[:link_beginning]}" unless params[:link_beginning].nil?
+        command << " --link-ending #{params[:link_ending]}" unless params[:link_ending].nil?
+        command << " --output-folder #{params[:output_folder]}" unless params[:output_folder].nil?
+        command << " --min-acl #{params[:min_acl]}" unless params[:min_acl].nil?
+        command << " --module-name-path" if params[:module_name_path]
+        command << " --clean" if params[:clean]
+        command << " --collapsible" if params[:collapsible]
+        command << " --table-of-contents" if params[:table_of_contents]
+        command << " --reproducible-docs" if params[:reproducible]
+        unless params[:scheme].nil?
+          command << " -- -scheme #{params[:scheme]}"
+          command << " -sdk #{params[:sdk_platform]}" unless params[:sdk_platform].nil?
+        end
+        Actions.sh(command)
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Generate docs using SourceDocs"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(
+            key: :all_modules,
+            env_name: 'FL_SOURCEDOCS_OUTPUT_ALL_MODULES',
+            description: 'Generate documentation for all modules in a Swift package',
+            type: Boolean,
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :spm_module,
+            env_name: 'FL_SOURCEDOCS_SPM_MODULE',
+            description: 'Generate documentation for Swift Package Manager module',
+            type: String,
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :module_name,
+            env_name: 'FL_SOURCEDOCS_MODULE_NAME',
+            description: 'Generate documentation for a Swift module',
+            type: String,
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :link_beginning,
+            env_name: 'FL_SOURCEDOCS_LINK_BEGINNING',
+            description: 'The text to begin links with',
+            type: String,
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :link_ending,
+            env_name: 'FL_SOURCEDOCS_LINK_ENDING',
+            description: 'The text to end links with (default: .md)',
+            type: String,
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :output_folder,
+            env_name: 'FL_SOURCEDOCS_OUTPUT_FOLDER',
+            description: 'Output directory to clean (default: Documentation/Reference)',
+            type: String,
+            optional: false
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :min_acl,
+            env_name: 'FL_SOURCEDOCS_MIN_ACL',
+            description: 'Access level to include in documentation [private, fileprivate, internal, public, open] (default: public)',
+            type: String,
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :module_name_path,
+            env_name: 'FL_SOURCEDOCS_MODULE_NAME_PATH',
+            description: 'Include the module name as part of the output folder path',
+            type: Boolean,
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :clean,
+            env_name: 'FL_SOURCEDOCS_CLEAN',
+            description: 'Delete output folder before generating documentation',
+            type: Boolean,
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :collapsible,
+            env_name: 'FL_SOURCEDOCS_COLLAPSIBLE',
+            description: 'Put methods, properties and enum cases inside collapsible blocks',
+            type: Boolean,
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :table_of_contents,
+            env_name: 'FL_SOURCEDOCS_TABLE_OF_CONTENT',
+            description: 'Generate a table of contents with properties and methods for each type',
+            type: Boolean,
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :reproducible,
+            env_name: 'FL_SOURCEDOCS_REPRODUCIBLE',
+            description: 'Generate documentation that is reproducible: only depends on the sources',
+            type: Boolean,
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :scheme,
+            env_name: 'FL_SOURCEDOCS_SCHEME',
+            description: 'Create documentation for specific scheme',
+            type: String,
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :sdk_platform,
+            env_name: 'FL_SOURCEDOCS_SDK_PlATFORM',
+            description: 'Create documentation for specific sdk platform',
+            type: String,
+            optional: true
+          )
+        ]
+      end
+
+      def self.output
+      end
+
+      def self.return_value
+      end
+
+      def self.authors
+        ["Kukurijek"]
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include?(platform)
+      end
+
+      def self.example_code
+        [
+          "sourcedocs(output_folder: 'docs')",
+          "sourcedocs(output_folder: 'docs', clean: true, reproducible: true, scheme: 'MyApp')"
+        ]
+      end
+
+      def self.category
+        :documentation
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/spaceship_logs.rb

@@ -124,7 +124,7 @@ module Fastlane
       end
 
       def self.return_type
-        :array
+        :array_of_strings
       end
 
       def self.author

data/fastlane/lib/fastlane/actions/update_project_provisioning.rb

@@ -21,9 +21,8 @@ module Fastlane
         # download certificate
         unless File.exist?(params[:certificate])
           UI.message("Downloading root certificate from (#{ROOT_CERTIFICATE_URL}) to path '#{params[:certificate]}'")
-          require 'open-uri'
           File.open(params[:certificate], "w:ASCII-8BIT") do |file|
-            file.write(open(ROOT_CERTIFICATE_URL, "rb").read)
+            file.write(FastlaneCore::Helper.open_uri(ROOT_CERTIFICATE_URL, "rb").read)
           end
         end
 

data/fastlane/lib/fastlane/actions/upload_symbols_to_crashlytics.rb

@@ -5,8 +5,10 @@ module Fastlane
         require 'tmpdir'
 
         find_binary_path(params)
-        find_gsp_path(params)
-        find_api_token(params)
+        unless params[:app_id]
+          find_gsp_path(params)
+          find_api_token(params)
+        end
 
         if !params[:app_id] && !params[:gsp_path] && !params[:api_token]
           UI.user_error!('Either Firebase Crashlytics App ID, path to GoogleService-Info.plist or legacy Fabric API key must be given.')

data/fastlane/lib/fastlane/cli_tools_distributor.rb

@@ -23,7 +23,7 @@ module Fastlane
       def take_off
         before_import_time = Time.now
 
-        if !ENV["FASTLANE_DISABLE_ANIMATION"]
+        if ENV["FASTLANE_DISABLE_ANIMATION"].nil?
           # Usually in the fastlane code base we use
           #
           #   Helper.show_loading_indicator

data/fastlane/lib/fastlane/commands_generator.rb

@@ -1,5 +1,6 @@
 require 'commander'
 require 'fastlane/new_action'
+require 'fastlane_core/ui/help_formatter'
 
 HighLine.track_eof = false
 
@@ -85,7 +86,7 @@ module Fastlane
       program :help, 'Author', 'Felix Krause <fastlane@krausefx.com>'
       program :help, 'Website', 'https://fastlane.tools'
       program :help, 'GitHub', 'https://github.com/fastlane/fastlane'
-      program :help_formatter, :compact
+      program :help_formatter, FastlaneCore::HelpFormatter
 
       global_option('--verbose') { FastlaneCore::Globals.verbose = true }
       global_option('--capture_output', 'Captures the output of the current run, and generates a markdown issue template') do

data/fastlane/lib/fastlane/fast_file.rb

@@ -284,7 +284,7 @@ module Fastlane
 
         action_launched('import_from_git')
 
-        is_eligible_for_caching = !version.nil? && !cache_path.nil?
+        is_eligible_for_caching = !cache_path.nil?
 
         UI.message("Eligible for caching") if is_eligible_for_caching
 
@@ -338,7 +338,15 @@ module Fastlane
             UI.user_error!("No tag found matching #{version.inspect}") if checkout_param.nil?
           end
 
-          Actions.sh("cd #{clone_folder.shellescape} && git checkout #{checkout_param.shellescape} #{checkout_path}")
+          if is_eligible_for_caching && version.nil?
+            # Update the repo if it's eligible for caching but the version isn't specified
+            UI.message("Fetching remote git branches and updating git repo...")
+            Helper.with_env_values('GIT_TERMINAL_PROMPT' => '0') do
+              Actions.sh("cd #{clone_folder.shellescape} && git fetch --all --quiet && git checkout #{checkout_param.shellescape} #{checkout_path} && git reset --hard && git rebase")
+            end
+          else
+            Actions.sh("cd #{clone_folder.shellescape} && git checkout #{checkout_param.shellescape} #{checkout_path}")
+          end
 
           # Knowing that we check out all the files and directories when the
           # current call is eligible for caching, we don't need to also

data/fastlane/lib/fastlane/fastlane_require.rb

@@ -59,8 +59,14 @@ module Fastlane
 
       def find_gem_name(user_supplied_name)
         fetcher = Gem::SpecFetcher.fetcher
-        gems = fetcher.suggest_gems_from_name(user_supplied_name)
 
+        # RubyGems 3.2.0 changed behavior of suggest_gems_from_name to no longer return user supplied name (only similar suggestions)
+        # First search for exact gem with detect then use suggest_gems_from_name
+        if (detected_gem = fetcher.detect(:latest) { |nt| nt.name == user_supplied_name }.first)
+          return detected_gem[0].name
+        end
+
+        gems = fetcher.suggest_gems_from_name(user_supplied_name)
         return gems.first
       end
 

data/fastlane/lib/fastlane/helper/git_helper.rb

@@ -2,6 +2,13 @@ module Fastlane
   module Actions
     GIT_MERGE_COMMIT_FILTERING_OPTIONS = [:include_merges, :exclude_merges, :only_include_merges].freeze
 
+    module SharedValues
+      GIT_BRANCH_ENV_VARS = %w(GIT_BRANCH BRANCH_NAME TRAVIS_BRANCH BITRISE_GIT_BRANCH CI_BUILD_REF_NAME CI_COMMIT_REF_NAME WERCKER_GIT_BRANCH BUILDKITE_BRANCH APPCENTER_BRANCH CIRCLE_BRANCH).reject do |branch|
+        # Removing because tests break on CircleCI
+        Helper.test? && branch == "CIRCLE_BRANCH"
+      end.freeze
+    end
+
     def self.git_log_between(pretty_format, from, to, merge_commit_filtering, date_format = nil, ancestry_path)
       command = %w(git log)
       command << "--pretty=#{pretty_format}"
@@ -112,14 +119,19 @@ module Fastlane
       return nil
     end
 
-    # Returns the current git branch - can be replaced using the environment variable `GIT_BRANCH`
+    # Returns the current git branch, or "HEAD" if it's not checked out to any branch
+    # Can be replaced using the environment variable `GIT_BRANCH`
     def self.git_branch
-      return ENV['GIT_BRANCH'] if ENV['GIT_BRANCH'].to_s.length > 0 # set by Jenkins
-      s = Actions.sh("git rev-parse --abbrev-ref HEAD", log: false).chomp
-      return s.to_s.strip if s.to_s.length > 0
-      nil
-    rescue
-      nil
+      env_name = SharedValues::GIT_BRANCH_ENV_VARS.find { |env_var| FastlaneCore::Env.truthy?(env_var) }
+      ENV.fetch(env_name.to_s) do
+        # Rescues if not a git repo or no commits in a git repo
+        begin
+          Actions.sh("git rev-parse --abbrev-ref HEAD", log: false).chomp
+        rescue => err
+          UI.verbose("Error getting git branch: #{err.message}")
+          nil
+        end
+      end
     end
 
     private_class_method

data/fastlane/lib/fastlane/lane_manager.rb

@@ -107,12 +107,13 @@ module Fastlane
 
       puts(table)
 
+      fastlane_command = Helper.bundler? ? "bundle exec fastlane" : "fastlane"
       i = UI.input("Which number would you like run?")
 
       i = i.to_i - 1
       if i >= 0 && available[i]
         selection = available[i].last.pretty_name
-        UI.important("Running lane `#{selection}`. Next time you can do this by directly typing `fastlane #{selection}` 🚀.")
+        UI.important("Running lane `#{selection}`. Next time you can do this by directly typing `#{fastlane_command} #{selection}` 🚀.")
         platform = selection.split(' ')[0]
         lane_name = selection.split(' ')[1]
 
@@ -123,7 +124,7 @@ module Fastlane
 
         return platform, lane_name # yeah
       else
-        UI.user_error!("Run `fastlane` the next time you need to build, test or release your app 🚀")
+        UI.user_error!("Run `#{fastlane_command}` the next time you need to build, test or release your app 🚀")
       end
     end
   end

data/fastlane/lib/fastlane/notification/slack.rb

@@ -0,0 +1,56 @@
+module Fastlane
+  module Notification
+    class Slack
+      def initialize(webhook_url)
+        @webhook_url = webhook_url
+        @client = Faraday.new do |conn|
+          conn.use(Faraday::Response::RaiseError)
+        end
+      end
+
+      # Overriding channel, icon_url and username is only supported in legacy incoming webhook.
+      # Also note that the use of attachments has been discouraged by Slack, in favor of Block Kit.
+      # https://api.slack.com/legacy/custom-integrations/messaging/webhooks
+      def post_to_legacy_incoming_webhook(channel:, username:, attachments:, link_names:, icon_url:)
+        @client.post(@webhook_url) do |request|
+          request.headers['Content-Type'] = 'application/json'
+          request.body = {
+            channel: channel,
+            username: username,
+            icon_url: icon_url,
+            attachments: attachments,
+            link_names: link_names
+          }.to_json
+        end
+      end
+
+      # This class was inspired by `LinkFormatter` in `slack-notifier` gem
+      # https://github.com/stevenosloan/slack-notifier/blob/4bf6582663dc9e5070afe3fdc42d67c14a513354/lib/slack-notifier/util/link_formatter.rb
+      class LinkConverter
+        HTML_PATTERN = %r{<a.*?href=['"](?<link>#{URI.regexp})['"].*?>(?<label>.+?)<\/a>}
+        MARKDOWN_PATTERN = /\[(?<label>[^\[\]]*?)\]\((?<link>#{URI.regexp}|mailto:#{URI::MailTo::EMAIL_REGEXP})\)/
+
+        def self.convert(string)
+          convert_markdown_to_slack_link(convert_html_to_slack_link(string.scrub))
+        end
+
+        def self.convert_html_to_slack_link(string)
+          string.gsub(HTML_PATTERN) do |match|
+            slack_link(Regexp.last_match[:link], Regexp.last_match[:label])
+          end
+        end
+
+        def self.convert_markdown_to_slack_link(string)
+          string.gsub(MARKDOWN_PATTERN) do |match|
+            slack_link(Regexp.last_match[:link], Regexp.last_match[:label])
+          end
+        end
+
+        def self.slack_link(href, text)
+          return "<#{href}>" if text.nil? || text.empty?
+          "<#{href}|#{text}>"
+        end
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/plugins/plugin_fetcher.rb

@@ -7,14 +7,13 @@ module Fastlane
     # Returns an array of FastlanePlugin objects
     def self.fetch_gems(search_query: nil)
       require 'json'
-      require 'open-uri'
 
       page = 1
       plugins = []
       loop do
         url = "https://rubygems.org/api/v1/search.json?query=#{PluginManager.plugin_prefix}&page=#{page}"
         FastlaneCore::UI.verbose("RubyGems API Request: #{url}")
-        results = JSON.parse(open(url).read)
+        results = JSON.parse(FastlaneCore::Helper.open_uri(url).read)
         break if results.count == 0
 
         plugins += results.collect do |current|

data/fastlane/lib/fastlane/plugins/plugin_info.rb

@@ -33,11 +33,11 @@ module Fastlane
 
     # Used to expose a local binding for use in ERB templating
     #
-    # rubocop:disable Style/AccessorMethodName
+    # rubocop:disable Naming/AccessorMethodName
     def get_binding
       binding
     end
-    # rubocop:enable Style/AccessorMethodName
+    # rubocop:enable Naming/AccessorMethodName
 
     def ==(other)
       @plugin_name == other.plugin_name &&

data/fastlane/lib/fastlane/plugins/plugin_info_collector.rb

@@ -65,10 +65,9 @@ module Fastlane
 
     # Checks if the gem name is still free on RubyGems
     def gem_name_taken?(name)
-      require 'open-uri'
       require 'json'
       url = "https://rubygems.org/api/v1/gems/#{name}.json"
-      response = JSON.parse(open(url).read)
+      response = JSON.parse(FastlaneCore::Helper.open_uri(url).read)
       return !!response['version']
     rescue
       false

data/fastlane/lib/fastlane/plugins/plugin_manager.rb

@@ -155,11 +155,10 @@ module Fastlane
     #####################################################
 
     def self.fetch_gem_info_from_rubygems(gem_name)
-      require 'open-uri'
       require 'json'
       url = "https://rubygems.org/api/v1/gems/#{gem_name}.json"
       begin
-        JSON.parse(URI.open(url).read)
+        JSON.parse(FastlaneCore::Helper.open_uri(url).read)
       rescue
         nil
       end