fastlane_iac_publish 0.1.0

data/scan/README.md

@@ -0,0 +1,17 @@
+<h3 align="center">
+  <a href="https://docs.fastlane.tools/actions/scan/">
+    <img src="https://raw.githubusercontent.com/fastlane/fastlane/master/fastlane/assets/fastlane.png" width="100" />
+    <br />
+    fastlane
+  </a>
+</h3>
+
+------
+
+<p align="center">
+  <a href="https://docs.fastlane.tools/actions/scan/">
+    <img src="https://raw.githubusercontent.com/fastlane/fastlane/master/scan/assets/scan.png" height="110">
+  </a>
+</p>
+
+<h3 align="center">The <i>scan</i> docs were moved to <a href='https://docs.fastlane.tools/actions/scan/'>docs.fastlane.tools</a></h3>

data/scan/lib/assets/ScanfileTemplate

@@ -0,0 +1,16 @@
+# For more information about this configuration visit
+# https://docs.fastlane.tools/actions/scan/#scanfile
+
+# In general, you can use the options available
+# fastlane scan --help
+
+# Remove the # in front of the line to enable the option
+
+# scheme("Example")
+
+# open_report(true)
+
+# clean(true)
+
+# Enable skip_build to skip debug builds for faster test performance
+skip_build(true)

data/scan/lib/assets/ScanfileTemplate.swift

@@ -0,0 +1,13 @@
+// For more information about this configuration visit
+// https://docs.fastlane.tools/actions/scan/#scanfile
+
+// In general, you can use the options available
+// fastlane scan --help
+
+// Remove the // in front of the line to enable the option
+
+class Scanfile: ScanfileProtocol {
+    //var scheme: String? { return "Example" }
+    //var openReport: Bool { return true }
+    //var clean: Bool { return true }
+}

data/scan/lib/scan.rb

@@ -0,0 +1,10 @@
+require_relative 'scan/manager'
+require_relative 'scan/options'
+require_relative 'scan/runner'
+require_relative 'scan/detect_values'
+require_relative 'scan/test_command_generator'
+require_relative 'scan/xcpretty_reporter_options_generator.rb'
+require_relative 'scan/test_result_parser'
+require_relative 'scan/error_handler'
+require_relative 'scan/slack_poster'
+require_relative 'scan/module'

data/scan/lib/scan/commands_generator.rb

@@ -0,0 +1,78 @@
+require 'commander'
+
+require 'fastlane_core/configuration/configuration'
+require_relative 'module'
+require_relative 'manager'
+require_relative 'options'
+
+HighLine.track_eof = false
+
+module Scan
+  class CommandsGenerator
+    include Commander::Methods
+
+    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, "Documentation", "https://docs.fastlane.tools/actions/scan/"
+      program :help_formatter, :compact
+
+      global_option("--verbose") { FastlaneCore::Globals.verbose = true }
+
+      command :tests do |c|
+        c.syntax = "fastlane scan"
+        c.description = Scan::DESCRIPTION
+
+        FastlaneCore::CommanderGenerator.new.generate(Scan::Options.available_options, command: c)
+
+        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 = "fastlane scan init"
+        c.description = "Creates a new Scanfile for you"
+        c.action do |args, options|
+          containing = FastlaneCore::Helper.fastlane_enabled_folder_path
+          path = File.join(containing, Scan.scanfile_name)
+          UI.user_error!("Scanfile already exists").yellow if File.exist?(path)
+
+          is_swift_fastfile = args.include?("swift")
+          if is_swift_fastfile
+            path = File.join(containing, Scan.scanfile_name + ".swift")
+            UI.user_error!("Scanfile.swift already exists") if File.exist?(path)
+          end
+
+          if is_swift_fastfile
+            template = File.read("#{Scan::ROOT}/lib/assets/ScanfileTemplate.swift")
+          else
+            template = File.read("#{Scan::ROOT}/lib/assets/ScanfileTemplate")
+          end
+
+          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,219 @@
+require 'fastlane_core/device_manager'
+require 'fastlane_core/project'
+require_relative 'module'
+
+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)
+
+      prevalidate
+
+      # 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
+
+      coerce_to_array_of_strings(:only_testing)
+      coerce_to_array_of_strings(:skip_testing)
+
+      return config
+    end
+
+    def self.prevalidate
+      output_types = Scan.config[:output_types]
+      has_multiple_report_types = output_types && output_types.split(',').size > 1
+      if has_multiple_report_types && Scan.config[:custom_report_file_name]
+        UI.user_error!("Using a :custom_report_file_name with multiple :output_types (#{output_types}) will lead to unexpected results. Use :output_files instead.")
+      end
+    end
+
+    def self.coerce_to_array_of_strings(config_key)
+      config_value = Scan.config[config_key]
+
+      return if config_value.nil?
+
+      # splitting on comma allows us to support comma-separated lists of values
+      # from the command line, even though the ConfigItem is not defined as an
+      # Array type
+      config_value = config_value.split(',') unless config_value.kind_of?(Array)
+      Scan.config[config_key] = config_value.map(&:to_s)
+    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
+
+      unless Scan.config[:skip_detect_devices]
+        default = lambda do
+          UI.error("Couldn't find any matching simulators for '#{devices}' - falling back to default simulator") if (devices || []).count > 0
+
+          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.message("Found simulator \"#{result.first.name} (#{result.first.os_version})\"") if result.first
+
+          result
+        end
+      end
+
+      # grab the first unempty evaluated array
+      if default
+        Scan.devices = [matches, default].lazy.map { |x|
+          arr = x.call
+          arr unless arr.empty?
+        }.reject(&:nil?).first
+      else
+        Scan.devices = []
+      end
+    end
+
+    def self.min_xcode8?
+      Helper.xcode_at_least?("8.0")
+    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 `fastlane 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}" }
+      elsif Scan.project.mac_app?
+        Scan.config[:destination] = min_xcode8? ? ["platform=macOS"] : ["platform=OS X"]
+      end
+    end
+  end
+end

data/scan/lib/scan/error_handler.rb

@@ -0,0 +1,52 @@
+require_relative 'module'
+
+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.build_failure!("Error building the application - see the log above")
+        when /Executed/, /Failing tests:/
+          # 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
+          # ------------------------------------------------
+          # For the "Failing tests:" case, this covers Xcode
+          # 10 parallel testing failure, which doesn't
+          # print out the "Executed" line that would show
+          # test summary (number of tests passed, etc.).
+          # Instead, it just prints "Failing tests:"
+          # followed by a list of tests that failed.
+          return
+        end
+        UI.build_failure!("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,21 @@
+require 'fastlane_core/print_table'
+require_relative 'module'
+require_relative 'runner'
+
+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/module.rb

@@ -0,0 +1,32 @@
+require 'fastlane_core/helper'
+require 'fastlane/boolean'
+require_relative 'detect_values'
+
+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
+  Boolean = Fastlane::Boolean
+  ROOT = Pathname.new(File.expand_path('../../..', __FILE__))
+
+  DESCRIPTION = "The easiest way to run tests of your iOS and Mac app"
+end