fastlane 2.13.0 → 2.14.0

data/match/lib/match/git_helper.rb

@@ -46,7 +46,9 @@ module Match
       [
         "[fastlane]",
         "Updated",
-        params[:type].to_s
+        params[:type].to_s,
+        "and platform",
+        params[:platform]
       ].join(" ")
     end
 

data/match/lib/match/nuke.rb

@@ -13,7 +13,7 @@ module Match
 
       params[:workspace] = GitHelper.clone(params[:git_url], params[:shallow_clone], skip_docs: params[:skip_docs], branch: params[:git_branch])
 
-      had_app_identifier = self.params[:app_identifier]
+      had_app_identifier = self.params.fetch(:app_identifier, ask: false)
       self.params[:app_identifier] = '' # we don't really need a value here
       FastlaneCore::PrintTable.print_values(config: params,
                                          hide_keys: [:app_identifier, :workspace],
@@ -51,12 +51,16 @@ module Match
       UI.message "Fetching certificates and profiles..."
       cert_type = Match.cert_type_sym(type)
 
-      prov_types = [:development]
+      prov_types = []
+      prov_types = [:development] if cert_type == :development
       prov_types = [:appstore, :adhoc] if cert_type == :distribution
+      prov_types = [:enterprise] if cert_type == :enterprise
 
       Spaceship.login(params[:username])
       Spaceship.select_team
 
+      UI.user_error!("`fastlane match nuke` doesn't support enterprise accounts") if Spaceship.client.in_house?
+
       self.certs = certificate_type(cert_type).all
       self.profiles = []
       prov_types.each do |prov_type|
@@ -170,21 +174,21 @@ module Match
 
     # The kind of certificate we're interested in
     def certificate_type(type)
-      cert_type = Spaceship.certificate.production
-      cert_type = Spaceship.certificate.development if type == :development
-      cert_type = Spaceship.certificate.in_house if Match.enterprise? && Spaceship.client.in_house?
-
-      cert_type
+      {
+        distribution: Spaceship.certificate.production,
+        development:  Spaceship.certificate.development,
+        enterprise:   Spaceship.certificate.in_house
+      }[type] ||= raise "Unknown type '#{type}'"
     end
 
     # The kind of provisioning profile we're interested in
-    def profile_type(type)
-      profile_type = Spaceship.provisioning_profile.app_store
-      profile_type = Spaceship.provisioning_profile.in_house if Match.enterprise? && Spaceship.client.in_house?
-      profile_type = Spaceship.provisioning_profile.ad_hoc if type == :adhoc
-      profile_type = Spaceship.provisioning_profile.development if type == :development
-
-      profile_type
+    def profile_type(prov_type)
+      {
+        appstore:    Spaceship.provisioning_profile.app_store,
+        development: Spaceship.provisioning_profile.development,
+        enterprise:  Spaceship.provisioning_profile.in_house,
+        adhoc:       Spaceship.provisioning_profile.ad_hoc
+      }[prov_type] ||= raise "Unknown provisioning type '#{prov_type}'"
     end
   end
 end

data/match/lib/match/options.rb

@@ -19,7 +19,7 @@ module Match
                                      default_value: 'master'),
         FastlaneCore::ConfigItem.new(key: :type,
                                      env_name: "MATCH_TYPE",
-                                     description: "Create a development certificate instead of a distribution one",
+                                     description: "Define the profile type, can be #{Match.environments.join(', ')}",
                                      is_string: true,
                                      short_option: "-y",
                                      default_value: 'development',
@@ -117,7 +117,18 @@ module Match
                                      env_name: "MATCH_SKIP_DOCS",
                                      description: "Skip generation of a README.md for the created git repository",
                                      is_string: false,
-                                     default_value: false)
+                                     default_value: false),
+        FastlaneCore::ConfigItem.new(key: :platform,
+                                     short_option: '-o',
+                                     env_name: "MATCH_PLATFORM",
+                                     description: "Set the provisioning profile's platform to work with (i.e. ios, tvos)",
+                                     is_string: false,
+                                     default_value: "ios",
+                                     verify_block: proc do |value|
+                                       value = value.to_s
+                                       pt = %w(tvos ios)
+                                       UI.user_error!("Unsupported platform, must be: #{pt}") unless pt.include?(value)
+                                     end)
       ]
     end
   end

data/match/lib/match/runner.rb

@@ -8,10 +8,14 @@ module Match
                                          hide_keys: [:workspace],
                                              title: "Summary for match #{Fastlane::VERSION}")
 
-      UI.error("Enterprise profiles are currently not officially supported in _match_, you might run into issues") if Match.enterprise?
-
       params[:workspace] = GitHelper.clone(params[:git_url], params[:shallow_clone], skip_docs: params[:skip_docs], branch: params[:git_branch])
-      self.spaceship = SpaceshipEnsure.new(params[:username]) unless params[:readonly]
+
+      unless params[:readonly]
+        self.spaceship = SpaceshipEnsure.new(params[:username])
+        if params[:type] == "enterprise" && !Spaceship.client.in_house?
+          UI.user_error!("You defined the profile type 'enterprise', but your Apple account doesn't support In-House profiles")
+        end
+      end
 
       if params[:app_identifier].kind_of?(Array)
         app_identifiers = params[:app_identifier]
@@ -47,7 +51,7 @@ module Match
 
       # Print a summary table for each app_identifier
       app_identifiers.each do |app_identifier|
-        TablePrinter.print_summary(app_identifier: app_identifier, type: params[:type])
+        TablePrinter.print_summary(app_identifier: app_identifier, type: params[:type], platform: params[:platform])
       end
 
       UI.success "All required keys, certificates and provisioning profiles are installed 🙌".green
@@ -98,7 +102,11 @@ module Match
     def fetch_provisioning_profile(params: nil, certificate_id: nil, app_identifier: nil)
       prov_type = Match.profile_type_sym(params[:type])
 
-      profile_name = [Match::Generator.profile_type_name(prov_type), app_identifier].join("_").gsub("*", '\*') # this is important, as it shouldn't be a wildcard
+      names = [Match::Generator.profile_type_name(prov_type), app_identifier]
+      if params[:platform].to_s != :ios.to_s
+        names.push(params[:platform])
+      end
+      profile_name = names.join("_").gsub("*", '\*') # this is important, as it shouldn't be a wildcard
       base_dir = File.join(params[:workspace], "profiles", prov_type.to_s)
       profiles = Dir[File.join(base_dir, "#{profile_name}.mobileprovision")]
 
@@ -139,16 +147,20 @@ module Match
       end
 
       Utils.fill_environment(Utils.environment_variable_name(app_identifier: app_identifier,
-                                                                       type: prov_type),
+                                                                       type: prov_type,
+                                                                   platform: params[:platform]),
+
                              uuid)
 
       # TeamIdentifier is returned as an array, but we're not sure why there could be more than one
       Utils.fill_environment(Utils.environment_variable_name_team_id(app_identifier: app_identifier,
-                                                                               type: prov_type),
+                                                                               type: prov_type,
+                                                                           platform: params[:platform]),
                              parsed["TeamIdentifier"].first)
 
       Utils.fill_environment(Utils.environment_variable_name_profile_name(app_identifier: app_identifier,
-                                                                                    type: prov_type),
+                                                                                    type: prov_type,
+                                                                                platform: params[:platform]),
                              parsed["Name"])
 
       return uuid

data/match/lib/match/table_printer.rb

@@ -14,18 +14,19 @@ module Match
       UI.error(ex)
     end
 
-    def self.print_summary(app_identifier: nil, type: nil)
+    def self.print_summary(app_identifier: nil, type: nil, platform: :ios)
       rows = []
 
       type = type.to_sym
 
       rows << ["App Identifier", "", app_identifier]
       rows << ["Type", "", type]
+      rows << ["Platform", "", platform.to_s]
 
       {
-        Utils.environment_variable_name(app_identifier: app_identifier, type: type) => "Profile UUID",
-        Utils.environment_variable_name_profile_name(app_identifier: app_identifier, type: type) => "Profile Name",
-        Utils.environment_variable_name_team_id(app_identifier: app_identifier, type: type) => "Development Team ID"
+        Utils.environment_variable_name(app_identifier: app_identifier, type: type, platform: platform) => "Profile UUID",
+        Utils.environment_variable_name_profile_name(app_identifier: app_identifier, type: type, platform: platform) => "Profile Name",
+        Utils.environment_variable_name_team_id(app_identifier: app_identifier, type: type, platform: platform) => "Development Team ID"
       }.each do |env_key, name|
         rows << [name, env_key, ENV[env_key]]
       end

data/match/lib/match/utils.rb

@@ -11,16 +11,16 @@ module Match
       ENV[key] = value
     end
 
-    def self.environment_variable_name(app_identifier: nil, type: nil)
-      base_environment_variable_name(app_identifier: app_identifier, type: type).join("_")
+    def self.environment_variable_name(app_identifier: nil, type: nil, platform: :ios)
+      base_environment_variable_name(app_identifier: app_identifier, type: type, platform: platform).join("_")
     end
 
-    def self.environment_variable_name_team_id(app_identifier: nil, type: nil)
-      (base_environment_variable_name(app_identifier: app_identifier, type: type) + ["team-id"]).join("_")
+    def self.environment_variable_name_team_id(app_identifier: nil, type: nil, platform: :ios)
+      (base_environment_variable_name(app_identifier: app_identifier, type: type, platform: platform) + ["team-id"]).join("_")
     end
 
-    def self.environment_variable_name_profile_name(app_identifier: nil, type: nil)
-      (base_environment_variable_name(app_identifier: app_identifier, type: type) + ["profile-name"]).join("_")
+    def self.environment_variable_name_profile_name(app_identifier: nil, type: nil, platform: :ios)
+      (base_environment_variable_name(app_identifier: app_identifier, type: type, platform: platform) + ["profile-name"]).join("_")
     end
 
     def self.get_cert_info(cer_certificate_path)
@@ -52,8 +52,12 @@ module Match
       return {}
     end
 
-    def self.base_environment_variable_name(app_identifier: nil, type: nil)
-      ["sigh", app_identifier, type]
+    def self.base_environment_variable_name(app_identifier: nil, type: nil, platform: :ios)
+      if platform.to_s == :ios.to_s
+        ["sigh", app_identifier, type] # We keep the ios profiles without the platform for backwards compatibility
+      else
+        ["sigh", app_identifier, type, platform.to_s]
+      end
     end
   end
 end

data/scan/lib/scan/options.rb

@@ -125,6 +125,28 @@ module Scan
                                      env_name: "SCAN_FORMATTER",
                                      description: "A custom xcpretty formatter to use",
                                      optional: true),
+
+        FastlaneCore::ConfigItem.new(key: :test_without_building,
+                                     short_option: "-T",
+                                     env_name: "SCAN_TEST_WITHOUT_BUILDING",
+                                     description: "Test without building, requires a derrived data path",
+                                     is_string: false,
+                                     conflicting_options: [:build_for_testing],
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :build_for_testing,
+                                     short_option: "-B",
+                                     env_name: "SCAN_BUILD_FOR_TESTING",
+                                     description: "Build for testing only, does not run tests",
+                                     conflicting_options: [:test_without_building],
+                                     is_string: false,
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :xctestrun,
+                                     short_option: "-X",
+                                     env_name: "SCAN_XCTESTRUN",
+                                     description: "Run tests using the provided .xctestrun file",
+                                     conflicting_options: [:test_without_building, :build_for_testing],
+                                     is_string: true,
+                                     optional: true),
         FastlaneCore::ConfigItem.new(key: :derived_data_path,
                                      short_option: "-j",
                                      env_name: "SCAN_DERIVED_DATA_PATH",
@@ -162,7 +184,8 @@ module Scan
                                      short_option: "-x",
                                      env_name: "SCAN_XCARGS",
                                      description: "Pass additional arguments to xcodebuild. Be sure to quote the setting names and values e.g. OTHER_LDFLAGS=\"-ObjC -lstdc++\"",
-                                     optional: true),
+                                     optional: true,
+                                     type: :shell_string),
         FastlaneCore::ConfigItem.new(key: :xcconfig,
                                      short_option: "-y",
                                      env_name: "SCAN_XCCONFIG",

data/scan/lib/scan/runner.rb

@@ -16,7 +16,6 @@ module Scan
       # This way it's okay to just call it for the first simulator we're using for
       # the first test run
       open_simulator_for_device(Scan.devices.first) if Scan.devices
-
       command = TestCommandGenerator.generate
       prefix_hash = [
         {
@@ -80,17 +79,9 @@ module Scan
       })
       puts ""
 
-      report_collector.parse_raw_file(TestCommandGenerator.xcodebuild_log_path)
+      copy_simulator_logs
 
-      if Scan.config[:include_simulator_logs]
-        Scan.devices.each do |device|
-          sim_device_logfilepath_source = File.expand_path("~/Library/Logs/CoreSimulator/#{device.udid}/system.log")
-          if File.exist?(sim_device_logfilepath_source)
-            sim_device_logfilepath_dest = File.join(Scan.config[:output_directory], "#{device.name}_#{device.os_type}_#{device.os_version}_system.log")
-            FileUtils.cp(sim_device_logfilepath_source, sim_device_logfilepath_dest)
-          end
-        end
-      end
+      report_collector.parse_raw_file(TestCommandGenerator.xcodebuild_log_path)
 
       unless tests_exit_status == 0
         UI.user_error!("Test execution failed. Exit status: #{tests_exit_status}")
@@ -101,6 +92,16 @@ module Scan
       end
     end
 
+    def copy_simulator_logs
+      return unless Scan.config[:include_simulator_logs]
+
+      UI.header("Collecting system logs")
+      Scan.devices.each do |device|
+        logarchive_dest = File.join(Scan.config[:output_directory], "system_logs-#{device.name}_#{device.os_type}_#{device.os_version}.logarchive")
+        FastlaneCore::Simulator.copy_logarchive(device, logarchive_dest)
+      end
+    end
+
     def open_simulator_for_device(device)
       return unless FastlaneCore::Env.truthy?('FASTLANE_EXPLICIT_OPEN_SIMULATOR')
 

data/scan/lib/scan/test_command_generator.rb

@@ -39,6 +39,7 @@ module Scan
         options << "-enableAddressSanitizer #{config[:address_sanitizer] ? 'YES' : 'NO'}" unless config[:address_sanitizer].nil?
         options << "-enableThreadSanitizer #{config[:thread_sanitizer] ? 'YES' : 'NO'}" unless config[:thread_sanitizer].nil?
         options << "-xcconfig '#{config[:xcconfig]}'" if config[:xcconfig]
+        options << "-xctestrun '#{config[:xctestrun]}'" if config[:xctestrun]
         options << config[:xcargs] if config[:xcargs]
 
         # detect_values will ensure that these values are present as Arrays if
@@ -54,8 +55,15 @@ module Scan
 
         actions = []
         actions << :clean if config[:clean]
-        actions << :build unless config[:skip_build]
-        actions << :test
+
+        if config[:build_for_testing]
+          actions << "build-for-testing"
+        elsif config[:test_without_building] || config[:xctestrun]
+          actions << "test-without-building"
+        else
+          actions << :build unless config[:skip_build]
+          actions << :test
+        end
 
         actions
       end

data/sigh/lib/sigh/download_all.rb

@@ -23,7 +23,7 @@ module Sigh
       type_name = profile.class.pretty_type
       type_name = "AdHoc" if profile.is_adhoc?
 
-      profile_name = "#{type_name}_#{profile.app.bundle_id}.mobileprovision" # default name
+      profile_name = "#{type_name}_#{profile.uuid}_#{profile.app.bundle_id}.mobileprovision" # default name
 
       output_path = File.join(Sigh.config[:output_path], profile_name)
       File.open(output_path, "wb") do |f|

data/sigh/lib/sigh/runner.rb

@@ -132,13 +132,13 @@ module Sigh
                                 bundle_id: bundle_id,
                               certificate: cert,
                                       mac: Sigh.config[:platform].to_s == 'macos',
-                             sub_platform: Sigh.config[:platform].to_s == 'tvos' ? 'tvos' : nil)
+                             sub_platform: Sigh.config[:platform].to_s == 'tvos' ? 'tvOS' : nil)
       profile
     end
 
     def certificates_for_profile_and_platform
       case Sigh.config[:platform].to_s
-      when 'ios'
+      when 'ios', 'tvos'
         if profile_type == Spaceship.provisioning_profile.Development
           certificates = Spaceship.certificate.development.all
         elsif profile_type == Spaceship.provisioning_profile.InHouse

data/snapshot/lib/snapshot/options.rb

@@ -33,7 +33,8 @@ module Snapshot
                                      short_option: "-X",
                                      env_name: "SNAPSHOT_XCARGS",
                                      description: "Pass additional arguments to xcodebuild for the test phase. Be sure to quote the setting names and values e.g. OTHER_LDFLAGS=\"-ObjC -lstdc++\"",
-                                     optional: true),
+                                     optional: true,
+                                     type: :shell_string),
         FastlaneCore::ConfigItem.new(key: :devices,
                                      description: "A list of devices you want to take the screenshots from",
                                      short_option: "-d",

data/snapshot/lib/snapshot/runner.rb

@@ -51,6 +51,8 @@ module Snapshot
             UI.message("snapshot run #{current_run} of #{number_of_runs}")
 
             results[device][language] = run_for_device_and_language(language, locale, device, launch_arguments)
+
+            copy_simulator_logs(device, language, locale, launch_arguments)
           end
         end
       end
@@ -62,10 +64,6 @@ module Snapshot
       # Generate HTML report
       ReportsGenerator.new.generate
 
-      if Snapshot.config[:output_simulator_logs]
-        output_simulator_logs
-      end
-
       # Clear the Derived Data
       unless Snapshot.config[:derived_data_path]
         FileUtils.rm_rf(TestCommandGenerator.derived_data_path)
@@ -100,15 +98,17 @@ module Snapshot
       end
     end
 
-    def output_simulator_logs
-      Snapshot.config[:devices].each do |device_name|
-        device = TestCommandGenerator.find_device(device_name)
-        sim_device_logfilepath_source = File.expand_path("~/Library/Logs/CoreSimulator/#{device.udid}/system.log")
-        next unless File.exist?(sim_device_logfilepath_source)
+    def copy_simulator_logs(device_name, language, locale, launch_arguments)
+      return unless Snapshot.config[:output_simulator_logs]
 
-        sim_device_logfilepath_dest = File.join(Snapshot.config[:output_directory], "#{device.name}_#{device.os_type}_#{device.os_version}_system.log")
-        FileUtils.cp(sim_device_logfilepath_source, sim_device_logfilepath_dest)
-      end
+      detected_language = locale || language
+      language_folder = File.join(Snapshot.config[:output_directory], detected_language)
+      device = TestCommandGenerator.find_device(device_name)
+      components = [launch_arguments].delete_if { |a| a.to_s.length == 0 }
+
+      UI.header("Collecting system logs #{device_name} - #{language}")
+      logarchive_dest = File.join(language_folder, "system_logs-" + Digest::MD5.hexdigest(components.join("-")) + ".logarchive")
+      FastlaneCore::Simulator.copy_logarchive(device, logarchive_dest)
     end
 
     def print_results(results)

data/spaceship/lib/spaceship.rb

@@ -27,6 +27,7 @@ module Spaceship
   AppSubmission = Spaceship::Tunes::AppSubmission
   Application = Spaceship::Tunes::Application
   Members = Spaceship::Tunes::Members
+  Persons = Spaceship::Portal::Persons
 
   DESCRIPTION = "Ruby library to access the Apple Dev Center and iTunes Connect".freeze
 end

data/spaceship/lib/spaceship/base.rb

@@ -217,20 +217,43 @@ module Spaceship
     #####################################################
 
     def inspect
-      inspectables = self.attributes
+      # To avoid circular references, we keep track of the references
+      # of all objects already inspected from the first call to inspect
+      # in this call stack
+      # We use a Thread local storage for multi-thread friendliness
+      thread = Thread.current
+      tree_root = thread[:inspected_objects].nil?
+      thread[:inspected_objects] = Set.new if tree_root
 
-      value = inspectables.map do |k|
+      if thread[:inspected_objects].include? self
+        # already inspected objects have a default value,
+        # let's follow Ruby's convention for circular references
+        value = "#<Object ...>"
+      else
+        thread[:inspected_objects].add self
+        begin
+          value = inspect_value
+        ensure
+          thread[:inspected_objects] = nil if tree_root
+        end
+      end
+
+      "<#{self.class.name} \n#{value}>"
+    end
+
+    def inspect_value
+      self.attributes.map do |k|
         v = self.send(k).inspect
         v.gsub!("\n", "\n\t") # to align nested elements
 
         "\t#{k}=#{v}"
       end.join(", \n")
-
-      "<#{self.class.name} \n#{value}>"
     end
 
     def to_s
       self.inspect
     end
+
+    private :inspect_value
   end
 end