fastlane 1.111.0 → 2.0.1

data/scan/lib/scan.rb

@@ -0,0 +1,40 @@
+require 'json'
+require 'scan/manager'
+require 'scan/options'
+require 'scan/runner'
+require 'scan/detect_values'
+require 'scan/report_collector'
+require 'scan/test_command_generator'
+require 'scan/test_result_parser'
+require 'scan/error_handler'
+require 'scan/slack_poster'
+
+require 'fastlane_core'
+
+module Scan
+  class << self
+    attr_accessor :config
+
+    attr_accessor :project
+
+    attr_accessor :cache
+
+    attr_accessor :devices
+
+    def config=(value)
+      @config = value
+      DetectValues.set_additional_default_values
+      @cache = {}
+    end
+
+    def scanfile_name
+      "Scanfile"
+    end
+  end
+
+  Helper = FastlaneCore::Helper # you gotta love Ruby: Helper.* should use the Helper class contained in FastlaneCore
+  UI = FastlaneCore::UI
+  ROOT = Pathname.new(File.expand_path('../..', __FILE__))
+
+  DESCRIPTION = "The easiest way to run tests of your iOS and Mac app"
+end

data/scan/lib/scan/commands_generator.rb

@@ -0,0 +1,61 @@
+require "commander"
+require "fastlane_core"
+
+HighLine.track_eof = false
+
+module Scan
+  class CommandsGenerator
+    include Commander::Methods
+
+    FastlaneCore::CommanderGenerator.new.generate(Scan::Options.available_options)
+
+    def self.start
+      new.run
+    end
+
+    def convert_options(options)
+      o = options.__hash__.dup
+      o.delete(:verbose)
+      o
+    end
+
+    def run
+      program :name, 'scan'
+      program :version, Fastlane::VERSION
+      program :description, Scan::DESCRIPTION
+      program :help, "Author", "Felix Krause <scan@krausefx.com>"
+      program :help, "Website", "https://fastlane.tools"
+      program :help, "GitHub", "https://github.com/fastlane/fastlane/tree/master/scan"
+      program :help_formatter, :compact
+
+      global_option("--verbose") { $verbose = true }
+
+      command :tests do |c|
+        c.syntax = "scan"
+        c.description = Scan::DESCRIPTION
+        c.action do |_args, options|
+          config = FastlaneCore::Configuration.create(Scan::Options.available_options,
+                                                      convert_options(options))
+          Scan::Manager.new.work(config)
+        end
+      end
+
+      command :init do |c|
+        c.syntax = "scan init"
+        c.description = "Creates a new Scanfile for you"
+        c.action do |_args, options|
+          containing = (Helper.fastlane_enabled? ? 'fastlane' : '.')
+          path = File.join(containing, Scan.scanfile_name)
+          UI.user_error!("Scanfile already exists").yellow if File.exist?(path)
+          template = File.read("#{Scan::ROOT}/lib/assets/ScanfileTemplate")
+          File.write(path, template)
+          UI.success("Successfully created '#{path}'. Open the file using a code editor.")
+        end
+      end
+
+      default_command :tests
+
+      run!
+    end
+  end
+end

data/scan/lib/scan/detect_values.rb

@@ -0,0 +1,184 @@
+module Scan
+  # This class detects all kinds of default values
+  class DetectValues
+    # This is needed as these are more complex default values
+    # Returns the finished config object
+    def self.set_additional_default_values
+      config = Scan.config
+
+      # First, try loading the Scanfile from the current directory
+      config.load_configuration_file(Scan.scanfile_name)
+
+      # Detect the project
+      FastlaneCore::Project.detect_projects(config)
+      Scan.project = FastlaneCore::Project.new(config)
+
+      # Go into the project's folder, as there might be a Snapfile there
+      imported_path = File.expand_path(Scan.scanfile_name)
+      Dir.chdir(File.expand_path("..", Scan.project.path)) do
+        config.load_configuration_file(Scan.scanfile_name) unless File.expand_path(Scan.scanfile_name) == imported_path
+      end
+
+      Scan.project.select_scheme
+
+      devices = Scan.config[:devices] || Array(Scan.config[:device]) # important to use Array(nil) for when the value is nil
+      if devices.count > 0
+        detect_simulator(devices, '', '', '', nil)
+      else
+        if Scan.project.ios?
+          # An iPhone 5s is a reasonably small and useful default for tests
+          detect_simulator(devices, 'iOS', 'IPHONEOS_DEPLOYMENT_TARGET', 'iPhone 5s', nil)
+        elsif Scan.project.tvos?
+          detect_simulator(devices, 'tvOS', 'TVOS_DEPLOYMENT_TARGET', 'Apple TV 1080p', 'TV')
+        end
+      end
+      detect_destination
+
+      default_derived_data
+
+      return config
+    end
+
+    def self.default_derived_data
+      return unless Scan.config[:derived_data_path].to_s.empty?
+      default_path = Scan.project.build_settings(key: "BUILT_PRODUCTS_DIR")
+      # => /Users/.../Library/Developer/Xcode/DerivedData/app-bqrfaojicpsqnoglloisfftjhksc/Build/Products/Release-iphoneos
+      # We got 3 folders up to point to ".../DerivedData/app-[random_chars]/"
+      default_path = File.expand_path("../../..", default_path)
+      UI.verbose("Detected derived data path '#{default_path}'")
+      Scan.config[:derived_data_path] = default_path
+    end
+
+    def self.filter_simulators(simulators, operator = :greater_than_or_equal, deployment_target)
+      deployment_target_version = Gem::Version.new(deployment_target)
+      simulators.select do |s|
+        sim_version = Gem::Version.new(s.os_version)
+        if operator == :greater_than_or_equal
+          sim_version >= deployment_target_version
+        elsif operator == :equal
+          sim_version == deployment_target_version
+        else
+          false # this will show an error message in the detect_simulator method
+        end
+      end
+    end
+
+    def self.regular_expression_for_split_on_whitespace_followed_by_parenthesized_version
+      # %r{
+      #   \s # a whitespace character
+      #   (?= # followed by -- using lookahead
+      #   \( # open parenthesis
+      #   [\d\.]+ # our version -- one or more digits or full stops
+      #   \) # close parenthesis
+      #   $ # end of line
+      #   ) # end of lookahead
+      # }
+      /\s(?=\([\d\.]+\)$)/
+    end
+
+    def self.detect_simulator(devices, requested_os_type, deployment_target_key, default_device_name, simulator_type_descriptor)
+      require 'set'
+
+      deployment_target_version = Scan.project.build_settings(key: deployment_target_key) || '0'
+
+      simulators = filter_simulators(
+        FastlaneCore::DeviceManager.simulators(requested_os_type).tap do |array|
+          if array.empty?
+            UI.user_error!(['No', simulator_type_descriptor, 'simulators found on local machine'].reject(&:nil?).join(' '))
+          end
+        end,
+        :greater_than_or_equal,
+        deployment_target_version
+      ).tap do |sims|
+        if sims.empty?
+          UI.error("No simulators found that are greater than or equal to the version of deployment target (#{deployment_target_version})")
+        end
+      end
+
+      # At this point we have all simulators for the given deployment target (or higher)
+
+      # We create 2 lambdas, which we iterate over later on
+      # If the first lambda `matches` found a simulator to use
+      # we'll never call the second one
+
+      matches = lambda do
+        set_of_simulators = devices.inject(
+          Set.new # of simulators
+        ) do |set, device_string|
+          pieces = device_string.split(regular_expression_for_split_on_whitespace_followed_by_parenthesized_version)
+
+          selector = ->(sim) { pieces.count > 0 && sim.name == pieces.first }
+
+          set + (
+            if pieces.count == 0
+              [] # empty array
+            elsif pieces.count == 1
+              simulators
+                .select(&selector)
+                .reverse # more efficient, because `simctl` prints higher versions first
+                .sort_by! { |sim| Gem::Version.new(sim.os_version) }
+                .pop(1)
+            else # pieces.count == 2 -- mathematically, because of the 'end of line' part of our regular expression
+              version = pieces[1].tr('()', '')
+              potential_emptiness_error = lambda do |sims|
+                if sims.empty?
+                  UI.error("No simulators found that are equal to the version " \
+                  "of specifier (#{version}) and greater than or equal to the version " \
+                  "of deployment target (#{deployment_target_version})")
+                end
+              end
+              filter_simulators(simulators, :equal, version).tap(&potential_emptiness_error).select(&selector)
+            end
+          ).tap do |array|
+            UI.error("Ignoring '#{device_string}', couldn’t find matching simulator") if array.empty?
+          end
+        end
+
+        set_of_simulators.to_a
+      end
+
+      default = lambda do
+        UI.error("Couldn't find any matching simulators for '#{devices}' - falling back to default simulator")
+
+        result = Array(
+          simulators
+            .select { |sim| sim.name == default_device_name }
+            .reverse # more efficient, because `simctl` prints higher versions first
+            .sort_by! { |sim| Gem::Version.new(sim.os_version) }
+            .last || simulators.first
+        )
+
+        UI.error("Found simulator \"#{result.first.name} (#{result.first.os_version})\"") if result.first
+
+        result
+      end
+
+      # grab the first unempty evaluated array
+      Scan.devices = [matches, default].lazy.map { |x|
+        arr = x.call
+        arr unless arr.empty?
+      }.reject(&:nil?).first
+    end
+
+    def self.min_xcode8?
+      Helper.xcode_version.split(".").first.to_i >= 8
+    end
+
+    def self.detect_destination
+      if Scan.config[:destination]
+        UI.important("It's not recommended to set the `destination` value directly")
+        UI.important("Instead use the other options available in `scan --help`")
+        UI.important("Using your value '#{Scan.config[:destination]}' for now")
+        UI.important("because I trust you know what you're doing...")
+        return
+      end
+
+      # building up the destination now
+      if Scan.devices && Scan.devices.count > 0
+        Scan.config[:destination] = Scan.devices.map { |d| "platform=#{d.os_type} Simulator,id=#{d.udid}" }
+      else
+        Scan.config[:destination] = min_xcode8? ? ["platform=macOS"] : ["platform=OS X"]
+      end
+    end
+  end
+end

data/scan/lib/scan/error_handler.rb

@@ -0,0 +1,43 @@
+module Scan
+  # This classes methods are called when something goes wrong in the building process
+  class ErrorHandler
+    class << self
+      # @param [String] The output of the errored build
+      # This method should raise an exception in any case, as the return code indicated a failed build
+      def handle_build_error(output)
+        # The order of the handling below is import
+        case output
+        when /US\-ASCII/
+          print "Your shell environment is not correctly configured"
+          print "Instead of UTF-8 your shell uses US-ASCII"
+          print "Please add the following to your '~/.bashrc':"
+          print ""
+          print "       export LANG=en_US.UTF-8"
+          print "       export LANGUAGE=en_US.UTF-8"
+          print "       export LC_ALL=en_US.UTF-8"
+          print ""
+          print "You'll have to restart your shell session after updating the file."
+          print "If you are using zshell or another shell, make sure to edit the correct bash file."
+          print "For more information visit this stackoverflow answer:"
+          print "https://stackoverflow.com/a/17031697/445598"
+        when /Testing failed/
+          UI.user_error!("Error building the application - see the log above")
+        when /Executed/
+          # this is *really* important:
+          # we don't want to raise an exception here
+          # as we handle this in runner.rb at a later point
+          # after parsing the actual test results
+          return
+        end
+        UI.user_error!("Error building/testing the application - see the log above")
+      end
+
+      private
+
+      # Just to make things easier
+      def print(text)
+        UI.error(text)
+      end
+    end
+  end
+end

data/scan/lib/scan/manager.rb

@@ -0,0 +1,17 @@
+module Scan
+  class Manager
+    def work(options)
+      Scan.config = options
+
+      # Also print out the path to the used Xcode installation
+      # We go 2 folders up, to not show "Contents/Developer/"
+      values = Scan.config.values(ask: false)
+      values[:xcode_path] = File.expand_path("../..", FastlaneCore::Helper.xcode_path)
+      FastlaneCore::PrintTable.print_values(config: values,
+                                         hide_keys: [:destination, :slack_url],
+                                             title: "Summary for scan #{Fastlane::VERSION}")
+
+      return Runner.new.run
+    end
+  end
+end

data/scan/lib/scan/options.rb

@@ -0,0 +1,189 @@
+require "fastlane_core"
+require "credentials_manager"
+
+module Scan
+  class Options
+    def self.available_options
+      containing = Helper.fastlane_enabled? ? './fastlane' : '.'
+
+      [
+        FastlaneCore::ConfigItem.new(key: :workspace,
+                                     short_option: "-w",
+                                     env_name: "SCAN_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: "SCAN_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: :device,
+                                     short_option: "-a",
+                                     optional: true,
+                                     is_string: true,
+                                     env_name: "SCAN_DEVICE",
+                                     description: "The name of the simulator type you want to run tests on (e.g. 'iPhone 6')",
+                                     conflicting_options: [:devices],
+                                     conflict_block: proc do |value|
+                                       UI.user_error!("You can't use 'device' and 'devices' options in one run")
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :devices,
+                                     optional: true,
+                                     is_string: false,
+                                     env_name: "SCAN_DEVICES",
+                                     type: Array,
+                                     description: "Array of devices to run the tests on (e.g. ['iPhone 6', 'iPad Air'])",
+                                     conflicting_options: [:device],
+                                     conflict_block: proc do |value|
+                                       UI.user_error!("You can't use 'device' and 'devices' options in one run")
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :scheme,
+                                     short_option: "-s",
+                                     optional: true,
+                                     env_name: "SCAN_SCHEME",
+                                     description: "The project's scheme. Make sure it's marked as `Shared`"),
+        FastlaneCore::ConfigItem.new(key: :clean,
+                                     short_option: "-c",
+                                     env_name: "SCAN_CLEAN",
+                                     description: "Should the project be cleaned before building it?",
+                                     is_string: false,
+                                     default_value: false),
+        FastlaneCore::ConfigItem.new(key: :code_coverage,
+                                     description: "Should generate code coverage (Xcode 7 only)?",
+                                     is_string: false,
+                                     default_value: false),
+        FastlaneCore::ConfigItem.new(key: :address_sanitizer,
+                                     description: "Should turn on the address sanitizer?",
+                                     is_string: false,
+                                     default_value: false),
+        FastlaneCore::ConfigItem.new(key: :skip_build,
+                                     description: "Should skip debug build before test build?",
+                                     short_option: "-r",
+                                     env_name: "SCAN_SKIP_BUILD",
+                                     is_string: false,
+                                     default_value: false),
+        FastlaneCore::ConfigItem.new(key: :output_directory,
+                                     short_option: "-o",
+                                     env_name: "SCAN_OUTPUT_DIRECTORY",
+                                     description: "The directory in which all reports will be stored",
+                                     default_value: File.join(containing, "test_output")),
+        FastlaneCore::ConfigItem.new(key: :output_style,
+                                     short_option: "-b",
+                                     env_name: "SCAN_OUTPUT_STYLE",
+                                     description: "Define how the output should look like (standard, basic, rspec or raw)",
+                                     optional: true,
+                                     verify_block: proc do |value|
+                                       UI.user_error!("Invalid output_style #{value}") unless ['standard', 'basic', 'rspec', 'raw'].include?(value)
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :output_types,
+                                     short_option: "-f",
+                                     env_name: "SCAN_OUTPUT_TYPES",
+                                     description: "Comma separated list of the output types (e.g. html, junit)",
+                                     default_value: "html,junit"),
+        FastlaneCore::ConfigItem.new(key: :buildlog_path,
+                                     short_option: "-l",
+                                     env_name: "SCAN_BUILDLOG_PATH",
+                                     description: "The directory were to store the raw log",
+                                     default_value: "#{FastlaneCore::Helper.buildlog_path}/scan"),
+        FastlaneCore::ConfigItem.new(key: :formatter,
+                                     short_option: "-n",
+                                     env_name: "SCAN_FORMATTER",
+                                     description: "A custom xcpretty formatter to use",
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :derived_data_path,
+                                     short_option: "-j",
+                                     env_name: "SCAN_DERIVED_DATA_PATH",
+                                     description: "The directory where build products and other derived data will go",
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :result_bundle,
+                                     short_option: "-z",
+                                     env_name: "SCAN_RESULT_BUNDLE",
+                                     is_string: false,
+                                     description: "Produce the result bundle describing what occurred will be placed",
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :sdk,
+                                     short_option: "-k",
+                                     env_name: "SCAN_SDK",
+                                     description: "The SDK that should be used for building the application",
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :open_report,
+                                     short_option: "-g",
+                                     env_name: "SCAN_OPEN_REPORT",
+                                     description: "Should the HTML report be opened when tests are completed",
+                                     is_string: false,
+                                     default_value: false),
+        FastlaneCore::ConfigItem.new(key: :configuration,
+                                     short_option: "-q",
+                                     env_name: "SCAN_CONFIGURATION",
+                                     description: "The configuration to use when building the app. Defaults to 'Release'",
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :destination,
+                                     short_option: "-d",
+                                     env_name: "SCAN_DESTINATION",
+                                     description: "Use only if you're a pro, use the other options instead",
+                                     is_string: false,
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :xcargs,
+                                     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),
+        FastlaneCore::ConfigItem.new(key: :xcconfig,
+                                     short_option: "-y",
+                                     env_name: "SCAN_XCCONFIG",
+                                     description: "Use an extra XCCONFIG file to build your app",
+                                     optional: true,
+                                     verify_block: proc do |value|
+                                       UI.user_error!("File not found at path '#{File.expand_path(value)}'") unless File.exist?(value)
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :slack_url,
+                                     short_option: "-i",
+                                     env_name: "SLACK_URL",
+                                     sensitive: true,
+                                     description: "Create an Incoming WebHook for your Slack group to post results there",
+                                     optional: true,
+                                     verify_block: proc do |value|
+                                       UI.user_error!("Invalid URL, must start with https://") unless value.start_with? "https://"
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :slack_channel,
+                                     short_option: "-e",
+                                     env_name: "SCAN_SLACK_CHANNEL",
+                                     description: "#channel or @username",
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :slack_message,
+                                     short_option: "-m",
+                                     env_name: "SCAN_SLACK_MESSAGE",
+                                     description: "The message included with each message posted to slack",
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :skip_slack,
+                                     description: "Don't publish to slack, even when an URL is given",
+                                     is_string: false,
+                                     default_value: false),
+        FastlaneCore::ConfigItem.new(key: :slack_only_on_failure,
+                                    description: "Only post on Slack if the tests fail",
+                                    is_string: false,
+                                    default_value: false),
+        FastlaneCore::ConfigItem.new(key: :use_clang_report_name,
+                                    description: "Generate the json compilation database with clang naming convention (compile_commands.json)",
+                                    is_string: false,
+                                    default_value: false),
+        FastlaneCore::ConfigItem.new(key: :custom_report_file_name,
+                                    description: "Sets custom full report file name",
+                                    optional: true,
+                                    is_string: true)
+      ]
+    end
+  end
+end