fastlane 2.131.0 → 2.135.1

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

@@ -33,7 +33,7 @@ module Fastlane
             req.url("/api/upload/")
             req.body = options
           end
-        rescue Faraday::Error::TimeoutError
+        rescue Faraday::TimeoutError
           UI.crash!("Uploading build to TestFairy timed out ⏳")
         end
       end

data/fastlane/lib/fastlane/actions/update_fastlane.rb

@@ -10,18 +10,10 @@ module Fastlane
       def self.run(options)
         return if options[:no_update] # this is used to update itself
 
-        tools_to_update = options[:tools].split(',') unless options[:tools].nil?
-        tools_to_update ||= all_installed_tools
-
-        if tools_to_update.count == 0
-          UI.error("No tools specified or couldn't find any installed fastlane.tools")
-          return
-        end
-
+        tools_to_update = ALL_TOOLS
         UI.message("Looking for updates for #{tools_to_update.join(', ')}...")
 
         updater = Gem::CommandManager.instance[:update]
-        updater.options[:prerelease] = true if options[:nightly]
         cleaner = Gem::CommandManager.instance[:cleanup]
 
         gem_dir = ENV['GEM_HOME'] || Gem.dir
@@ -49,7 +41,6 @@ module Fastlane
 
         if update_needed.count == 0
           UI.success("Nothing to update ✅")
-          show_information_about_nightly_builds unless options[:nightly]
           return
         end
 
@@ -58,18 +49,13 @@ module Fastlane
 
         update_needed.each do |tool_info|
           tool = tool_info[0]
-          gem_version = tool_info[1]
           local_version = Gem::Version.new(highest_versions[tool].version)
           latest_official_version = FastlaneCore::UpdateChecker.fetch_latest(tool)
 
-          if options[:nightly]
-            UI.message("Updating #{tool} from #{local_version.to_s.yellow} to nightly build #{gem_version.to_s.yellow}... (last official release #{latest_official_version.to_s.yellow}) 🚀")
-          else
-            UI.message("Updating #{tool} from #{local_version.to_s.yellow} to #{latest_official_version.to_s.yellow}... 🚀")
-          end
+          UI.message("Updating #{tool} from #{local_version.to_s.yellow} to #{latest_official_version.to_s.yellow}... 🚀")
 
           # Approximate_recommendation will create a string like "~> 0.10" from a version 0.10.0, e.g. one that is valid for versions >= 0.10 and <1.0
-          requirement_version = options[:nightly] ? gem_version : local_version.approximate_recommendation
+          requirement_version = local_version.approximate_recommendation
           updater.update_gem(tool, Gem::Requirement.new(requirement_version))
 
           UI.success("Finished updating #{tool}")
@@ -79,34 +65,12 @@ module Fastlane
         cleaner.options[:args] = tools_to_update
         cleaner.execute
 
-        if options[:nightly]
-          UI.success("Thanks for using fastlane's nightly builds! This makes it easier for everyone to detect regressions earlier.")
-          UI.success("Please submit an issue on GitHub if anything behaves differently than it should 🍪")
-        else
-          show_information_about_nightly_builds
-        end
-
         UI.message("fastlane.tools successfully updated! I will now restart myself... 😴")
 
         # Set no_update to true so we don't try to update again
         exec("FL_NO_UPDATE=true #{$PROGRAM_NAME} #{ARGV.join(' ')}")
       end
 
-      def self.show_information_about_nightly_builds
-        UI.message("")
-        UI.message("Please help us test early releases of fastlane by opting into nightly builds 🌃")
-        UI.message("Just replace your `update_fastlane` call with")
-        UI.message("")
-        UI.command_output("update_fastlane(nightly: true)")
-        UI.message("")
-        UI.message("Nightly builds are reviewed and tested just like the public releases 🚂")
-        UI.message("")
-      end
-
-      def self.all_installed_tools
-        Gem::Specification.select { |s| ALL_TOOLS.include?(s.name) }.map(&:name).uniq
-      end
-
       def self.description
         "Makes sure fastlane-tools are up-to-date when running fastlane"
       end
@@ -134,21 +98,17 @@ module Fastlane
 
       def self.available_options
         [
-          FastlaneCore::ConfigItem.new(key: :nightly,
-                                       env_name: "FL_UPDATE_FASTLANE_NIGHTLY",
-                                       description: "Opt-in to install and use nightly fastlane builds",
-                                       is_string: false,
-                                       default_value: false),
           FastlaneCore::ConfigItem.new(key: :no_update,
                                        env_name: "FL_NO_UPDATE",
                                        description: "Don't update during this run. This is used internally",
                                        is_string: false,
                                        default_value: false),
-          FastlaneCore::ConfigItem.new(key: :tools,
-                                       env_name: "FL_TOOLS_TO_UPDATE",
-                                       description: "Comma separated list of fastlane tools to update (e.g. `fastlane,deliver,sigh`)",
-                                       deprecated: true,
-                                       optional: true)
+          FastlaneCore::ConfigItem.new(key: :nightly,
+                                       env_name: "FL_UPDATE_FASTLANE_NIGHTLY",
+                                       description: "Opt-in to install and use nightly fastlane builds",
+                                       is_string: false,
+                                       default_value: false,
+                                       deprecated: "Nightly builds are no longer being made available")
         ]
       end
 

data/fastlane/lib/fastlane/actions/update_keychain_access_groups.rb

@@ -0,0 +1,94 @@
+module Fastlane
+  module Actions
+    module SharedValues
+      KEYCHAIN_ACCESS_GROUPS = :KEYCHAIN_ACCESS_GROUPS
+    end
+
+    class UpdateKeychainAccessGroupsAction < Action
+      require 'plist'
+
+      def self.run(params)
+        UI.message("Entitlements File: #{params[:entitlements_file]}")
+        UI.message("New keychain access groups: #{params[:identifiers]}")
+
+        entitlements_file = params[:entitlements_file]
+        UI.user_error!("Could not find entitlements file at path '#{entitlements_file}'") unless File.exist?(entitlements_file)
+
+        # parse entitlements
+        result = Plist.parse_xml(entitlements_file)
+        UI.user_error!("Entitlements file at '#{entitlements_file}' cannot be parsed.") unless result
+
+        # keychain access groups key
+        keychain_access_groups_key = 'keychain-access-groups'
+
+        # get keychain access groups
+        keychain_access_groups_field = result[keychain_access_groups_key]
+        UI.user_error!("No existing keychain access groups field specified. Please specify an keychain access groups in the entitlements file.") unless keychain_access_groups_field
+
+        # set new keychain access groups
+        UI.message("Old keychain access groups: #{keychain_access_groups_field}")
+        result[keychain_access_groups_key] = params[:identifiers]
+
+        # save entitlements file
+        result.save_plist(entitlements_file)
+        UI.message("New keychain access groups: #{result[keychain_access_groups_key]}")
+
+        Actions.lane_context[SharedValues::KEYCHAIN_ACCESS_GROUPS] = result[keychain_access_groups_key]
+      end
+
+      def self.description
+        "This action changes the keychain access groups in the entitlements file"
+      end
+
+      def self.details
+        "Updates the Keychain Group Access Groups in the given Entitlements file, so you can have keychain access groups for the app store build and keychain access groups for an enterprise build."
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :entitlements_file,
+                                       env_name: "FL_UPDATE_KEYCHAIN_ACCESS_GROUPS_ENTITLEMENTS_FILE_PATH", # The name of the environment variable
+                                       description: "The path to the entitlement file which contains the keychain access groups", # a short description of this parameter
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Please pass a path to an entitlements file. ") unless value.include?(".entitlements")
+                                         UI.user_error!("Could not find entitlements file") if !File.exist?(value) && !Helper.test?
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :identifiers,
+                                       env_name: "FL_UPDATE_KEYCHAIN_ACCESS_GROUPS_IDENTIFIERS",
+                                       description: "An Array of unique identifiers for the keychain access groups. Eg. ['your.keychain.access.groups.identifiers']",
+                                       is_string: false,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("The parameter identifiers need to be an Array.") unless value.kind_of?(Array)
+                                       end)
+        ]
+      end
+
+      def self.output
+        [
+          ['KEYCHAIN_ACCESS_GROUPS', 'The new Keychain Access Groups']
+        ]
+      end
+
+      def self.authors
+        ["yutae"]
+      end
+
+      def self.is_supported?(platform)
+        platform == :ios
+      end
+
+      def self.example_code
+        [
+          'update_keychain_access_groups(
+            entitlements_file: "/path/to/entitlements_file.entitlements",
+            identifiers: ["your.keychain.access.groups.identifiers"]
+          )'
+        ]
+      end
+
+      def self.category
+        :project
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/environment_printer.rb

@@ -50,11 +50,11 @@ module Fastlane
     end
 
     def self.print_loaded_plugins
-      ENV["FASTLANE_ENV_PRINTER"] = "enabled"
       env_output =  "### Loaded fastlane plugins:\n"
       env_output << "\n"
       plugin_manager = Fastlane::PluginManager.new
-      plugin_manager.load_plugins
+      plugin_manager.load_plugins(print_table: false)
+
       if plugin_manager.available_plugins.length <= 0
         env_output << "**No plugins Loaded**\n"
       else
@@ -211,7 +211,7 @@ module Fastlane
         "OS" => os_version,
         "Ruby" => RUBY_VERSION,
         "Bundler?" => Helper.bundler?,
-        "Git" => `git --version`.strip.split("\n").first,
+        "Git" => git_version,
         "Installation Source" => anonymized_path($PROGRAM_NAME),
         "Host" => "#{product} #{version} (#{build})",
         "Ruby Lib Dir" => anonymized_path(RbConfig::CONFIG['libdir']),
@@ -293,5 +293,11 @@ module Fastlane
       require 'open3'
       Open3.popen3('pbcopy') { |input, _, _| input << string }
     end
+
+    def self.git_version
+      return `git --version`.strip.split("\n").first
+    rescue
+      return "not found"
+    end
   end
 end

data/fastlane/lib/fastlane/fast_file.rb

@@ -26,10 +26,15 @@ module Fastlane
                 'you should turn off smart quotes in your editor of choice.')
       end
 
-      content.scan(/^\s*require (.*)/).each do |current|
+      content.scan(/^\s*require ["'](.*?)["']/).each do |current|
         gem_name = current.last
         next if gem_name.include?(".") # these are local gems
-        UI.important("You have required a gem, if this is a third party gem, please use `fastlane_require #{gem_name}` to ensure the gem is installed locally.")
+
+        begin
+          require(gem_name)
+        rescue LoadError
+          UI.important("You have required a gem, if this is a third party gem, please use `fastlane_require '#{gem_name}'` to ensure the gem is installed locally.")
+        end
       end
 
       parse(content, @path)
@@ -190,6 +195,7 @@ module Fastlane
     #  sh("ls")
     #  sh("ls", log: false)
     #  sh(command: "ls")
+    #  sh(command: "ls", step_name: "listing the files")
     #  sh(command: "ls", log: false)
     def sh(*args, &b)
       # First accepts hash (or named keywords) like other actions
@@ -207,8 +213,8 @@ module Fastlane
       end
     end
 
-    def self.sh(*command, log: true, error_callback: nil, &b)
-      command_header = log ? Actions.shell_command_from_args(*command) : "shell command"
+    def self.sh(*command, step_name: nil, log: true, error_callback: nil, &b)
+      command_header = log ? step_name || Actions.shell_command_from_args(*command) : "shell command"
       Actions.execute_action(command_header) do
         Actions.sh_no_action(*command, log: log, error_callback: error_callback, &b)
       end

data/fastlane/lib/fastlane/lane_manager.rb

@@ -113,7 +113,7 @@ module Fastlane
         rows: FastlaneCore::PrintTable.transform_output(rows)
       )
 
-      UI.message("Welcome to fastlane! Here's what your app is setup to do:")
+      UI.message("Welcome to fastlane! Here's what your app is set up to do:")
 
       puts(table)
 

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

@@ -278,7 +278,7 @@ module Fastlane
     #   fastlane-plugin-[plugin_name]
     # This will make sure to load the action
     # and all its helpers
-    def load_plugins
+    def load_plugins(print_table: true)
       UI.verbose("Checking if there are any plugins that should be loaded...")
 
       loaded_plugins = false
@@ -311,7 +311,7 @@ module Fastlane
         UI.error("Please follow the troubleshooting guide: #{TROUBLESHOOTING_URL}")
       end
 
-      skip_print_plugin_info = self.plugin_references.empty? || CLIToolsDistributor.running_version_command? || FastlaneCore::Env.truthy?("FASTLANE_ENV_PRINTER")
+      skip_print_plugin_info = self.plugin_references.empty? || CLIToolsDistributor.running_version_command? || !print_table
 
       # We want to avoid printing output other than the version number if we are running `fastlane -v`
       print_plugin_information(self.plugin_references) unless skip_print_plugin_info
@@ -319,9 +319,12 @@ module Fastlane
 
     # Prints a table all the plugins that were loaded
     def print_plugin_information(references)
+      no_action_found = false
+
       rows = references.collect do |current|
         if current[1][:actions].empty?
           # Something is wrong with this plugin, no available actions
+          no_action_found = true
           [current[0].red, current[1][:version_number], "No actions found".red]
         else
           [current[0], current[1][:version_number], current[1][:actions].join("\n")]
@@ -335,6 +338,13 @@ module Fastlane
         headings: ["Plugin", "Version", "Action"]
       }))
       puts("")
+
+      if no_action_found
+        puts("[!] No actions were found while loading one or more plugins".red)
+        puts("    Please use `bundle exec fastlane` with plugins".red)
+        puts("    More info - https://docs.fastlane.tools/plugins/using-plugins/#run-with-plugins".red)
+        puts("")
+      end
     end
 
     #####################################################

data/fastlane/lib/fastlane/plugins/template/.rubocop.yml

@@ -158,6 +158,7 @@ CrossPlatform/ForkUsage:
 Lint/IsStringUsage:
   Include:
   - gym/**/*
+  - supply/**/*
 Style/MethodCallWithArgsParentheses:
   Enabled: true
   IgnoredMethods:

data/fastlane/lib/fastlane/runner.rb

@@ -252,13 +252,13 @@ module Fastlane
               puts(class_ref.deprecated_notes.to_s.remove_markdown.deprecated) if class_ref.deprecated_notes
               puts("==========================================\n".deprecated)
             end
-            class_ref.runner = self # needed to call another action form an action
+            class_ref.runner = self # needed to call another action from an action
             return class_ref.run(arguments)
           end
         end
       rescue Interrupt => e
         raise e # reraise the interruption to avoid logging this as a crash
-      rescue FastlaneCore::Interface::FastlaneCommonException => e # these are exceptions that we dont count as crashes
+      rescue FastlaneCore::Interface::FastlaneCommonException => e # these are exceptions that we don't count as crashes
         raise e
       rescue FastlaneCore::Interface::FastlaneError => e # user_error!
         action_completed(method_sym.to_s, status: FastlaneCore::ActionCompletionStatus::USER_ERROR, exception: e)

data/fastlane/lib/fastlane/setup/setup_android.rb

@@ -55,7 +55,7 @@ module Fastlane
 
       self.package_name = UI.input("Package Name (com.krausefx.app): ")
       puts("")
-      puts("To automatically upload builds and metadata to Google Play, fastlane needs a service action json secret file".yellow)
+      puts("To automatically upload builds and metadata to Google Play, fastlane needs a service account json secret file".yellow)
       puts("Follow the Setup Guide on how to get the Json file: https://docs.fastlane.tools/actions/supply/".yellow)
       puts("Feel free to press Enter at any time in order to skip providing pieces of information when asked")
       self.json_key_file = UI.input("Path to the json secret file: ")

data/fastlane/lib/fastlane/swift_fastlane_api_generator.rb

@@ -439,13 +439,17 @@ func parseInt(fromString: String, function: String = #function) -> Int {
       if self.tools_option_files.include?(action_name.to_s.downcase)
         tool_swift_function = ToolSwiftFunction.new(
           action_name: action_name,
+          action_description: action.description,
+          action_details: action.details,
           keys: keys,
           key_descriptions: key_descriptions,
           key_default_values: key_default_values,
           key_optionality_values: key_optionality_values,
           key_type_overrides: key_type_overrides,
           key_is_strings: key_is_strings,
-          return_type: action_return_type
+          return_type: action_return_type,
+          return_value: action.return_value,
+          sample_return_value: action.sample_return_value
         )
         generated_protocol_file_path = generate_tool_protocol(tool_swift_function: tool_swift_function)
         self.generated_paths << generated_protocol_file_path unless generated_protocol_file_path.nil?
@@ -453,13 +457,17 @@ func parseInt(fromString: String, function: String = #function) -> Int {
       else
         return SwiftFunction.new(
           action_name: action_name,
+          action_description: action.description,
+          action_details: action.details,
           keys: keys,
           key_descriptions: key_descriptions,
           key_default_values: key_default_values,
           key_optionality_values: key_optionality_values,
           key_type_overrides: key_type_overrides,
           key_is_strings: key_is_strings,
-          return_type: action_return_type
+          return_type: action_return_type,
+          return_value: action.return_value,
+          sample_return_value: action.sample_return_value
         )
       end
     end

data/fastlane/lib/fastlane/swift_fastlane_function.rb

@@ -1,7 +1,11 @@
 module Fastlane
   class SwiftFunction
     attr_accessor :function_name
+    attr_accessor :function_description
+    attr_accessor :function_details
     attr_accessor :return_type
+    attr_accessor :return_value
+    attr_accessor :sample_return_value
     attr_accessor :param_names
     attr_accessor :param_descriptions
     attr_accessor :param_default_values
@@ -11,14 +15,18 @@ module Fastlane
     attr_accessor :reserved_words
     attr_accessor :default_values_to_ignore
 
-    def initialize(action_name: nil, keys: nil, key_descriptions: nil, key_default_values: nil, key_optionality_values: nil, key_type_overrides: nil, key_is_strings: nil, return_type: nil)
+    def initialize(action_name: nil, action_description: nil, action_details: nil, keys: nil, key_descriptions: nil, key_default_values: nil, key_optionality_values: nil, key_type_overrides: nil, key_is_strings: nil, return_type: nil, return_value: nil, sample_return_value: nil)
       @function_name = action_name
+      @function_description = action_description
+      @function_details = action_details
       @param_names = keys
       @param_descriptions = key_descriptions
       @param_default_values = key_default_values
       @param_optionality_values = key_optionality_values
       @param_is_strings = key_is_strings
       @return_type = return_type
+      @return_value = non_empty(string: return_value)
+      @sample_return_value = non_empty(string: sample_return_value)
       @param_type_overrides = key_type_overrides
 
       # rubocop:disable LineLength
@@ -34,6 +42,14 @@ module Fastlane
       return "`#{word}`"
     end
 
+    def non_empty(string: nil)
+      if string.nil? || string.to_s.empty?
+        return nil
+      else
+        return string
+      end
+    end
+
     def return_declaration
       expected_type = swift_type_for_return_type
       unless expected_type.to_s.length > 0
@@ -178,7 +194,54 @@ module Fastlane
       indent = ' ' * (discardable_result.length + function_name.length + function_keyword_definition.length + open_paren.length)
       params = self.parameters.join(",\n#{indent}")
 
-      return "#{discardable_result}#{function_keyword_definition}#{function_name}#{open_paren}#{params}#{closed_paren}#{function_return_declaration} {\n#{self.implementation}\n}"
+      return "#{swift_documentation}#{discardable_result}#{function_keyword_definition}#{function_name}#{open_paren}#{params}#{closed_paren}#{function_return_declaration} {\n#{self.implementation}\n}\n"
+    end
+
+    def swift_documentation
+      has_parameters = @param_names && @param_names.length > 0
+      unless @function_description || @function_details || has_parameters
+        return ''
+      end
+
+      description = " #{fix_documentation_indentation(string: @function_description)}" if @function_description
+      details = " #{fix_documentation_indentation(string: @function_details)}" if @function_details
+      separator = ''
+      documentation_elements = [description, swift_parameter_documentation, swift_return_value_documentation, details].compact
+      # Adds newlines between each documentation element.
+      documentation = documentation_elements.flat_map { |element| [element, separator] }.tap(&:pop).join("\n")
+
+      return "/**\n#{documentation}\n*/\n"
+    end
+
+    def swift_parameter_documentation
+      unless @param_names && @param_names.length > 0
+        return nil
+      end
+
+      names_and_descriptions = @param_names.zip(@param_descriptions)
+
+      if @param_names.length == 1
+        detail_strings = names_and_descriptions.map { |name, description| " - parameter #{camel_case_lower(string: name)}: #{description}" }
+        return detail_strings.first
+      else
+        detail_strings = names_and_descriptions.map { |name, description| "   - #{camel_case_lower(string: name)}: #{description}" }
+        return " - parameters:\n#{detail_strings.join("\n")}"
+      end
+    end
+
+    def swift_return_value_documentation
+      unless @return_value
+        return nil
+      end
+
+      sample = ". Example: #{@sample_return_value}" if @sample_return_value
+
+      return " - returns: #{return_value}#{sample}"
+    end
+
+    def fix_documentation_indentation(string: nil)
+      indent = ' '
+      string.gsub("\n", "\n#{indent}")
     end
 
     def build_argument_list
@@ -248,12 +311,18 @@ module Fastlane
       unless @param_names
         return []
       end
-      swift_vars = @param_names.zip(param_default_values, param_optionality_values, param_type_overrides).map do |param, default_value, optional, param_type_override|
+      swift_vars = @param_names.zip(param_default_values, param_optionality_values, param_type_overrides, param_descriptions).map do |param, default_value, optional, param_type_override, param_description|
         type = get_type(param: param, default_value: default_value, optional: optional, param_type_override: param_type_override)
 
         param = camel_case_lower(string: param)
         param = sanitize_reserved_word(word: param)
         static_var_for_parameter_name = param
+
+        if param_description
+          documentation = "  /// #{param_description}\n"
+        end
+
+        "\n#{documentation}"\
         "  var #{static_var_for_parameter_name}: #{type} { get }"
       end