fastlane 1.111.0 → 2.0.1

data/snapshot/lib/snapshot/reports_generator.rb

@@ -0,0 +1,64 @@
+require 'erb'
+require 'fastimage'
+
+module Snapshot
+  class ReportsGenerator
+    def generate
+      UI.message "Generating HTML Report"
+
+      screens_path = Snapshot.config[:output_directory]
+
+      @data = {}
+
+      Dir[File.join(screens_path, "*")].sort.each do |language_folder|
+        language = File.basename(language_folder)
+        Dir[File.join(language_folder, '*.png')].sort.each do |screenshot|
+          available_devices.each do |key_name, output_name|
+            next unless File.basename(screenshot).include?(key_name)
+
+            # This screenshot is from this device
+            @data[language] ||= {}
+            @data[language][output_name] ||= []
+
+            resulting_path = File.join('.', language, File.basename(screenshot))
+            @data[language][output_name] << resulting_path
+            break # to not include iPhone 6 and 6 Plus (name is contained in the other name)
+          end
+        end
+      end
+
+      html_path = File.join(Snapshot::ROOT, "lib", "snapshot/page.html.erb")
+      html = ERB.new(File.read(html_path)).result(binding) # http://www.rrn.dk/rubys-erb-templating-system
+
+      export_path = "#{screens_path}/screenshots.html"
+      File.write(export_path, html)
+
+      export_path = File.expand_path(export_path)
+      UI.success "Successfully created HTML file with an overview of all the screenshots: '#{export_path}'"
+      system("open '#{export_path}'") unless Snapshot.config[:skip_open_summary]
+    end
+
+    private
+
+    def available_devices
+      # The order IS important, since those names are used to check for include?
+      # and the iPhone 6 is inlucded in the iPhone 6 Plus
+      {
+        'AppleTV1080p' => 'Apple TV',
+        'iPhone7Plus' => "iPhone7Plus (5.5-Inch)",
+        'iPhone7' => "iPhone7 (4.7-Inch)",
+        'iPhone6sPlus' => "iPhone6sPlus (5.5-Inch)",
+        'iPhone6Plus' => "iPhone6Plus (5.5-Inch)",
+        'iPhone6s' => "iPhone6s (4.7-Inch)",
+        'iPhone6' => "iPhone6 (4.7-Inch)",
+        'iPhone5' => "iPhone5 (4-Inch)",
+        'iPhone4' => "iPhone4 (3.5-Inch)",
+        'iPadPro(9.7inch)' => "iPad Pro (9.7 inch)",
+        'iPadPro(12.9inch)' => "iPad Pro (12.9 inch)",
+        'iPad Pro' => "iPad Pro",
+        'iPad' => "iPad",
+        'Mac' => "Mac"
+      }
+    end
+  end
+end

data/snapshot/lib/snapshot/reset_simulators.rb

@@ -0,0 +1,88 @@
+module Snapshot
+  class ResetSimulators
+    def self.clear_everything!(ios_versions, force = false)
+      # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+      # !! Warning: This script will remove all your existing simulators !!
+      # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+      sure = true if ENV["SNAPSHOT_FORCE_DELETE"] ||  force
+      sure = agree("Are you sure? All your simulators will be DELETED and new ones will be created! (y/n)".red, true) unless sure
+      UI.user_error!("User cancelled action") unless sure
+
+      devices.each do |device|
+        _, name, id = device
+        puts "Removing device #{name} (#{id})"
+        `xcrun simctl delete #{id}`
+      end
+
+      all_runtimes = `xcrun simctl list runtimes`.lines.map { |s| s.slice(/(.*?) \(/, 1) }.compact
+      tv_versions = filter_runtimes(all_runtimes, 'tvOS')
+      watch_versions = filter_runtimes(all_runtimes, 'watchOS')
+
+      all_device_types = `xcrun simctl list devicetypes`.scan(/(.*)\s\((.*)\)/)
+      # == Device Types ==
+      # iPhone 4s (com.apple.CoreSimulator.SimDeviceType.iPhone-4s)
+      # iPhone 5 (com.apple.CoreSimulator.SimDeviceType.iPhone-5)
+      # iPhone 5s (com.apple.CoreSimulator.SimDeviceType.iPhone-5s)
+      # iPhone 6 (com.apple.CoreSimulator.SimDeviceType.iPhone-6)
+      all_device_types.each do |device_type|
+        if device_type.join(' ').include?("Watch")
+          create(device_type, watch_versions, 'watchOS')
+        elsif device_type.join(' ').include?("TV")
+          create(device_type, tv_versions, 'tvOS')
+        else
+          create(device_type, ios_versions)
+        end
+      end
+
+      make_phone_watch_pair
+    end
+
+    def self.create(device_type, os_versions, os_name = 'iOS')
+      os_versions.each do |os_version|
+        puts "Creating #{device_type} for #{os_name} version #{os_version}"
+        `xcrun simctl create '#{device_type[0]}' #{device_type[1]} #{os_version}`
+      end
+    end
+
+    def self.filter_runtimes(all_runtimes, os = 'iOS')
+      all_runtimes.select { |r| r[/^#{os}/] }.map { |r| r.split(' ')[1] }
+    end
+
+    def self.devices
+      all_devices = Helper.backticks('xcrun simctl list devices', print: $verbose)
+      # == Devices ==
+      # -- iOS 9.0 --
+      #   iPhone 4s (32246EBC-33B0-47F9-B7BB-5C23C550DF29) (Shutdown)
+      #   iPhone 5 (4B56C101-6B95-43D1-9485-3FBA0E127FFA) (Shutdown)
+      #   iPhone 5s (6379C204-E82A-4FBD-8A22-6A01C7791D62) (Shutdown)
+      # -- Unavailable: com.apple.CoreSimulator.SimRuntime.iOS-8-4 --
+      #   iPhone 4s (FE9D6F85-1C51-4FE6-8597-FCAB5286B869) (Shutdown) (unavailable, runtime profile not found)
+
+      result = all_devices.lines.map do |line|
+        (line.match(/\s+(.+?)\s\(([\w\-]+)\).*/) || []).to_a
+      end
+
+      result.select { |parsed| parsed.length == 3 } # we don't care about those headers
+    end
+
+    def self.make_phone_watch_pair
+      phones = []
+      watches = []
+      devices.each do |device|
+        full_line, name, id = device
+        phones << id if name.start_with?('iPhone 6') && device_line_usable?(full_line)
+        watches << id if name.end_with?('mm') && device_line_usable?(full_line)
+      end
+
+      if phones.any? && watches.any?
+        puts "Creating device pair of #{phones.last} and #{watches.last}"
+        Helper.backticks("xcrun simctl pair #{watches.last} #{phones.last}", print: $verbose)
+      end
+    end
+
+    def self.device_line_usable?(line)
+      !line.include?("unavailable")
+    end
+  end
+end

data/snapshot/lib/snapshot/runner.rb

@@ -0,0 +1,294 @@
+require 'shellwords'
+require 'plist'
+
+module Snapshot
+  class Runner
+    # The number of times we failed on launching the simulator... sigh
+    attr_accessor :number_of_retries_due_to_failing_simulator
+
+    # All the errors we experience while running snapshot
+    attr_accessor :collected_errors
+
+    def work
+      if File.exist?("./fastlane/snapshot.js") or File.exist?("./snapshot.js")
+        UI.error "Found old snapshot configuration file 'snapshot.js'"
+        UI.error "You updated to snapshot 1.0 which now uses UI Automation"
+        UI.error "Please follow the migration guide: https://github.com/fastlane/fastlane/blob/master/snapshot/MigrationGuide.md"
+        UI.error "And read the updated documentation: https://github.com/fastlane/fastlane/tree/master/snapshot"
+        sleep 3 # to be sure the user sees this, as compiling clears the screen
+      end
+
+      Snapshot.config[:output_directory] = File.expand_path(Snapshot.config[:output_directory])
+
+      verify_helper_is_current
+
+      # Also print out the path to the used Xcode installation
+      # We go 2 folders up, to not show "Contents/Developer/"
+      values = Snapshot.config.values(ask: false)
+      values[:xcode_path] = File.expand_path("../..", FastlaneCore::Helper.xcode_path)
+      FastlaneCore::PrintTable.print_values(config: values, hide_keys: [], title: "Summary for snapshot #{Fastlane::VERSION}")
+
+      clear_previous_screenshots if Snapshot.config[:clear_previous_screenshots]
+
+      UI.success "Building and running project - this might take some time..."
+
+      self.number_of_retries_due_to_failing_simulator = 0
+      self.collected_errors = []
+      results = {} # collect all the results for a nice table
+      launch_arguments_set = config_launch_arguments
+      Snapshot.config[:devices].each_with_index do |device, device_index|
+        launch_arguments_set.each do |launch_arguments|
+          Snapshot.config[:languages].each_with_index do |language, language_index|
+            locale = nil
+            if language.kind_of?(Array)
+              locale = language[1]
+              language = language[0]
+            end
+            results[device] ||= {}
+
+            current_run = device_index * Snapshot.config[:languages].count + language_index + 1
+            number_of_runs = Snapshot.config[:languages].count * Snapshot.config[:devices].count
+            UI.message("snapshot run #{current_run} of #{number_of_runs}")
+
+            results[device][language] = run_for_device_and_language(language, locale, device, launch_arguments)
+          end
+        end
+      end
+
+      print_results(results)
+
+      UI.user_error!(self.collected_errors.join('; ')) if self.collected_errors.count > 0
+
+      # Generate HTML report
+      ReportsGenerator.new.generate
+
+      # Clear the Derived Data
+      unless Snapshot.config[:derived_data_path]
+        FileUtils.rm_rf(TestCommandGenerator.derived_data_path)
+      end
+    end
+
+    # This is its own method so that it can re-try if the tests fail randomly
+    # @return true/false depending on if the tests succeded
+    def run_for_device_and_language(language, locale, device, launch_arguments, retries = 0)
+      return launch(language, locale, device, launch_arguments)
+    rescue => ex
+      UI.error ex.to_s # show the reason for failure to the user, but still maybe retry
+
+      if retries < Snapshot.config[:number_of_retries]
+        UI.important "Tests failed, re-trying #{retries + 1} out of #{Snapshot.config[:number_of_retries] + 1} times"
+        run_for_device_and_language(language, locale, device, launch_arguments, retries + 1)
+      else
+        UI.error "Backtrace:\n\t#{ex.backtrace.join("\n\t")}" if $verbose
+        self.collected_errors << ex
+        raise ex if Snapshot.config[:stop_after_first_error]
+        return false # for the results
+      end
+    end
+
+    def config_launch_arguments
+      launch_arguments = Array(Snapshot.config[:launch_arguments])
+      # if more than 1 set of arguments, use a tuple with an index
+      if launch_arguments.count == 1
+        [launch_arguments]
+      else
+        launch_arguments.map.with_index { |e, i| [i, e] }
+      end
+    end
+
+    def print_results(results)
+      return if results.count == 0
+
+      rows = []
+      results.each do |device, languages|
+        current = [device]
+        languages.each do |language, value|
+          current << (value == true ? " 💚" : " ❌")
+        end
+        rows << current
+      end
+
+      params = {
+        rows: rows,
+        headings: ["Device"] + results.values.first.keys,
+        title: "snapshot results"
+      }
+      puts ""
+      puts Terminal::Table.new(params)
+      puts ""
+    end
+
+    # Returns true if it succeded
+    def launch(language, locale, device_type, launch_arguments)
+      screenshots_path = TestCommandGenerator.derived_data_path
+      FileUtils.rm_rf(File.join(screenshots_path, "Logs"))
+      FileUtils.rm_rf(screenshots_path) if Snapshot.config[:clean]
+      FileUtils.mkdir_p(screenshots_path)
+
+      prefix = File.join(Dir.home, "Library/Caches/tools.fastlane")
+      FileUtils.mkdir_p(prefix)
+      File.write(File.join(prefix, "language.txt"), language)
+      File.write(File.join(prefix, "locale.txt"), locale || "")
+      File.write(File.join(prefix, "snapshot-launch_arguments.txt"), launch_arguments.last)
+
+      # Kill and shutdown all currently running simulators so that the following settings
+      # changes will be picked up when they are started again.
+      Snapshot.kill_simulator # because of https://github.com/fastlane/snapshot/issues/337
+      `xcrun simctl shutdown booted &> /dev/null`
+
+      Fixes::SimulatorZoomFix.patch
+      Fixes::HardwareKeyboardFix.patch
+
+      if Snapshot.config[:erase_simulator] || Snapshot.config[:localize_simulator]
+        erase_simulator(device_type)
+        if Snapshot.config[:localize_simulator]
+          localize_simulator(device_type, language, locale)
+        end
+      elsif Snapshot.config[:reinstall_app]
+        # no need to reinstall if device has been erased
+        uninstall_app(device_type)
+      end
+
+      add_media(device_type, :photo, Snapshot.config[:add_photos]) if Snapshot.config[:add_photos]
+      add_media(device_type, :video, Snapshot.config[:add_videos]) if Snapshot.config[:add_videos]
+
+      open_simulator_for_device(device_type)
+
+      command = TestCommandGenerator.generate(device_type: device_type)
+
+      if locale
+        UI.header("#{device_type} - #{language} (#{locale})")
+      else
+        UI.header("#{device_type} - #{language}")
+      end
+
+      prefix_hash = [
+        {
+          prefix: "Running Tests: ",
+          block: proc do |value|
+            value.include?("Touching")
+          end
+        }
+      ]
+
+      FastlaneCore::CommandExecutor.execute(command: command,
+                                          print_all: true,
+                                      print_command: true,
+                                             prefix: prefix_hash,
+                                            loading: "Loading...",
+                                              error: proc do |output, return_code|
+                                                ErrorHandler.handle_test_error(output, return_code)
+
+                                                # no exception raised... that means we need to retry
+                                                UI.error "Caught error... #{return_code}"
+
+                                                self.number_of_retries_due_to_failing_simulator += 1
+                                                if self.number_of_retries_due_to_failing_simulator < 20
+                                                  launch(language, locale, device_type, launch_arguments)
+                                                else
+                                                  # It's important to raise an error, as we don't want to collect the screenshots
+                                                  UI.crash!("Too many errors... no more retries...")
+                                                end
+                                              end)
+
+      raw_output = File.read(TestCommandGenerator.xcodebuild_log_path)
+
+      dir_name = locale || language
+
+      return Collector.fetch_screenshots(raw_output, dir_name, device_type, launch_arguments.first)
+    end
+
+    def open_simulator_for_device(device_name)
+      return unless ENV['FASTLANE_EXPLICIT_OPEN_SIMULATOR']
+
+      device = TestCommandGenerator.find_device(device_name)
+      FastlaneCore::Simulator.launch(device) if device
+    end
+
+    def uninstall_app(device_type)
+      UI.verbose "Uninstalling app '#{Snapshot.config[:app_identifier]}' from #{device_type}..."
+      Snapshot.config[:app_identifier] ||= UI.input("App Identifier: ")
+      device_udid = TestCommandGenerator.device_udid(device_type)
+
+      UI.message "Launch Simulator #{device_type}"
+      Helper.backticks("xcrun instruments -w #{device_udid} &> /dev/null")
+
+      UI.message "Uninstall application #{Snapshot.config[:app_identifier]}"
+      Helper.backticks("xcrun simctl uninstall #{device_udid} #{Snapshot.config[:app_identifier]} &> /dev/null")
+    end
+
+    def erase_simulator(device_type)
+      UI.verbose("Erasing #{device_type}...")
+      device_udid = TestCommandGenerator.device_udid(device_type)
+
+      UI.important("Erasing #{device_type}...")
+
+      `xcrun simctl erase #{device_udid} &> /dev/null`
+    end
+
+    def localize_simulator(device_type, language, locale)
+      device_udid = TestCommandGenerator.device_udid(device_type)
+      if device_udid
+        locale ||= language.sub("-", "_")
+        plist = {
+          AppleLocale: locale,
+          AppleLanguages: [language]
+        }
+        UI.message "Localizing #{device_type} (AppleLocale=#{locale} AppleLanguages=[#{language}])"
+        plist_path = "#{ENV['HOME']}/Library/Developer/CoreSimulator/Devices/#{device_udid}/data/Library/Preferences/.GlobalPreferences.plist"
+        File.write(plist_path, Plist::Emit.dump(plist))
+      end
+    end
+
+    def add_media(device_type, media_type, paths)
+      media_type = media_type.to_s
+
+      UI.verbose "Adding #{media_type}s to #{device_type}..."
+      device_udid = TestCommandGenerator.device_udid(device_type)
+
+      UI.message "Launch Simulator #{device_type}"
+      Helper.backticks("xcrun instruments -w #{device_udid} &> /dev/null")
+
+      paths.each do |path|
+        UI.message "Adding '#{path}'"
+        Helper.backticks("xcrun simctl add#{media_type} #{device_udid} #{path.shellescape} &> /dev/null")
+      end
+    end
+
+    def clear_previous_screenshots
+      UI.important "Clearing previously generated screenshots"
+      path = File.join(Snapshot.config[:output_directory], "*", "*.png")
+      Dir[path].each do |current|
+        UI.verbose "Deleting #{current}"
+        File.delete(current)
+      end
+    end
+
+    def version_of_bundled_helper
+      runner_dir = File.dirname(__FILE__)
+      bundled_helper = File.read File.expand_path('../assets/SnapshotHelper.swift', runner_dir)
+      current_version = bundled_helper.match(/\n.*SnapshotHelperVersion \[.+\]/)[0]
+
+      ## Something like "// SnapshotHelperVersion [1.2]", but be relaxed about whitespace
+      current_version.gsub(%r{^//\w*}, '').strip
+    end
+
+    # rubocop:disable Style/Next
+    def verify_helper_is_current
+      current_version = version_of_bundled_helper
+      UI.verbose "Checking that helper files contain #{current_version}"
+
+      helper_files = Update.find_helper
+      helper_files.each do |path|
+        content = File.read(path)
+
+        unless content.include?(current_version)
+          UI.error "Your '#{path}' is outdated, please run `snapshot update`"
+          UI.error "to update your Helper file"
+          UI.user_error!("Please update your Snapshot Helper file")
+        end
+      end
+    end
+    # rubocop:enable Style/Next
+  end
+end

data/snapshot/lib/snapshot/screenshot_flatten.rb

@@ -0,0 +1,18 @@
+module Snapshot
+  # This class takes care of removing the alpha channel of the generated screenshots
+  class ScreenshotFlatten
+    # @param (String) The path in which the screenshots are located in
+    def run(path)
+      UI.message "Removing the alpha channel from generated png files"
+      flatten(path)
+    end
+
+    def flatten(path)
+      Dir.glob([path, '/**/*.png'].join('/')).each do |file|
+        UI.verbose("Removing alpha channel from '#{file}'")
+        `sips -s format bmp '#{file}' &> /dev/null` # &> /dev/null because there is warning because of the extension
+        `sips -s format png '#{file}'`
+      end
+    end
+  end
+end