fastlane 1.111.0 → 2.0.1

data/fastlane_core/lib/fastlane_core/ui/github_issue_inspector_reporter.rb

@@ -0,0 +1,50 @@
+module Fastlane
+  # Adds all the necessary emojis (obv)
+  #
+  class InspectorReporter
+    NUMBER_OF_ISSUES_INLINE = 3
+
+    # Called just as the investigation has begun.
+    def inspector_started_query(query, inspector)
+      puts ""
+      puts "Looking for related GitHub issues on #{inspector.repo_owner}/#{inspector.repo_name}..."
+      puts "Search query: #{query}" if $verbose
+      puts ""
+    end
+
+    # Called once the inspector has recieved a report with more than one issue.
+    def inspector_successfully_recieved_report(report, inspector)
+      report.issues[0..(NUMBER_OF_ISSUES_INLINE - 1)].each { |issue| print_issue_full(issue) }
+
+      if report.issues.count > NUMBER_OF_ISSUES_INLINE
+        puts "and #{report.total_results - NUMBER_OF_ISSUES_INLINE} more at: #{report.url}"
+      end
+    end
+
+    # Called once the report has been recieved, but when there are no issues found.
+    def inspector_recieved_empty_report(report, inspector)
+      puts "Found no similar issues. To create a new issue, please visit:"
+      puts "https://github.com/#{inspector.repo_owner}/#{inspector.repo_name}/issues/new"
+      puts "Run `fastlane env` to append the fastlane environment to your issue"
+    end
+
+    # Called when there have been networking issues in creating the report.
+    def inspector_could_not_create_report(error, query, inspector)
+      puts "Could not access the GitHub API, you may have better luck via the website."
+      puts "https://github.com/#{inspector.repo_owner}/#{inspector.repo_name}/search?q=#{query}&type=Issues&utf8=✓"
+      puts "Error: #{error.name}"
+    end
+
+    private
+
+    def print_issue_full(issue)
+      resolved = issue.state == 'closed'
+      status = (resolved ? issue.state.green : issue.state.red)
+
+      puts "➡️  #{issue.title.yellow}"
+      puts "   #{issue.html_url} [#{status}] #{issue.comments} 💬"
+      puts "   #{Time.parse(issue.updated_at).to_pretty}"
+      puts ""
+    end
+  end
+end

data/fastlane_core/lib/fastlane_core/ui/implementations/shell.rb

@@ -0,0 +1,122 @@
+module FastlaneCore
+  # Shell is the terminal output of things
+  # For documentation for each of the methods open `interface.rb`
+  class Shell < Interface
+    def log
+      return @log if @log
+
+      $stdout.sync = true
+
+      if Helper.is_test?
+        @log ||= Logger.new(nil) # don't show any logs when running tests
+      else
+        @log ||= Logger.new($stdout)
+      end
+
+      @log.formatter = proc do |severity, datetime, progname, msg|
+        if $verbose
+          string = "#{severity} [#{datetime.strftime('%Y-%m-%d %H:%M:%S.%2N')}]: "
+        elsif FastlaneCore::Env.truthy?("FASTLANE_HIDE_TIMESTAMP")
+          string = ""
+        else
+          string = "[#{datetime.strftime('%H:%M:%S')}]: "
+        end
+
+        string += "#{msg}\n"
+
+        string
+      end
+
+      @log
+    end
+
+    #####################################################
+    # @!group Messaging: show text to the user
+    #####################################################
+
+    def error(message)
+      log.error(message.to_s.red)
+    end
+
+    def important(message)
+      log.warn(message.to_s.yellow)
+    end
+
+    def success(message)
+      log.info(message.to_s.green)
+    end
+
+    def message(message)
+      log.info(message.to_s)
+    end
+
+    def deprecated(message)
+      log.error(message.to_s.bold.blue)
+    end
+
+    def command(message)
+      log.info("$ #{message}".cyan.underline)
+    end
+
+    def command_output(message)
+      actual = (message.split("\r").last || "") # as clearing the line will remove the `>` and the time stamp
+      actual.split("\n").each do |msg|
+        prefix = msg.include?("▸") ? "" : "▸ "
+        log.info(prefix + "" + msg.magenta)
+      end
+    end
+
+    def verbose(message)
+      log.debug(message.to_s) if $verbose
+    end
+
+    def header(message)
+      i = message.length + 8
+      success("-" * i)
+      success("--- " + message + " ---")
+      success("-" * i)
+    end
+
+    #####################################################
+    # @!group Errors: Inputs
+    #####################################################
+
+    def interactive?
+      interactive = true
+      interactive = false if $stdout.isatty == false
+      interactive = false if Helper.ci?
+      return interactive
+    end
+
+    def input(message)
+      verify_interactive!(message)
+      ask(message.to_s.yellow).to_s.strip
+    end
+
+    def confirm(message)
+      verify_interactive!(message)
+      agree("#{message} (y/n)".yellow, true)
+    end
+
+    def select(message, options)
+      verify_interactive!(message)
+
+      important(message)
+      choose(*options)
+    end
+
+    def password(message)
+      verify_interactive!(message)
+
+      ask(message.yellow) { |q| q.echo = "*" }
+    end
+
+    private
+
+    def verify_interactive!(message)
+      return if interactive?
+      important(message)
+      crash!("Could not retrieve response as fastlane runs in non-interactive mode")
+    end
+  end
+end

data/fastlane_core/lib/fastlane_core/ui/interface.rb

@@ -0,0 +1,159 @@
+module FastlaneCore
+  # Abstract super class
+  class Interface
+    #####################################################
+    # @!group Messaging: show text to the user
+    #####################################################
+
+    # Level Error: Can be used to show additional error
+    #   information before actually raising an exception
+    #   or can be used to just show an error from which
+    #   fastlane can recover (much magic)
+    #
+    #   By default those messages are shown in red
+    def error(_message)
+      not_implemented(__method__)
+    end
+
+    # Level Important: Can be used to show warnings to the user
+    #   not necessarly negative, but something the user should
+    #   be aware of.
+    #
+    #   By default those messages are shown in yellow
+    def important(_message)
+      not_implemented(__method__)
+    end
+
+    # Level Success: Show that something was successful
+    #
+    #   By default those messages are shown in green
+    def success(_message)
+      not_implemented(__method__)
+    end
+
+    # Level Message: Show a neutral message to the user
+    #
+    #   By default those messages shown in white/black
+    def message(_message)
+      not_implemented(__method__)
+    end
+
+    # Level Deprecated: Show that a particular function is deprecated
+    #
+    #   By default those messages shown in strong blue
+    def deprecated(_message)
+      not_implemented(__method__)
+    end
+
+    # Level Command: Print out a terminal command that is being
+    #   executed.
+    #
+    #   By default those messages shown in cyan
+    def command(_message)
+      not_implemented(__method__)
+    end
+
+    # Level Command Output: Print the output of a command with
+    #   this method
+    #
+    #   By default those messages shown in magenta
+    def command_output(_message)
+      not_implemented(__method__)
+    end
+
+    # Level Verbose: Print out additional information for the
+    #   users that are interested. Will only be printed when
+    #   $verbose = true
+    #
+    #   By default those messages are shown in white
+    def verbose(_message)
+      not_implemented(__method__)
+    end
+
+    # Print a header = a text in a box
+    #   use this if this message is really important
+    def header(_message)
+      not_implemented(__method__)
+    end
+
+    #####################################################
+    # @!group Errors: Inputs
+    #####################################################
+
+    # Is is possible to ask the user questions?
+    def interactive?(_message)
+      not_implemented(__method__)
+    end
+
+    # get a standard text input (single line)
+    def input(_message)
+      not_implemented(__method__)
+    end
+
+    # A simple yes or no question
+    def confirm(_message)
+      not_implemented(__method__)
+    end
+
+    # Let the user select one out of x items
+    # return value is the value of the option the user chose
+    def select(_message, _options)
+      not_implemented(__method__)
+    end
+
+    # Password input for the user, text field shouldn't show
+    # plain text
+    def password(_message)
+      not_implemented(__method__)
+    end
+
+    #####################################################
+    # @!group Errors: Different kinds of exceptions
+    #####################################################
+
+    # raised from crash!
+    class FastlaneCrash < StandardError
+    end
+
+    # raised from user_error!
+    class FastlaneError < StandardError
+      attr_reader :show_github_issues
+
+      def initialize(show_github_issues: false)
+        @show_github_issues = show_github_issues
+      end
+    end
+
+    # Pass an exception to this method to exit the program
+    #   using the given exception
+    # Use this method instead of user_error! if this error is
+    # unexpected, e.g. an invalid server response that shouldn't happen
+    def crash!(exception)
+      raise FastlaneCrash.new, exception.to_s
+    end
+
+    # Use this method to exit the program because of an user error
+    #   e.g. app doesn't exist on the given Developer Account
+    #        or invalid user credentials
+    #        or scan tests fail
+    # This will show the error message, but doesn't show the full
+    #   stack trace
+    # Basically this should be used when you actively catch the error
+    # and want to show a nice error message to the user
+    def user_error!(error_message, options = {})
+      options = { show_github_issues: false }.merge(options)
+      raise FastlaneError.new(show_github_issues: options[:show_github_issues]), error_message.to_s
+    end
+
+    #####################################################
+    # @!group Helpers
+    #####################################################
+    def not_implemented(method_name)
+      UI.user_error!("Current UI '#{self}' doesn't support method '#{method_name}'")
+    end
+
+    def to_s
+      self.class.name.split('::').last
+    end
+  end
+end

data/fastlane_core/lib/fastlane_core/ui/ui.rb

@@ -0,0 +1,26 @@
+module FastlaneCore
+  class UI
+    class << self
+      def current
+        @current ||= Shell.new
+      end
+    end
+
+    def self.method_missing(method_sym, *args, &_block)
+      # not using `responds` beacuse we don't care about methods like .to_s and so on
+      interface_methods = Interface.instance_methods - Object.instance_methods
+      UI.user_error!("Unknown method '#{method_sym}', supported #{interface_methods}") unless interface_methods.include?(method_sym)
+
+      self.current.send(method_sym, *args)
+    end
+  end
+end
+
+require 'fastlane_core/ui/interface'
+
+# Import all available implementations
+Dir[File.expand_path('implementations/*.rb', File.dirname(__FILE__))].each do |file|
+  require file
+end
+
+require 'fastlane_core/ui/disable_colors' if FastlaneCore::Helper.colors_disabled?

data/fastlane_core/lib/fastlane_core/update_checker/changelog.rb

@@ -0,0 +1,37 @@
+require 'excon'
+
+module FastlaneCore
+  class Changelog
+    class << self
+      def show_changes(gem_name, current_version)
+        did_show_changelog = false
+
+        self.releases(gem_name).each_with_index do |release, index|
+          next unless Gem::Version.new(release['tag_name']) > Gem::Version.new(current_version)
+          puts ""
+          puts release['name'].green
+          puts release['body']
+          did_show_changelog = true
+
+          next unless index == 2
+          puts ""
+          puts "To see all new releases, open https://github.com/fastlane/#{gem_name}/releases".green
+          break
+        end
+
+        puts ""
+        puts "Please update using `#{UpdateChecker.update_command(gem_name: gem_name)}`".green if did_show_changelog
+      rescue
+        # Something went wrong, we don't care so much about this
+      end
+
+      def releases(gem_name)
+        url = "https://api.github.com/repos/fastlane/#{gem_name}/releases"
+        # We have to follow redirects, since some repos were moved away into a separate org
+        server_response = Excon.get(url,
+                                    middlewares: Excon.defaults[:middlewares] + [Excon::Middleware::RedirectFollower])
+        JSON.parse(server_response.body)
+      end
+    end
+  end
+end

data/fastlane_core/lib/fastlane_core/update_checker/update_checker.rb

@@ -0,0 +1,198 @@
+require 'excon'
+require 'digest'
+
+require 'fastlane_core/update_checker/changelog'
+
+module FastlaneCore
+  # Verifies, the user runs the latest version of this gem
+  class UpdateChecker
+    # This web service is fully open source: https://github.com/fastlane/refresher
+    UPDATE_URL = "https://fastlane-refresher.herokuapp.com/"
+
+    def self.start_looking_for_update(gem_name)
+      return if Helper.is_test?
+      return if FastlaneCore::Env.truthy?("FASTLANE_SKIP_UPDATE_CHECK")
+
+      @start_time = Time.now
+
+      url = generate_fetch_url(gem_name)
+      Thread.new do
+        begin
+          server_results[gem_name] = fetch_latest(url)
+        rescue
+        end
+      end
+    end
+
+    def self.server_results
+      @results ||= {}
+    end
+
+    def self.update_available?(gem_name, current_version)
+      latest = server_results[gem_name]
+      return (latest and Gem::Version.new(latest) > Gem::Version.new(current_version))
+    end
+
+    def self.show_update_status(gem_name, current_version)
+      fork do
+        begin
+          finished_running(gem_name)
+        rescue
+          # we don't want to show a stack trace if something goes wrong
+        end
+      end
+
+      if update_available?(gem_name, current_version)
+        show_update_message(gem_name, current_version)
+      end
+    end
+
+    # Show a message to the user to update to a new version of fastlane (or a sub-gem)
+    # Use this method, as this will detect the current Ruby environment and show an
+    # appropriate message to the user
+    def self.show_update_message(gem_name, current_version)
+      available = server_results[gem_name]
+      puts ""
+      puts '#######################################################################'.green
+      if available
+        puts "# #{gem_name} #{available} is available. You are on #{current_version}.".green
+      else
+        puts "# An update for #{gem_name} is available. You are on #{current_version}.".green
+      end
+      puts "# It is recommended to use the latest version.".green
+      puts "# Please update using `#{self.update_command(gem_name: gem_name)}`.".green
+
+      puts "# To see what's new, open https://github.com/fastlane/#{gem_name}/releases.".green if FastlaneCore::Env.truthy?("FASTLANE_HIDE_CHANGELOG")
+
+      if !Helper.bundler? && !Helper.contained_fastlane? && Random.rand(5) == 1
+        # We want to show this message from time to time, if the user doesn't use bundler, nor bundled fastlane
+        puts '#######################################################################'.green
+        puts "# Run `sudo gem cleanup` from time to time to speed up fastlane".green
+      end
+      puts '#######################################################################'.green
+      Changelog.show_changes(gem_name, current_version) unless FastlaneCore::Env.truthy?("FASTLANE_HIDE_CHANGELOG")
+    end
+
+    # The command that the user should use to update their mac
+    def self.update_command(gem_name: "fastlane")
+      if Helper.bundler?
+        "bundle update #{gem_name.downcase}"
+      elsif Helper.contained_fastlane?
+        "fastlane update_fastlane"
+      else
+        "sudo gem update #{gem_name.downcase}"
+      end
+    end
+
+    # Generate the URL on the main thread (since we're switching directory)
+    def self.generate_fetch_url(gem_name)
+      url = UPDATE_URL + gem_name
+      params = {}
+      params["ci"] = "1" if Helper.is_ci?
+
+      project_hash = p_hash(ARGV, gem_name)
+      params["p_hash"] = project_hash if project_hash
+      params["platform"] = @platform if @platform # this has to be called after `p_hash`
+
+      url += "?" + URI.encode_www_form(params) if params.count > 0
+      return url
+    end
+
+    def self.fetch_latest(url)
+      JSON.parse(Excon.post(url).body).fetch("version", nil)
+    end
+
+    def self.finished_running(gem_name)
+      return if ENV["FASTLANE_OPT_OUT_USAGE"]
+
+      time = (Time.now - @start_time).to_i
+      url = UPDATE_URL + "time/#{gem_name}"
+      url += "?time=#{time}"
+      url += "&ci=1" if Helper.ci?
+      url += "&gem=1" if Helper.rubygems?
+      url += "&bundler=1" if Helper.bundler?
+      url += "&mac_app=1" if Helper.mac_app?
+      url += "&standalone=1" if Helper.contained_fastlane?
+      url += "&homebrew=1" if Helper.homebrew?
+
+      Excon.post(url)
+    end
+
+    # (optional) Returns the app identifier for the current tool
+    def self.ios_app_identifier(args)
+      # args example: ["-a", "com.krausefx.app", "--team_id", "5AA97AAHK2"]
+      args.each_with_index do |current, index|
+        if current == "-a" || current == "--app_identifier"
+          return args[index + 1] if args.count > index
+        end
+      end
+
+      ["FASTLANE", "DELIVER", "PILOT", "PRODUCE", "PEM", "SIGH", "SNAPSHOT", "MATCH"].each do |current|
+        return ENV["#{current}_APP_IDENTIFIER"] if FastlaneCore::Env.truthy?("#{current}_APP_IDENTIFIER")
+      end
+
+      return CredentialsManager::AppfileConfig.try_fetch_value(:app_identifier)
+    rescue
+      nil # we don't want this method to cause a crash
+    end
+
+    # (optional) Returns the app identifier for the current tool
+    # supply and screengrab use different param names and env variable patterns so we have to special case here
+    # example:
+    #   supply --skip_upload_screenshots -a beta -p com.test.app should return com.test.app
+    #   screengrab -a com.test.app should return com.test.app
+    def self.android_app_identifier(args, gem_name)
+      app_identifier = nil
+      # args example: ["-a", "com.krausefx.app"]
+      args.each_with_index do |current, index|
+        if android_app_identifier_arg?(gem_name, current)
+          app_identifier = args[index + 1] if args.count > index
+          break
+        end
+      end
+
+      app_identifier ||= ENV["SUPPLY_PACKAGE_NAME"] if FastlaneCore::Env.truthy?("SUPPLY_PACKAGE_NAME")
+      app_identifier ||= ENV["SCREENGRAB_APP_PACKAGE_NAME"] if FastlaneCore::Env.truthy?("SCREENGRAB_APP_PACKAGE_NAME")
+      app_identifier ||= CredentialsManager::AppfileConfig.try_fetch_value(:package_name)
+
+      # Add Android prefix to prevent collisions if there is an iOS app with the same identifier
+      app_identifier ? "android_project_#{app_identifier}" : nil
+    rescue
+      nil # we don't want this method to cause a crash
+    end
+
+    def self.android_app_identifier_arg?(gem_name, arg)
+      return arg == "--package_name" ||
+             arg == "--app_package_name" ||
+             (arg == '-p' && gem_name == 'supply') ||
+             (arg == '-a' && gem_name == 'screengrab')
+    end
+
+    # To not count the same projects multiple time for the number of launches
+    # More information: https://github.com/fastlane/refresher
+    # Use the `FASTLANE_OPT_OUT_USAGE` variable to opt out
+    # The resulting value is e.g. ce12f8371df11ef6097a83bdf2303e4357d6f5040acc4f76019489fa5deeae0d
+    def self.p_hash(args, gem_name)
+      return nil if FastlaneCore::Env.truthy?("FASTLANE_OPT_OUT_USAGE")
+      require 'credentials_manager'
+
+      # check if this is an android project first because some of the same params exist for iOS and Android tools
+      app_identifier = android_app_identifier(args, gem_name)
+      @platform = nil # since have a state in-between runs
+      if app_identifier
+        @platform = :android
+      else
+        app_identifier = ios_app_identifier(args)
+        @platform = :ios if app_identifier
+      end
+
+      if app_identifier
+        return Digest::SHA256.hexdigest("p#{app_identifier}fastlan3_SAlt") # hashed + salted the bundle identifier
+      end
+
+      return nil
+    rescue
+      return nil
+    end
+  end
+end