fastlane 2.129.0 → 2.134.0

data/fastlane/lib/fastlane/helper/crashlytics_helper.rb

@@ -108,7 +108,7 @@ module Fastlane
 
             UI.important("Downloading Crashlytics Support Library - this might take a minute...")
             result = http_conn.request_get(uri.path)
-            UI.error!("#{result.message} (#{result.code})") unless result.kind_of?(Net::HTTPSuccess)
+            UI.error("#{result.message} (#{result.code})") unless result.kind_of?(Net::HTTPSuccess)
             File.write(zip_path, result.body)
 
             # Now unzip the file

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

@@ -178,6 +178,7 @@ module Fastlane
       with_clean_bundler_env do
         cmd = "bundle install"
         cmd << " --quiet" unless FastlaneCore::Globals.verbose?
+        cmd << " && bundle exec fastlane generate_swift" if FastlaneCore::FastlaneFolder.swift?
         cmd << " && echo 'Successfully installed plugins'"
         UI.command(cmd) if FastlaneCore::Globals.verbose?
         exec(cmd)
@@ -197,6 +198,7 @@ module Fastlane
         cmd = "bundle update"
         cmd << " #{plugins.join(' ')}"
         cmd << " --quiet" unless FastlaneCore::Globals.verbose?
+        cmd << " && bundle exec fastlane generate_swift" if FastlaneCore::FastlaneFolder.swift?
         cmd << " && echo 'Successfully updated plugins'"
         UI.command(cmd) if FastlaneCore::Globals.verbose?
         exec(cmd)

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

@@ -155,6 +155,9 @@ Style/CollectionMethods:
 CrossPlatform/ForkUsage:
   Exclude:
   - "**/plugins/template/**/*"
+Lint/IsStringUsage:
+  Include:
+  - gym/**/*
 Style/MethodCallWithArgsParentheses:
   Enabled: true
   IgnoredMethods:

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

@@ -13,28 +13,18 @@ module Fastlane
     end
   end
 
-  class SwiftFastlaneAPIGenerator
-    DEFAULT_API_VERSION_STRING = "0.9.1"
-    attr_accessor :tools_option_files
-    attr_accessor :actions_not_supported
-    attr_accessor :action_options_to_ignore
-    attr_accessor :target_output_path
-    attr_accessor :generated_paths # stores all file names of generated files (as they are generated)
+  class SwiftAPIGenerator
+  end
 
+  class SwiftFastlaneAPIGenerator < SwiftAPIGenerator
     def initialize(target_output_path: "swift")
+      @target_filename = "Fastlane.swift"
       @target_output_path = File.expand_path(target_output_path)
       @generated_paths = []
-      require 'fastlane'
-      require 'fastlane/documentation/actions_list'
-      Fastlane.load_actions
-      # Tools that can be used with <Toolname>file, like Deliverfile, Screengrabfile
-      # this is important because we need to generate the proper api for these by creating a protocol
-      # with default implementation we can use in the Fastlane.swift API if people want to use
-      # <Toolname>file.swift files.
-      self.tools_option_files = TOOL_CONFIG_FILES.map { |config_file| config_file.downcase.chomp("file") }.to_set
 
-      self.actions_not_supported = ["import", "import_from_git"].to_set
+      super()
 
+      self.actions_not_supported = ["import", "import_from_git"].to_set
       self.action_options_to_ignore = {
 
         "precheck" => [
@@ -51,6 +41,109 @@ module Fastlane
       }
     end
 
+    def extend_content(file_content, tool_details)
+      file_content << "" # newline because we're adding an extension
+      file_content << "// These are all the parsing functions needed to transform our data into the expected types"
+      file_content << generate_lanefile_parsing_functions
+
+      tool_objects = generate_lanefile_tool_objects(classes: tool_details.map(&:swift_class))
+      file_content << tool_objects
+
+      old_file_content = File.read(fastlane_swift_api_path)
+      new_file_content = file_content.join("\n")
+
+      # compare old file content to potential new file content
+      api_version = determine_api_version(new_file_content: new_file_content, old_file_content: old_file_content)
+      old_api_version = find_api_version_string(content: old_file_content)
+
+      # if there is a change, we need to write out the new file
+      if api_version != old_api_version
+        file_content << autogen_version_warning_text(api_version: api_version)
+      else
+        file_content = nil
+      end
+
+      return file_content
+    end
+  end
+
+  class SwiftActionsAPIGenerator < SwiftAPIGenerator
+    def initialize(target_output_path: "swift")
+      @target_filename = "Actions.swift"
+      @target_output_path = File.expand_path(target_output_path)
+      @generated_paths = []
+
+      super()
+
+      # Excludes all actions that aren't external actions (including plugins)
+      available_external_actions = Fastlane.external_actions || []
+      available_actions = []
+      ActionsList.all_actions do |action|
+        available_actions << action.action_name unless available_external_actions.include?(action)
+      end
+
+      self.actions_not_supported = (["import", "import_from_git"] + available_actions).to_set
+      self.action_options_to_ignore = {}
+    end
+  end
+
+  class SwiftPluginsAPIGenerator < SwiftAPIGenerator
+    def initialize(target_output_path: "swift")
+      @target_filename = "Plugins.swift"
+      @target_output_path = File.expand_path(target_output_path)
+      @generated_paths = []
+
+      super()
+
+      # Gets list of plugin actions
+      plugin_actions = Fastlane.plugin_manager.plugin_references.values.flat_map do |info|
+        info[:actions]
+      end
+
+      # Action references from plugins
+      available_plugins = plugin_actions.map do |plugin_action|
+        Fastlane::Runner.new.class_reference_from_action_name(plugin_action)
+      end
+
+      # Excludes all actions that aren't pluign actions (including external actions)
+      available_actions = []
+      ActionsList.all_actions do |action|
+        available_actions << action.action_name unless available_plugins.include?(action)
+      end
+
+      self.actions_not_supported = (["import", "import_from_git"] + available_actions).to_set
+      self.action_options_to_ignore = {}
+    end
+  end
+
+  class SwiftAPIGenerator
+    DEFAULT_API_VERSION_STRING = "0.9.1"
+    attr_accessor :tools_option_files
+    attr_accessor :actions_not_supported
+    attr_accessor :action_options_to_ignore
+    attr_accessor :target_output_path
+    attr_accessor :target_filename
+    attr_accessor :generated_paths # stores all file names of generated files (as they are generated)
+
+    attr_accessor :fastlane_swift_api_path
+
+    def initialize
+      require 'fastlane'
+      require 'fastlane/documentation/actions_list'
+      Fastlane.load_actions
+      # Tools that can be used with <Toolname>file, like Deliverfile, Screengrabfile
+      # this is important because we need to generate the proper api for these by creating a protocol
+      # with default implementation we can use in the Fastlane.swift API if people want to use
+      # <Toolname>file.swift files.
+      self.tools_option_files = TOOL_CONFIG_FILES.map { |config_file| config_file.downcase.chomp("file") }.to_set
+
+      @fastlane_swift_api_path = File.join(@target_output_path, @target_filename)
+    end
+
+    def extend_content(content, tool_details)
+      return content
+    end
+
     def generate_swift
       self.generated_paths = [] # reset generated paths in case we're called multiple times
       file_content = []
@@ -74,24 +167,11 @@ module Fastlane
 
         file_content << swift_function.swift_code
       end
-      file_content << "" # newline because we're adding an extension
-      file_content << "// These are all the parsing functions needed to transform our data into the expected types"
-      file_content << generate_lanefile_parsing_functions
-
-      tool_objects = generate_lanefile_tool_objects(classes: tool_details.map(&:swift_class))
-      file_content << tool_objects
-      new_file_content = file_content.join("\n")
-
-      fastlane_swift_api_path = File.join(@target_output_path, "Fastlane.swift")
-      old_file_content = File.read(fastlane_swift_api_path)
 
-      # compare old file content to potential new file content
-      api_version = determine_api_version(new_file_content: new_file_content, old_file_content: old_file_content)
-      old_api_version = find_api_version_string(content: old_file_content)
+      file_content = extend_content(file_content, tool_details)
 
-      # if there is a change, we need to write out the new file
-      if api_version != old_api_version
-        new_file_content.concat(autogen_version_warning_text(api_version: api_version))
+      if file_content
+        new_file_content = file_content.join("\n")
 
         File.write(fastlane_swift_api_path, new_file_content)
         UI.success(fastlane_swift_api_path)
@@ -359,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?
@@ -373,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
 

data/fastlane/lib/fastlane/swift_runner_upgrader.rb

@@ -90,6 +90,10 @@ module Fastlane
       source_file_content = File.read(source)
       target_file_content = File.read(target)
 
+      # ignore if files don't contain FastlaneRunnerAPIVersion
+      return false unless source_file_content.include?("FastlaneRunnerAPIVersion")
+      return false unless target_file_content.include?("FastlaneRunnerAPIVersion")
+
       bundled_version = source_file_content.match(regex_to_use)[1]
       target_version = target_file_content.match(regex_to_use)[1]
       file_versions_are_different = bundled_version != target_version

data/fastlane/lib/fastlane/version.rb

@@ -1,5 +1,5 @@
 module Fastlane
-  VERSION = '2.129.0'.freeze
+  VERSION = '2.134.0'.freeze
   DESCRIPTION = "The easiest way to automate beta deployments and releases for your iOS and Android apps".freeze
   MINIMUM_XCODE_RELEASE = "7.0".freeze
   RUBOCOP_REQUIREMENT = '0.49.1'.freeze

data/fastlane/swift/Actions.swift

@@ -0,0 +1,15 @@
+// This class is automatically included in FastlaneRunner during build
+
+// This autogenerated file will be overwritten or replaced when running "fastlane generate_swift"
+//
+//  ** NOTE **
+//  This file is provided by fastlane and WILL be overwritten in future updates
+//  If you want to add extra functionality to this project, create a new file in a
+//  new group so that it won't be marked for upgrade
+//
+
+import Foundation
+
+// Please don't remove the lines below
+// They are used to detect outdated files
+// FastlaneRunnerAPIVersion [0.9.56]

data/fastlane/swift/Deliverfile.swift

@@ -18,4 +18,4 @@ class Deliverfile: DeliverfileProtocol {
 
 
 
-// Generated with fastlane 2.129.0
+// Generated with fastlane 2.134.0

data/fastlane/swift/DeliverfileProtocol.swift

@@ -1,63 +1,183 @@
 protocol DeliverfileProtocol: class {
+
+  /// Your Apple ID Username
   var username: String { get }
+
+  /// The bundle identifier of your app
   var appIdentifier: String? { get }
+
+  /// The version that should be edited or created
   var appVersion: String? { get }
+
+  /// Path to your ipa file
   var ipa: String? { get }
+
+  /// Path to your pkg file
   var pkg: String? { get }
+
+  /// If set the given build number (already uploaded to iTC) will be used instead of the current built one
   var buildNumber: String? { get }
+
+  /// The platform to use (optional)
   var platform: String { get }
+
+  /// Modify live metadata, this option disables ipa upload and screenshot upload
   var editLive: Bool { get }
+
+  /// Force usage of live version rather than edit version
   var useLiveVersion: Bool { get }
+
+  /// Path to the folder containing the metadata files
   var metadataPath: String? { get }
+
+  /// Path to the folder containing the screenshots
   var screenshotsPath: String? { get }
+
+  /// Skip uploading an ipa or pkg to App Store Connect
   var skipBinaryUpload: Bool { get }
+
+  /// Don't upload the screenshots
   var skipScreenshots: Bool { get }
+
+  /// Don't upload the metadata (e.g. title, description). This will still upload screenshots
   var skipMetadata: Bool { get }
+
+  /// Don't update app version for submission
   var skipAppVersionUpdate: Bool { get }
+
+  /// Skip the HTML report file verification
   var force: Bool { get }
+
+  /// Clear all previously uploaded screenshots before uploading the new ones
   var overwriteScreenshots: Bool { get }
+
+  /// Submit the new version for Review after uploading everything
   var submitForReview: Bool { get }
+
+  /// Rejects the previously submitted build if it's in a state where it's possible
   var rejectIfPossible: Bool { get }
+
+  /// Should the app be automatically released once it's approved?
   var automaticRelease: Bool { get }
+
+  /// Date in milliseconds for automatically releasing on pending approval
   var autoReleaseDate: String? { get }
+
+  /// Enable the phased release feature of iTC
   var phasedRelease: Bool { get }
+
+  /// Reset the summary rating when you release a new version of the application
   var resetRatings: Bool { get }
+
+  /// The price tier of this application
   var priceTier: String? { get }
+
+  /// Path to the app rating's config
   var appRatingConfigPath: String? { get }
+
+  /// Extra information for the submission (e.g. compliance specifications, IDFA settings)
   var submissionInformation: String? { get }
+
+  /// The ID of your App Store Connect team if you're in multiple teams
   var teamId: String? { get }
+
+  /// The name of your App Store Connect team if you're in multiple teams
   var teamName: String? { get }
+
+  /// The short ID of your Developer Portal team, if you're in multiple teams. Different from your iTC team ID!
   var devPortalTeamId: String? { get }
+
+  /// The name of your Developer Portal team if you're in multiple teams
   var devPortalTeamName: String? { get }
+
+  /// The provider short name to be used with the iTMSTransporter to identify your team. This value will override the automatically detected provider short name. To get provider short name run `pathToXcode.app/Contents/Applications/Application\ Loader.app/Contents/itms/bin/iTMSTransporter -m provider -u 'USERNAME' -p 'PASSWORD' -account_type itunes_connect -v off`. The short names of providers should be listed in the second column
   var itcProvider: String? { get }
+
+  /// Run precheck before submitting to app review
   var runPrecheckBeforeSubmit: Bool { get }
+
+  /// The default precheck rule level unless otherwise configured
   var precheckDefaultRuleLevel: String { get }
+
+  /// An array of localized metadata items to upload individually by language so that errors can be identified. E.g. ['name', 'keywords', 'description']. Note: slow
   var individualMetadataItems: [String] { get }
+
+  /// Metadata: The path to the app icon
   var appIcon: String? { get }
+
+  /// Metadata: The path to the Apple Watch app icon
   var appleWatchAppIcon: String? { get }
+
+  /// Metadata: The copyright notice
   var copyright: String? { get }
+
+  /// Metadata: The english name of the primary category (e.g. `Business`, `Books`)
   var primaryCategory: String? { get }
+
+  /// Metadata: The english name of the secondary category (e.g. `Business`, `Books`)
   var secondaryCategory: String? { get }
+
+  /// Metadata: The english name of the primary first sub category (e.g. `Educational`, `Puzzle`)
   var primaryFirstSubCategory: String? { get }
+
+  /// Metadata: The english name of the primary second sub category (e.g. `Educational`, `Puzzle`)
   var primarySecondSubCategory: String? { get }
+
+  /// Metadata: The english name of the secondary first sub category (e.g. `Educational`, `Puzzle`)
   var secondaryFirstSubCategory: String? { get }
+
+  /// Metadata: The english name of the secondary second sub category (e.g. `Educational`, `Puzzle`)
   var secondarySecondSubCategory: String? { get }
+
+  /// Metadata: A hash containing the trade representative contact information
   var tradeRepresentativeContactInformation: [String : Any]? { get }
+
+  /// Metadata: A hash containing the review information
   var appReviewInformation: [String : Any]? { get }
+
+  /// Metadata: Path to the app review attachment file
   var appReviewAttachmentFile: String? { get }
+
+  /// Metadata: The localised app description
   var description: String? { get }
+
+  /// Metadata: The localised app name
   var name: String? { get }
+
+  /// Metadata: The localised app subtitle
   var subtitle: [String : Any]? { get }
+
+  /// Metadata: An array of localised keywords
   var keywords: [String : Any]? { get }
+
+  /// Metadata: An array of localised promotional texts
   var promotionalText: [String : Any]? { get }
+
+  /// Metadata: Localised release notes for this version
   var releaseNotes: String? { get }
+
+  /// Metadata: Localised privacy url
   var privacyUrl: String? { get }
+
+  /// Metadata: Localised Apple TV privacy policy text
   var appleTvPrivacyPolicy: String? { get }
+
+  /// Metadata: Localised support url
   var supportUrl: String? { get }
+
+  /// Metadata: Localised marketing url
   var marketingUrl: String? { get }
+
+  /// Metadata: List of languages to activate
   var languages: [String]? { get }
+
+  /// Ignore errors when invalid languages are found in metadata and screenshot directories
   var ignoreLanguageDirectoryValidation: Bool { get }
+
+  /// Should precheck check in-app purchases?
   var precheckIncludeInAppPurchases: Bool { get }
+
+  /// The (spaceship) app ID of the app you want to use/modify
   var app: String { get }
 }
 
@@ -126,4 +246,4 @@ extension DeliverfileProtocol {
 
 // Please don't remove the lines below
 // They are used to detect outdated files
-// FastlaneRunnerAPIVersion [0.9.8]
+// FastlaneRunnerAPIVersion [0.9.18]