fastlane_pricing_fix 2.212.1

data/scan/lib/scan/test_command_generator.rb

@@ -0,0 +1,262 @@
+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
+      prefixes = ["set -o pipefail &&"]
+
+      package_path = Scan.config[:package_path]
+      prefixes << "cd #{package_path} &&" if package_path.to_s != ""
+
+      prefixes
+    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
+      unless Scan.config[:package_path].nil?
+        params = []
+        params << "-scheme #{Scan.config[:scheme].shellescape}" if Scan.config[:scheme]
+        params << "-workspace #{Scan.config[:workspace].shellescape}" if Scan.config[:workspace]
+        return params
+      end
+
+      proj = Scan.project.xcodebuild_parameters
+      return proj if proj.count > 0
+      UI.user_error!("No project/workspace found")
+    end
+
+    def options # rubocop:disable Metrics/PerceivedComplexity
+      config = Scan.config
+
+      options = []
+      options += project_path_array unless config[:xctestrun]
+      options << "-sdk '#{config[:sdk]}'" if config[:sdk]
+      options << destination if destination # generated in `detect_values`
+      options << "-toolchain '#{config[:toolchain]}'" if config[:toolchain]
+      if config[:derived_data_path] && !options.include?("-derivedDataPath #{config[:derived_data_path].shellescape}")
+        options << "-derivedDataPath #{config[:derived_data_path].shellescape}"
+      end
+      if config[:use_system_scm] && !options.include?("-scmProvider system")
+        options << "-scmProvider system"
+      end
+      if config[:result_bundle_path]
+        options << "-resultBundlePath '#{config[:result_bundle_path].shellescape}'"
+        Scan.cache[:result_bundle_path] = config[:result_bundle_path]
+      elsif config[:result_bundle]
+        options << "-resultBundlePath '#{result_bundle_path(true)}'"
+      end
+      if FastlaneCore::Helper.xcode_at_least?(10)
+        options << "-parallel-testing-enabled #{config[:parallel_testing] ? 'YES' : 'NO'}" unless config[:parallel_testing].nil?
+        options << "-parallel-testing-worker-count #{config[:concurrent_workers]}" if config[:concurrent_workers]
+        options << "-maximum-concurrent-test-simulator-destinations #{config[:max_concurrent_simulators]}" if config[:max_concurrent_simulators]
+        options << "-disable-concurrent-testing" if config[:disable_concurrent_testing]
+      end
+      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?
+      if FastlaneCore::Helper.xcode_at_least?(11)
+        options << "-testPlan '#{config[:testplan]}'" if config[:testplan]
+
+        # detect_values will ensure that these values are present as Arrays if
+        # they are present at all
+        options += config[:only_test_configurations].map { |name| "-only-test-configuration '#{name}'" } if config[:only_test_configurations]
+        options += config[:skip_test_configurations].map { |name| "-skip-test-configuration '#{name}'" } if config[:skip_test_configurations]
+      end
+      options << "-xctestrun '#{config[:xctestrun]}'" if config[:xctestrun]
+      options << config[:xcargs] if config[:xcargs]
+
+      # Number of retries does not equal xcodebuild's -test-iterations number
+      # It needs include 1 iteration by default
+      number_of_retries = config[:number_of_retries] + 1
+      if number_of_retries > 1 && FastlaneCore::Helper.xcode_at_least?(13)
+        options << "-retry-tests-on-failure"
+        options << "-test-iterations #{number_of_retries}"
+      end
+
+      # 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}'"]
+
+      # disable_xcpretty is now deprecated and directs to use output_style of raw
+      if Scan.config[:disable_xcpretty] || Scan.config[:output_style] == 'raw'
+        return pipe
+      end
+
+      formatter = Scan.config[:xcodebuild_formatter].chomp
+      options = legacy_xcpretty_options
+
+      if formatter == ''
+        UI.verbose("Not using an xcodebuild formatter")
+      elsif !options.empty?
+        UI.important("Detected legacy xcpretty being used so formatting wth xcpretty")
+        UI.important("Option(s) used: #{options.join(', ')}")
+        pipe << pipe_xcpretty
+      elsif formatter == 'xcpretty'
+        pipe << pipe_xcpretty
+      elsif formatter == 'xcbeautify'
+        pipe << pipe_xcbeautify
+      else
+        pipe << "| #{formatter}"
+      end
+
+      return pipe
+    end
+
+    def pipe_xcbeautify
+      formatter = ['| xcbeautify']
+
+      if FastlaneCore::Helper.colors_disabled?
+        formatter << '--disable-colored-output'
+      end
+
+      return formatter.join(' ')
+    end
+
+    def legacy_xcpretty_options
+      options = []
+
+      options << "formatter" if Scan.config[:formatter]
+      options << "xcpretty_formatter" if Scan.config[:xcpretty_formatter]
+      options << "output_style" if Scan.config[:output_style]
+      options << "output_types" if (Scan.config[:output_types] || "").include?("json-compilation-database")
+      options << "custom_report_file_name" if Scan.config[:custom_report_file_name]
+
+      return options
+    end
+
+    def pipe_xcpretty
+      formatter = []
+      if (custom_formatter = Scan.config[:xcpretty_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 "| xcpretty #{formatter.join(' ')} #{reporter_options.join(' ')} #{reporter_xcpretty_args}"
+    end
+
+    # Store the raw file
+    def xcodebuild_log_path
+      parts = []
+      if Scan.config[:app_name]
+        parts << Scan.config[:app_name]
+      elsif Scan.project
+        parts << Scan.project.app_name
+      end
+      parts << Scan.config[:scheme] if Scan.config[:scheme]
+
+      file_name = "#{parts.join('-')}.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
+
+    # The path to the result bundle
+    def result_bundle_path(use_output_directory)
+      root_dir = use_output_directory ? Scan.config[:output_directory] : Dir.mktmpdir
+
+      retry_count = Scan.cache[:retry_attempt] || 0
+      attempt = retry_count > 0 ? "-#{retry_count}" : ""
+      ext = FastlaneCore::Helper.xcode_version.to_i >= 11 ? '.xcresult' : '.test_result'
+      path = File.join([root_dir, Scan.config[:scheme]].compact) + attempt + ext
+
+      Scan.cache[:result_bundle_path] = path
+
+      # The result bundle path will be in the package path directory if specified
+      delete_path = path
+      delete_path = File.join(Scan.config[:package_path], path) if Scan.config[:package_path].to_s != ""
+      FileUtils.remove_dir(delete_path) if File.directory?(delete_path)
+
+      return path
+    end
+  end
+end

data/scan/lib/scan/test_result_parser.rb

@@ -0,0 +1,33 @@
+require_relative 'module'
+
+module Scan
+  class TestResultParser
+    def parse_result(output)
+      unless output
+        return {
+            tests: 0,
+            failures: 0
+        }
+      end
+
+      # 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
+
+        {
+          tests: tests,
+          failures: failures
+        }
+      else
+        UI.error("Couldn't parse the number of tests from the output")
+        {
+          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
+
+    # Initialize 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/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/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/android_environment.rb

@@ -0,0 +1,43 @@
+require_relative 'module'
+require 'fastlane_core/command_executor'
+
+module Screengrab
+  class AndroidEnvironment
+    attr_reader :android_home
+
+    # 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, ignored
+    def initialize(android_home, build_tools_version = nil)
+      @android_home = android_home
+    end
+
+    def platform_tools_path
+      @platform_tools_path ||= find_platform_tools(android_home)
+    end
+
+    def adb_path
+      @adb_path ||= find_adb(platform_tools_path)
+    end
+
+    private
+
+    def find_platform_tools(android_home)
+      return nil unless android_home
+
+      platform_tools_path = Helper.localize_file_path(File.join(android_home, 'platform-tools'))
+      File.directory?(platform_tools_path) ? platform_tools_path : nil
+    end
+
+    def find_adb(platform_tools_path)
+      return FastlaneCore::CommandExecutor.which('adb') unless platform_tools_path
+
+      adb_path = Helper.get_executable_path(File.join(platform_tools_path, 'adb'))
+      adb_path = Helper.localize_file_path(adb_path)
+      return executable_command?(adb_path) ? adb_path : nil
+    end
+
+    def executable_command?(cmd_path)
+      Helper.executable?(cmd_path)
+    end
+  end
+end

data/screengrab/lib/screengrab/commands_generator.rb

@@ -0,0 +1,71 @@
+require 'commander'
+
+require 'fastlane/version'
+require 'fastlane_core/ui/help_formatter'
+require 'fastlane_core/fastlane_folder'
+require 'fastlane_core/configuration/configuration'
+require_relative 'android_environment'
+require_relative 'dependency_checker'
+require_relative 'runner'
+require_relative 'options'
+require_relative 'module'
+
+HighLine.track_eof = false
+
+module Screengrab
+  class CommandsGenerator
+    include Commander::Methods
+
+    def self.start
+      self.new.run
+    end
+
+    def run
+      program :name, 'screengrab'
+      program :version, Fastlane::VERSION
+      program :description, 'CLI for \'screengrab\' - Automate taking localized screenshots of your Android app on emulators or real devices'
+      program :help, 'Authors', 'Andrea Falcone <asfalcone@google.com>, Michael Furtak <mfurtak@google.com>'
+      program :help, 'Website', 'https://fastlane.tools'
+      program :help, 'Documentation', 'https://docs.fastlane.tools/actions/screengrab/'
+      program :help_formatter, FastlaneCore::HelpFormatter
+
+      global_option('--verbose', 'Shows a more verbose output') { FastlaneCore::Globals.verbose = true }
+
+      always_trace!
+
+      command :run do |c|
+        c.syntax = 'fastlane screengrab'
+        c.description = 'Take new screenshots based on the Screengrabfile.'
+
+        FastlaneCore::CommanderGenerator.new.generate(Screengrab::Options.available_options, command: c)
+
+        c.action do |args, options|
+          o = options.__hash__.dup
+          o.delete(:verbose)
+          Screengrab.config = FastlaneCore::Configuration.create(Screengrab::Options.available_options, o)
+          Screengrab.android_environment = Screengrab::AndroidEnvironment.new(Screengrab.config[:android_home],
+                                                                              Screengrab.config[:build_tools_version])
+
+          Screengrab::DependencyChecker.check(Screengrab.android_environment)
+          Screengrab::Runner.new.run
+        end
+      end
+
+      command :init do |c|
+        c.syntax = 'fastlane screengrab init'
+        c.description = "Creates a new Screengrabfile in the current directory"
+
+        c.action do |args, options|
+          require 'screengrab/setup'
+          path = Screengrab::Helper.fastlane_enabled? ? FastlaneCore::FastlaneFolder.path : '.'
+          is_swift_fastfile = args.include?("swift")
+          Screengrab::Setup.create(path, is_swift_fastfile: is_swift_fastfile)
+        end
+      end
+
+      default_command(:run)
+
+      run!
+    end
+  end
+end

data/screengrab/lib/screengrab/dependency_checker.rb

@@ -0,0 +1,38 @@
+require_relative 'module'
+
+module Screengrab
+  class DependencyChecker
+    def self.check(android_env)
+      return if Helper.test?
+
+      check_adb(android_env)
+    end
+
+    def self.check_adb(android_env)
+      android_home = android_env.android_home
+      adb_path = android_env.adb_path
+
+      warn_if_command_path_not_relative_to_android_home('adb', android_home, adb_path)
+      # adb is required to function, so we'll quit noisily if we couldn't find it
+      raise_missing_adb(android_home) unless adb_path
+    end
+
+    def self.raise_missing_adb(android_home)
+      if android_home
+        UI.error("The `adb` command could not be found relative to your provided ANDROID_HOME at #{android_home}")
+        UI.error("Please ensure that the Android SDK is installed and the platform-tools directory is present")
+      else
+        UI.error('The `adb` command could not be found on your PATH')
+        UI.error('Please ensure that the Android SDK is installed and the platform-tools directory is present and on your PATH')
+      end
+
+      UI.user_error!('adb command not found')
+    end
+
+    def self.warn_if_command_path_not_relative_to_android_home(cmd_name, android_home, cmd_path)
+      if android_home && cmd_path && !cmd_path.start_with?(android_home)
+        UI.important("Using `#{cmd_name}` found at #{cmd_path} which is not within the specified ANDROID_HOME at #{android_home}")
+      end
+    end
+  end
+end

data/screengrab/lib/screengrab/detect_values.rb

@@ -0,0 +1,16 @@
+module Screengrab
+  class DetectValues
+    # This is needed to supply default values which are based on config values determined in the initial
+    # configuration pass
+    def self.set_additional_default_values
+      config = Screengrab.config
+
+      # First, try loading the Screengrabfile from the current directory
+      config.load_configuration_file(Screengrab.screengrabfile_name)
+
+      unless config[:tests_package_name]
+        config[:tests_package_name] = "#{config[:app_package_name]}.test"
+      end
+    end
+  end
+end

data/screengrab/lib/screengrab/module.rb

@@ -0,0 +1,26 @@
+require 'fastlane_core/helper'
+require 'fastlane/boolean'
+require_relative 'detect_values'
+
+module Screengrab
+  # Use this to just setup the configuration attribute and set it later somewhere else
+  class << self
+    attr_accessor :config
+    attr_accessor :android_environment
+
+    def config=(value)
+      @config = value
+      DetectValues.set_additional_default_values
+    end
+
+    def screengrabfile_name
+      "Screengrabfile"
+    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 = "Automated localized screenshots of your Android app on every device".freeze
+end