fastlane_iac_publish 0.1.0

data/scan/lib/scan/slack_poster.rb

@@ -0,0 +1,60 @@
+require 'fastlane/action'
+require 'fastlane/actions/slack'
+
+require_relative 'module'
+
+module Scan
+  class SlackPoster
+    def run(results)
+      return if Scan.config[:skip_slack]
+      return if Scan.config[:slack_only_on_failure] && results[:failures] == 0
+      return if Scan.config[:slack_url].to_s.empty?
+
+      if Scan.config[:slack_channel].to_s.length > 0
+        channel = Scan.config[:slack_channel]
+        channel = ('#' + channel) unless ['#', '@'].include?(channel[0]) # send message to channel by default
+      end
+
+      username = Scan.config[:slack_use_webhook_configured_username_and_icon] ? nil : Scan.config[:slack_username]
+      icon_url = Scan.config[:slack_use_webhook_configured_username_and_icon] ? nil : Scan.config[:slack_icon_url]
+      fields = []
+
+      if results[:build_errors]
+        fields << {
+          title: 'Build Errors',
+          value: results[:build_errors].to_s,
+          short: true
+        }
+      end
+
+      if results[:failures]
+        fields << {
+          title: 'Test Failures',
+          value: results[:failures].to_s,
+          short: true
+        }
+      end
+
+      if results[:tests] && results[:failures]
+        fields << {
+          title: 'Successful Tests',
+          value: (results[:tests] - results[:failures]).to_s,
+          short: true
+        }
+      end
+
+      Fastlane::Actions::SlackAction.run({
+        message: "#{Scan.project.app_name} Tests:\n#{Scan.config[:slack_message]}",
+        channel: channel,
+        slack_url: Scan.config[:slack_url].to_s,
+        success: results[:build_errors].to_i == 0 && results[:failures].to_i == 0,
+        username: username,
+        icon_url: icon_url,
+        payload: {},
+        attachment_properties: {
+          fields: fields
+        }
+      })
+    end
+  end
+end

data/scan/lib/scan/test_command_generator.rb

@@ -0,0 +1,160 @@
+require_relative 'xcpretty_reporter_options_generator'
+
+module Scan
+  # Responsible for building the fully working xcodebuild command
+  class TestCommandGenerator
+    def generate
+      parts = prefix
+      parts << Scan.config[:xcodebuild_command]
+      parts += options
+      parts += actions
+      parts += suffix
+      parts += pipe
+
+      parts
+    end
+
+    def prefix
+      ["set -o pipefail &&"]
+    end
+
+    # Path to the project or workspace as parameter
+    # This will also include the scheme (if given)
+    # @return [Array] The array with all the components to join
+    def project_path_array
+      proj = Scan.project.xcodebuild_parameters
+      return proj if proj.count > 0
+      UI.user_error!("No project/workspace found")
+    end
+
+    def options
+      config = Scan.config
+
+      options = []
+      options += project_path_array unless config[:xctestrun]
+      options << "-sdk '#{config[:sdk]}'" if config[:sdk]
+      options << destination # generated in `detect_values`
+      options << "-toolchain '#{config[:toolchain]}'" if config[:toolchain]
+      options << "-derivedDataPath '#{config[:derived_data_path]}'" if config[:derived_data_path]
+      options << "-resultBundlePath '#{result_bundle_path}'" if config[:result_bundle]
+      options << "-maximum-concurrent-test-simulator-destinations #{config[:max_concurrent_simulators]}" if config[:max_concurrent_simulators]
+      options << "-disable-concurrent-testing" if config[:disable_concurrent_testing]
+      options << "-enableCodeCoverage #{config[:code_coverage] ? 'YES' : 'NO'}" unless config[:code_coverage].nil?
+      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 << "-xctestrun '#{config[:xctestrun]}'" if config[:xctestrun]
+      options << config[:xcargs] if config[:xcargs]
+
+      # detect_values will ensure that these values are present as Arrays if
+      # they are present at all
+      options += config[:only_testing].map { |test_id| "-only-testing:#{test_id.shellescape}" } if config[:only_testing]
+      options += config[:skip_testing].map { |test_id| "-skip-testing:#{test_id.shellescape}" } if config[:skip_testing]
+
+      options
+    end
+
+    def actions
+      config = Scan.config
+
+      actions = []
+      actions << :clean if config[:clean]
+
+      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
+
+    def suffix
+      suffix = []
+      suffix
+    end
+
+    def pipe
+      pipe = ["| tee '#{xcodebuild_log_path}'"]
+
+      if Scan.config[:output_style] == 'raw'
+        return pipe
+      end
+
+      formatter = []
+      if (custom_formatter = Scan.config[:formatter])
+        if custom_formatter.end_with?(".rb")
+          formatter << "-f '#{custom_formatter}'"
+        else
+          formatter << "-f `#{custom_formatter}`"
+        end
+      elsif FastlaneCore::Env.truthy?("TRAVIS")
+        formatter << "-f `xcpretty-travis-formatter`"
+        UI.success("Automatically switched to Travis formatter")
+      end
+
+      if Helper.colors_disabled?
+        formatter << "--no-color"
+      end
+
+      if Scan.config[:output_style] == 'basic'
+        formatter << "--no-utf"
+      end
+
+      if Scan.config[:output_style] == 'rspec'
+        formatter << "--test"
+      end
+
+      @reporter_options_generator = XCPrettyReporterOptionsGenerator.new(Scan.config[:open_report],
+                                                                         Scan.config[:output_types],
+                                                                         Scan.config[:output_files] || Scan.config[:custom_report_file_name],
+                                                                         Scan.config[:output_directory],
+                                                                         Scan.config[:use_clang_report_name],
+                                                                         Scan.config[:xcpretty_args])
+      reporter_options = @reporter_options_generator.generate_reporter_options
+      reporter_xcpretty_args = @reporter_options_generator.generate_xcpretty_args_options
+      return pipe << "| xcpretty #{formatter.join(' ')} #{reporter_options.join(' ')} #{reporter_xcpretty_args}"
+    end
+
+    # Store the raw file
+    def xcodebuild_log_path
+      file_name = "#{Scan.project.app_name}-#{Scan.config[:scheme]}.log"
+      containing = File.expand_path(Scan.config[:buildlog_path])
+      FileUtils.mkdir_p(containing)
+
+      return File.join(containing, file_name)
+    end
+
+    # Generate destination parameters
+    def destination
+      unless Scan.cache[:destination]
+        Scan.cache[:destination] = [*Scan.config[:destination]].map { |dst| "-destination '#{dst}'" }.join(' ')
+      end
+      Scan.cache[:destination]
+    end
+
+    # The path to set the Derived Data to
+    def build_path
+      unless Scan.cache[:build_path]
+        day = Time.now.strftime("%F") # e.g. 2015-08-07
+
+        Scan.cache[:build_path] = File.expand_path("~/Library/Developer/Xcode/Archives/#{day}/")
+        FileUtils.mkdir_p(Scan.cache[:build_path])
+      end
+      Scan.cache[:build_path]
+    end
+
+    def result_bundle_path
+      unless Scan.cache[:result_bundle_path]
+        path = File.join(Scan.config[:output_directory], Scan.config[:scheme]) + ".test_result"
+        if File.directory?(path)
+          FileUtils.remove_dir(path)
+        end
+        Scan.cache[:result_bundle_path] = path
+      end
+      return Scan.cache[:result_bundle_path]
+    end
+  end
+end

data/scan/lib/scan/test_result_parser.rb

@@ -0,0 +1,26 @@
+require_relative 'module'
+
+module Scan
+  class TestResultParser
+    def parse_result(output)
+      # e.g. ...<testsuites tests='2' failures='1'>...
+      matched = output.scan(/<testsuites\b(?=[^<>]*\s+tests='(\d+)')(?=[^<>]*\s+failures='(\d+)')[^<>]+>/)
+
+      if matched && matched.length == 1 && matched[0].length == 2
+        tests = matched[0][0].to_i
+        failures = matched[0][1].to_i
+
+        return {
+          tests: tests,
+          failures: failures
+        }
+      else
+        UI.error("Couldn't parse the number of tests from the output")
+        return {
+          tests: 0,
+          failures: 0
+        }
+      end
+    end
+  end
+end

data/scan/lib/scan/xcpretty_reporter_options_generator.rb

@@ -0,0 +1,85 @@
+require_relative 'module'
+
+module Scan
+  class XCPrettyReporterOptionsGenerator
+    SUPPORTED_REPORT_TYPES = %w(html junit json-compilation-database)
+
+    def self.generate_from_scan_config
+      self.new(Scan.config[:open_report],
+               Scan.config[:output_types],
+               Scan.config[:output_files] || Scan.config[:custom_report_file_name],
+               Scan.config[:output_directory],
+               Scan.config[:use_clang_report_name],
+               Scan.config[:xcpretty_args])
+    end
+
+    # Intialize with values from Scan.config matching these param names
+    def initialize(open_report, output_types, output_files, output_directory, use_clang_report_name, xcpretty_args)
+      @open_report = open_report
+      @output_types = output_types
+      @output_files = output_files
+      @output_directory = output_directory
+      @use_clang_report_name = use_clang_report_name
+      @xcpretty_args = xcpretty_args
+
+      # might already be an array when passed via fastlane
+      @output_types = @output_types.split(',') if @output_types.kind_of?(String)
+
+      if @output_files.nil?
+        @output_files = @output_types.map { |type| "report.#{type}" }
+      elsif @output_files.kind_of?(String)
+        # might already be an array when passed via fastlane
+        @output_files = @output_files.split(',')
+      end
+
+      unless @output_types.length == @output_files.length
+        UI.important("WARNING: output_types and output_files do not have the same number of items. Default values will be substituted as needed.")
+      end
+
+      (@output_types - SUPPORTED_REPORT_TYPES).each do |type|
+        UI.error("Couldn't find reporter '#{type}', available #{SUPPORTED_REPORT_TYPES.join(', ')}")
+      end
+    end
+
+    def generate_reporter_options
+      reporter = []
+
+      valid_types = @output_types & SUPPORTED_REPORT_TYPES
+      valid_types.each do |raw_type|
+        type = raw_type.strip
+        output_path = File.join(File.expand_path(@output_directory), determine_output_file_name(type))
+        reporter << "--report #{type}"
+        reporter << "--output '#{output_path}'"
+
+        if type == "html" && @open_report
+          Scan.cache[:open_html_report_path] = output_path
+        end
+      end
+
+      # adds another junit reporter in case the user does not specify one
+      # this will be used to generate a results table and then discarded
+      require 'tempfile'
+      @temp_junit_report = Tempfile.new("junit_report")
+      Scan.cache[:temp_junit_report] = @temp_junit_report.path
+      reporter << "--report junit"
+      reporter << "--output '#{Scan.cache[:temp_junit_report]}'"
+      return reporter
+    end
+
+    def generate_xcpretty_args_options
+      return @xcpretty_args
+    end
+
+    private
+
+    def determine_output_file_name(type)
+      if @use_clang_report_name && type == "json-compilation-database"
+        return "compile_commands.json"
+      end
+
+      index = @output_types.index(type)
+      file = @output_files[index]
+      file || "report.#{type}"
+    end
+  end
+end

data/screengrab/README.md

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

data/screengrab/lib/assets/ScreengrabfileTemplate

@@ -0,0 +1,15 @@
+# remove the leading '#' to uncomment lines
+
+# app_package_name('your.app.package')
+# use_tests_in_packages(['your.screenshot.tests.package'])
+
+# app_apk_path('path/to/your/app.apk')
+# tests_apk_path('path/to/your/tests.apk')
+
+locales(['en-US', 'fr-FR', 'it-IT'])
+
+# clear all previously generated screenshots in your local output directory before creating new ones
+clear_previous_screenshots(true)
+
+# For more information about all available options run
+#   fastlane screengrab --help

data/screengrab/lib/assets/ScreengrabfileTemplate.swift

@@ -0,0 +1,15 @@
+// remove the leading "//" to uncomment lines
+
+// For more information about all available options run
+//   fastlane screengrab --help
+
+class Screengrabfile: ScreengrabfileProtocol {
+    //var appPackageName: String { return "your.app.package" }
+    //var useTestsInPackages: [String] { return ["your.screenshot.tests.package"] }
+    //var appApkPath: String? { return "path/to/your/app.apk" }
+    //var testsApkPath: String? { return "path/to/your/tests.apk" }
+    var locales: [String] { return ["en-US", "fr-FR", "it-IT"] }
+
+    // clear all previously generated screenshots in your local output directory before creating new ones
+    var clearPreviousScreenshots: Bool { return true }
+}

data/screengrab/lib/screengrab.rb

@@ -0,0 +1,7 @@
+require_relative 'screengrab/runner'
+require_relative 'screengrab/reports_generator'
+require_relative 'screengrab/detect_values'
+require_relative 'screengrab/dependency_checker'
+require_relative 'screengrab/options'
+require_relative 'screengrab/android_environment'
+require_relative 'screengrab/module'

data/screengrab/lib/screengrab/android_environment.rb

@@ -0,0 +1,91 @@
+require_relative 'module'
+require 'fastlane_core/command_executor'
+
+module Screengrab
+  class AndroidEnvironment
+    attr_reader :android_home
+    attr_reader :build_tools_version
+
+    # android_home        - the String path to the install location of the Android SDK
+    # build_tools_version - the String version of the Android build tools that should be used
+    def initialize(android_home, build_tools_version)
+      @android_home = android_home
+      @build_tools_version = build_tools_version
+    end
+
+    def platform_tools_path
+      @platform_tools_path ||= find_platform_tools(android_home)
+    end
+
+    def build_tools_path
+      @build_tools_path ||= find_build_tools(android_home, build_tools_version)
+    end
+
+    def adb_path
+      @adb_path ||= find_adb(platform_tools_path)
+    end
+
+    def aapt_path
+      @aapt_path ||= find_aapt(build_tools_path)
+    end
+
+    private
+
+    def find_platform_tools(android_home)
+      return nil unless android_home
+
+      platform_tools_path = File.join(android_home, 'platform-tools')
+      File.directory?(platform_tools_path) ? platform_tools_path : nil
+    end
+
+    def find_build_tools(android_home, build_tools_version)
+      return nil unless android_home
+
+      build_tools_dir = File.join(android_home, 'build-tools')
+
+      return nil unless build_tools_dir && File.directory?(build_tools_dir)
+
+      return File.join(build_tools_dir, build_tools_version) if build_tools_version
+
+      version = select_build_tools_version(build_tools_dir)
+
+      return version ? File.join(build_tools_dir, version) : nil
+    end
+
+    def select_build_tools_version(build_tools_dir)
+      # Collect the sub-directories of the build_tools_dir, rejecting any that start with '.' to remove . and ..
+      dir_names = Dir.entries(build_tools_dir).select { |e| !e.start_with?('.') && File.directory?(File.join(build_tools_dir, e)) }
+
+      # Collect a sorted array of Version objects from the directory names, handling the possibility that some
+      # entries may not be valid version names
+      versions = dir_names.map do |d|
+        begin
+          Gem::Version.new(d)
+        rescue
+          nil
+        end
+      end.reject(&:nil?).sort
+
+      # We'll take the last entry (highest version number) as the directory name we want
+      versions.last.to_s
+    end
+
+    def find_adb(platform_tools_path)
+      return FastlaneCore::CommandExecutor.which('adb') unless platform_tools_path
+
+      adb_path = File.join(platform_tools_path, 'adb')
+      return executable_command?(adb_path) ? adb_path : nil
+    end
+
+    def find_aapt(build_tools_path)
+      return FastlaneCore::CommandExecutor.which('aapt') unless build_tools_path
+
+      aapt_path = File.join(build_tools_path, 'aapt')
+      return executable_command?(aapt_path) ? aapt_path : nil
+    end
+
+    def executable_command?(cmd_path)
+      Helper.executable?(cmd_path)
+    end
+  end
+end