fastlane 1.111.0 → 2.0.1

data/snapshot/lib/snapshot/detect_values.rb

@@ -0,0 +1,53 @@
+module Snapshot
+  class DetectValues
+    # This is needed as these are more complex default values
+    def self.set_additional_default_values
+      config = Snapshot.config
+
+      # First, try loading the Snapfile from the current directory
+      config.load_configuration_file(Snapshot.snapfile_name)
+
+      # Detect the project
+      FastlaneCore::Project.detect_projects(config)
+      Snapshot.project = FastlaneCore::Project.new(config)
+
+      # Go into the project's folder, as there might be a Snapfile there
+      Dir.chdir(File.expand_path("..", Snapshot.project.path)) do
+        config.load_configuration_file(Snapshot.snapfile_name)
+      end
+
+      Snapshot.project.select_scheme(preferred_to_include: "UITests")
+
+      # Devices
+      unless config[:devices]
+        config[:devices] = []
+
+        # We only care about a subset of the simulators
+        all_simulators = FastlaneCore::Simulator.all
+        all_simulators.each do |sim|
+          # Filter iPads, we only want the following simulators
+          # Xcode 7:
+          #   ["iPad Pro", "iPad Air"]
+          # Xcode 8:
+          #   ["iPad Pro (9.7 Inch)", "iPad Pro (12.9 Inch)"]
+          #
+          # Full list: ["iPad 2", "iPad Retina", "iPad Air", "iPad Air 2", "iPad Pro"]
+          next if sim.name.include?("iPad 2")
+          next if sim.name.include?("iPad Retina")
+          next if sim.name.include?("iPad Air 2")
+          # In Xcode 8, we only need iPad Pro 9.7 inch, not the iPad Air
+          next if all_simulators.any? { |a| a.name.include?("9.7 inch") } && sim.name.include?("iPad Air")
+
+          # Filter iPhones
+          # Full list: ["iPhone 4s", "iPhone 5", "iPhone 5s", "iPhone 6", "iPhone 6 Plus", "iPhone 6s", "iPhone 6s Plus"]
+          next if sim.name.include?("6s") # same screen resolution as iPhone 6, or iPhone 6s Plus
+          next if sim.name.include?("5s") # same screen resolution as iPhone 5
+
+          next if sim.name.include?("Apple TV")
+
+          config[:devices] << sim.name
+        end
+      end
+    end
+  end
+end

data/snapshot/lib/snapshot/error_handler.rb

@@ -0,0 +1,22 @@
+module Snapshot
+  class ErrorHandler
+    class << self
+      # @param [Array] The output of the errored build (line by line)
+      # This method should raise an exception in any case, as the return code indicated a failed build
+      def handle_test_error(output, return_code)
+        # The order of the handling below is import
+
+        if return_code == 65
+          UI.user_error!("Tests failed - check out the log above")
+        end
+
+        case output
+        when /com\.apple\.CoreSimulator\.SimError/
+          UI.important "The simulator failed to launch - retrying..."
+        when /is not configured for Running/
+          UI.user_error!("Scheme is not properly configured, make sure to check out the snapshot README")
+        end
+      end
+    end
+  end
+end

data/snapshot/lib/snapshot/fixes/README.md

@@ -0,0 +1,5 @@
+### Fixes
+
+This directory contains all the files we don't actually want to have, but are necessary due to open radars, e.g.
+- [rdar://23062925](https://openradar.appspot.com/radar?id=5056366381105152): Trigger screenshots from UI Tests
+- [rdar://23323159](https://openradar.appspot.com/radar?id=6127019184095232): Screenshots are broken when simulator is not scaled at 100%

data/snapshot/lib/snapshot/fixes/hardware_keyboard_fix.rb

@@ -0,0 +1,14 @@
+module Snapshot
+  module Fixes
+    # Having "Connect Hardware Keyboard" enabled causes issues with entering text in secure textfields
+    # Fixes https://github.com/fastlane/snapshot/issues/433
+
+    class HardwareKeyboardFix
+      def self.patch
+        UI.verbose "Patching simulator to work with secure text fields"
+
+        Helper.backticks("defaults write com.apple.iphonesimulator ConnectHardwareKeyboard 0", print: $verbose)
+      end
+    end
+  end
+end

data/snapshot/lib/snapshot/fixes/simulator_zoom_fix.rb

@@ -0,0 +1,25 @@
+module Snapshot
+  module Fixes
+    # This fix is needed due to a bug in UI Tests that creates invalid screenshots when the
+    # simulator is not scaled to a 100%
+    # Issue: https://github.com/fastlane/snapshot/issues/249
+    # Radar: https://openradar.appspot.com/radar?id=6127019184095232
+
+    class SimulatorZoomFix
+      def self.patch
+        UI.message "Patching '#{config_path}' to scale simulator to 100%"
+
+        FastlaneCore::DeviceManager.simulators.each do |simulator|
+          simulator_name = simulator.name.tr("\s", "-")
+          key = "SimulatorWindowLastScale-com.apple.CoreSimulator.SimDeviceType.#{simulator_name}"
+
+          Helper.backticks("defaults write '#{config_path}' '#{key}' '1.0'", print: $verbose)
+        end
+      end
+
+      def self.config_path
+        File.join(File.expand_path("~"), "Library", "Preferences", "com.apple.iphonesimulator.plist")
+      end
+    end
+  end
+end

data/snapshot/lib/snapshot/latest_os_version.rb

@@ -0,0 +1,31 @@
+module Snapshot
+  class LatestOsVersion
+    def self.ios_version
+      return ENV["SNAPSHOT_IOS_VERSION"] if ENV["SNAPSHOT_IOS_VERSION"]
+      self.version("iOS")
+    end
+
+    @versions = {}
+    def self.version(os)
+      @versions[os] ||= version_for_os(os)
+    end
+
+    def self.version_for_os(os)
+      # We do all this, because we would get all kind of crap output generated by xcodebuild
+      # so we need to ignore stderror
+      output = ''
+      Open3.popen3('xcodebuild -version -sdk') do |stdin, stdout, stderr, wait_thr|
+        output = stdout.read
+      end
+
+      matched = output.match(/#{os} ([\d\.]+) \(.*/)
+      if matched.nil?
+        UI.user_error!("Could not determine installed #{os} SDK version. Try running the _xcodebuild_ command manually to ensure it works.")
+      elsif matched.length > 1
+        return matched[1]
+      else
+        UI.user_error!("Could not determine installed #{os} SDK version. Please pass it via the environment variable 'SNAPSHOT_IOS_VERSION'")
+      end
+    end
+  end
+end

data/snapshot/lib/snapshot/options.rb

@@ -0,0 +1,161 @@
+require 'fastlane_core'
+require 'credentials_manager'
+
+module Snapshot
+  class Options
+    def self.available_options
+      output_directory = (File.directory?("fastlane") ? "fastlane/screenshots" : "screenshots")
+
+      @options ||= [
+        FastlaneCore::ConfigItem.new(key: :workspace,
+                                     short_option: "-w",
+                                     env_name: "SNAPSHOT_WORKSPACE",
+                                     optional: true,
+                                     description: "Path the workspace file",
+                                     verify_block: proc do |value|
+                                       v = File.expand_path(value.to_s)
+                                       UI.user_error!("Workspace file not found at path '#{v}'") unless File.exist?(v)
+                                       UI.user_error!("Workspace file invalid") unless File.directory?(v)
+                                       UI.user_error!("Workspace file is not a workspace, must end with .xcworkspace") unless v.include?(".xcworkspace")
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :project,
+                                     short_option: "-p",
+                                     optional: true,
+                                     env_name: "SNAPSHOT_PROJECT",
+                                     description: "Path the project file",
+                                     verify_block: proc do |value|
+                                       v = File.expand_path(value.to_s)
+                                       UI.user_error!("Project file not found at path '#{v}'") unless File.exist?(v)
+                                       UI.user_error!("Project file invalid") unless File.directory?(v)
+                                       UI.user_error!("Project file is not a project file, must end with .xcodeproj") unless v.include?(".xcodeproj")
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :devices,
+                                     description: "A list of devices you want to take the screenshots from",
+                                     short_option: "-d",
+                                     type: Array,
+                                     optional: true,
+                                     verify_block: proc do |value|
+                                       available = FastlaneCore::DeviceManager.simulators
+                                       value.each do |current|
+                                         unless available.any? { |d| d.name.strip == current.strip }
+                                           UI.user_error!("Device '#{current}' not in list of available simulators '#{available.join(', ')}'")
+                                         end
+                                       end
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :languages,
+                                     description: "A list of languages which should be used",
+                                     short_option: "-g",
+                                     type: Array,
+                                     default_value: ['en-US']),
+        FastlaneCore::ConfigItem.new(key: :launch_arguments,
+                                     env_name: 'SNAPSHOT_LAUNCH_ARGUMENTS',
+                                     description: "A list of launch arguments which should be used",
+                                     short_option: "-m",
+                                     type: Array,
+                                     default_value: ['']),
+        FastlaneCore::ConfigItem.new(key: :output_directory,
+                                     short_option: "-o",
+                                     env_name: "SNAPSHOT_OUTPUT_DIRECTORY",
+                                     description: "The directory where to store the screenshots",
+                                     default_value: output_directory),
+        FastlaneCore::ConfigItem.new(key: :ios_version,
+                                     description: "By default, the latest version should be used automatically. If you want to change it, do it here",
+                                     short_option: "-i",
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :skip_open_summary,
+                                     env_name: 'SNAPSHOT_SKIP_OPEN_SUMMARY',
+                                     description: "Don't open the HTML summary after running _snapshot_",
+                                     default_value: false,
+                                     is_string: false),
+        FastlaneCore::ConfigItem.new(key: :clear_previous_screenshots,
+                                     env_name: 'SNAPSHOT_CLEAR_PREVIOUS_SCREENSHOTS',
+                                     description: "Enabling this option will automatically clear previously generated screenshots before running snapshot",
+                                     default_value: false,
+                                     is_string: false),
+        FastlaneCore::ConfigItem.new(key: :reinstall_app,
+                                     env_name: 'SNAPSHOT_REINSTALL_APP',
+                                     description: "Enabling this option will automatically uninstall the application before running it",
+                                     default_value: false,
+                                     is_string: false),
+        FastlaneCore::ConfigItem.new(key: :erase_simulator,
+                                     env_name: 'SNAPSHOT_ERASE_SIMULATOR',
+                                     description: "Enabling this option will automatically erase the simulator before running the application",
+                                     default_value: false,
+                                     is_string: false),
+        FastlaneCore::ConfigItem.new(key: :localize_simulator,
+                                     env_name: 'SNAPSHOT_LOCALIZE_SIMULATOR',
+                                     description: "Enabling this option will configure the Simulator's system language",
+                                     default_value: false,
+                                     is_string: false),
+        FastlaneCore::ConfigItem.new(key: :app_identifier,
+                                     env_name: 'SNAPSHOT_APP_IDENTIFIER',
+                                     short_option: "-a",
+                                     optional: true,
+                                     description: "The bundle identifier of the app to uninstall (only needed when enabling reinstall_app)",
+                                     default_value: ENV["SNAPSHOT_APP_IDENTITIFER"] || CredentialsManager::AppfileConfig.try_fetch_value(:app_identifier)),
+        FastlaneCore::ConfigItem.new(key: :add_photos,
+                                     env_name: 'SNAPSHOT_PHOTOS',
+                                     short_option: "-j",
+                                     description: "A list of photos that should be added to the simulator before running the application",
+                                     type: Array,
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :add_videos,
+                                     env_name: 'SNAPSHOT_VIDEOS',
+                                     short_option: "-u",
+                                     description: "A list of videos that should be added to the simulator before running the application",
+                                     type: Array,
+                                     optional: true),
+
+        # Everything around building
+        FastlaneCore::ConfigItem.new(key: :buildlog_path,
+                                     short_option: "-l",
+                                     env_name: "SNAPSHOT_BUILDLOG_PATH",
+                                     description: "The directory where to store the build log",
+                                     default_value: "#{FastlaneCore::Helper.buildlog_path}/snapshot"),
+        FastlaneCore::ConfigItem.new(key: :clean,
+                                     short_option: "-c",
+                                     env_name: "SNAPSHOT_CLEAN",
+                                     description: "Should the project be cleaned before building it?",
+                                     is_string: false,
+                                     default_value: false),
+        FastlaneCore::ConfigItem.new(key: :configuration,
+                                     short_option: "-q",
+                                     env_name: "SNAPSHOT_CONFIGURATION",
+                                     description: "The configuration to use when building the app. Defaults to 'Release'",
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :xcpretty_args,
+                                     short_option: "-x",
+                                     env_name: "SNAPSHOT_XCPRETTY_ARGS",
+                                     description: "Additional xcpretty arguments",
+                                     is_string: true,
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :sdk,
+                                     short_option: "-k",
+                                     env_name: "SNAPSHOT_SDK",
+                                     description: "The SDK that should be used for building the application",
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :scheme,
+                                     short_option: "-s",
+                                     env_name: 'SNAPSHOT_SCHEME',
+                                     description: "The scheme you want to use, this must be the scheme for the UI Tests",
+                                     optional: true), # optional true because we offer a picker to the user
+        FastlaneCore::ConfigItem.new(key: :number_of_retries,
+                                     short_option: "-n",
+                                     env_name: 'SNAPSHOT_NUMBER_OF_RETRIES',
+                                     description: "The number of times a test can fail before snapshot should stop retrying",
+                                     type: Integer,
+                                     default_value: 1),
+        FastlaneCore::ConfigItem.new(key: :stop_after_first_error,
+                                     env_name: 'SNAPSHOT_BREAK_ON_FIRST_ERROR',
+                                     description: "Should snapshot stop immediately after the tests completely failed on one device?",
+                                     default_value: false,
+                                     is_string: false),
+        FastlaneCore::ConfigItem.new(key: :derived_data_path,
+                                     short_option: "-f",
+                                     env_name: "SNAPSHOT_DERIVED_DATA_PATH",
+                                     description: "The directory where build products and other derived data will go",
+                                     optional: true)
+      ]
+    end
+  end
+end

data/snapshot/lib/snapshot/page.html.erb

@@ -0,0 +1,206 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>fastlane/snapshot</title>
+    <meta charset="UTF-8">
+    <style type="text/css">
+      * {
+        font-family: "HelveticaNeue-Light", "Helvetica Neue Light", "Helvetica Neue", Helvetica, Arial, "Lucida Grande", sans-serif;
+        font-weight: 300;
+      }
+      .language {
+
+      }
+      .deviceName {
+        display: block;
+        font-size: 30px;
+        padding-bottom: 24px;
+        padding-top: 45px;
+      }
+      .screenshot {
+        cursor: pointer;
+        border: 1px #EEE solid;
+        z-index: 0;
+      }
+      th {
+        text-align: left;
+      }
+      td {
+        text-align: center;
+        min-width: 200px;
+      }
+      #overlay {
+        position:fixed;
+        top:0;
+        left:0;
+        background:rgba(0,0,0,0.8);
+        z-index:5;
+        width:100%;
+        height:100%;
+        display:none;
+        cursor: zoom-out;
+        text-align: center;
+      }
+      #imageDisplay {
+        height: auto;
+        width: auto;
+        z-index: 10;
+        cursor: pointer;
+      }
+      #imageInfo {
+        background: none repeat scroll 0 0 rgba(0, 0, 0, 0.2);
+        border-radius: 5px;
+        color: white;
+        margin: 20px;
+        padding: 10px;
+        position: absolute;
+        right: 0;
+        top: 0;
+        width: 250px;
+        z-index: -1;
+      }
+      #imageInfo:hover {
+        z-index: 20;
+      }
+    </style>
+  </head>
+  <body>
+    <% divide_size_by = 5.0 %>
+    <% max_width = 180 %>
+    <% image_counter = 0 %>
+
+
+    <% @data.each do |language, content| %>
+      <h1 class="language"><%= language %></h1>
+      <hr>
+      <table>
+        <% content.each do |device_name, screens| %>
+          <tr>
+            <th colspan="<%= screens.count %>">
+              <span class="deviceName"><%= device_name %></span>
+            </th>
+          </tr>
+          <tr>
+            <% screens.each do |screen_path| %>
+              <% next if screen_path.include?"_framed.png" %>
+              <td>
+                <% style = "width: 100%;" %>
+                <% image_counter += 1 %>
+                <a href="<%= screen_path %>" target="_blank" class="screenshotLink">
+                  <img class="screenshot"
+                         src="<%= screen_path %>"
+                       style="<%= style %>"
+                         alt="<%= language %> <%= device_name %>"
+                data-counter="<%= image_counter %>" />
+                </a>
+              </td>
+            <% end %>
+          </tr>
+        <% end %>
+      </table>
+    <% end %>
+      <div id="overlay">
+        <img id="imageDisplay" src="" alt="" />
+        <div id="imageInfo"></div>
+      </div>
+      <script type="text/javascript">
+        var overlay        = document.getElementById('overlay');
+        var imageDisplay   = document.getElementById('imageDisplay');
+        var imageInfo      = document.getElementById('imageInfo');
+        var screenshotLink = document.getElementsByClassName('screenshotLink');
+
+        function doClick(el) {
+          if (document.createEvent) {
+            var evObj = document.createEvent('MouseEvents', true);
+            evObj.initMouseEvent("click", false, true, window, 0, 0, 0, 0, 0, false, false, false, false, 0, null);
+            el.dispatchEvent(evObj);
+          } else if (document.createEventObject) { //IE
+            var evObj = document.createEventObject();
+            el.fireEvent('onclick', evObj);
+          }
+        }
+
+        for (index = 0; index < screenshotLink.length; ++index) {
+          screenshotLink[index].addEventListener('click', function(e) {
+            e.preventDefault();
+            
+            var img = e.target;
+            if (e.target.tagName == 'A') {
+              img = e.target.children[0];
+            }
+            
+            // beautify
+            var tmpImg = new Image();
+            tmpImg.src = img.src;
+            imageDisplay.style.height     = 'auto';
+            imageDisplay.style.width     = 'auto';
+            if (window.innerHeight < tmpImg.height) {
+              imageDisplay.style.height = document.documentElement.clientHeight+'px';
+            } else if (window.innerWidth < tmpImg.width) {
+              imageDisplay.style.width = document.documentElement.clientWidth;+'px';
+            } else {
+              imageDisplay.style.paddingTop = parseInt((window.innerHeight - tmpImg.height) / 2)+'px';
+            }
+
+            imageDisplay.src             = img.src;
+            imageDisplay.alt             = img.alt;
+            imageDisplay.dataset.counter = img.dataset.counter;
+            
+            imageInfo.innerHTML          = '<h3>'+img.alt+'</h3>';
+            imageInfo.innerHTML         += decodeURI(img.src.split("/").pop());
+            imageInfo.innerHTML         += '<br />'+tmpImg.height+'&times;'+tmpImg.width+'px';
+                    
+            overlay.style.display        = "block";
+          });
+        }
+        
+        imageDisplay.addEventListener('click', function(e) {
+          e.stopPropagation(); // !
+          
+          overlay.style.display = "none";
+          
+          img_counter = parseInt(e.target.dataset.counter) + 1;
+          try {
+            link = document.body.querySelector('img[data-counter="'+img_counter+'"]').parentNode;
+          } catch (e) {
+            try {
+              link = document.body.querySelector('img[data-counter="0"]').parentNode;
+            } catch (e) {
+              return false;
+            }
+          }
+          doClick(link);
+        });
+
+        overlay.addEventListener('click', function(e) {
+          overlay.style.display = "none";
+        })
+        
+      function keyPressed(e) {
+        e = e || window.event;
+        var charCode = e.keyCode || e.which;
+        switch(charCode) {
+          case 27: // Esc
+            overlay.style.display = "none";
+            break;
+          case 34: // right-arrow, Page Down, keypad right, ...
+          case 39:
+          case 54:
+          case 102:
+            e.preventDefault();
+            doClick(imageDisplay);
+            break;
+          case 33: // left-arrow, Page Up, keypad right, ...
+          case 37:
+          case 52:
+          case 100:
+            e.preventDefault();
+            document.getElementById('imageDisplay').dataset.counter -= 2; // hacky
+            doClick(imageDisplay);
+            break;
+         }
+      };
+      document.body.addEventListener('keydown', keyPressed);
+      </script>
+  </body>
+</html>