fastlane_iac_publish 0.1.0

data/fastlane_core/lib/fastlane_core/android_package_name_guesser.rb

@@ -0,0 +1,79 @@
+require 'credentials_manager/appfile_config'
+
+require_relative 'configuration/configuration'
+require_relative 'env'
+
+module FastlaneCore
+  class AndroidPackageNameGuesser
+    class << self
+      def android_package_name_arg?(gem_name, arg)
+        return arg == "--package_name" ||
+               arg == "--app_package_name" ||
+               (arg == '-p' && gem_name == 'supply') ||
+               (arg == '-a' && gem_name == 'screengrab')
+      end
+
+      def guess_package_name_from_args(gem_name, args)
+        # args example: ["-a", "com.krausefx.app"]
+        package_name = nil
+        args.each_with_index do |current, index|
+          next unless android_package_name_arg?(gem_name, current)
+          # argument names are followed by argument values in the args array;
+          # use [index + 1] to find the package name (range check the array
+          # to avoid array bounds errors)
+          package_name = args[index + 1] if args.count > index
+          break
+        end
+        package_name
+      end
+
+      def guess_package_name_from_environment
+        package_name = nil
+        package_name ||= ENV["SUPPLY_PACKAGE_NAME"] if FastlaneCore::Env.truthy?("SUPPLY_PACKAGE_NAME")
+        package_name ||= ENV["SCREENGRAB_APP_PACKAGE_NAME"] if FastlaneCore::Env.truthy?("SCREENGRAB_APP_PACKAGE_NAME")
+        package_name
+      end
+
+      def guess_package_name_from_appfile
+        CredentialsManager::AppfileConfig.try_fetch_value(:package_name)
+      end
+
+      def fetch_package_name_from_file(file_name, package_name_key)
+        # we only care about the package name item in the configuration file, so
+        # build an options array & Configuration with just that one key and it will
+        # be fetched if it is present in the config file
+        genericfile_options = [FastlaneCore::ConfigItem.new(key: package_name_key)]
+        options = FastlaneCore::Configuration.create(genericfile_options, {})
+        # pass the empty proc to disable options validation, otherwise this will fail
+        # when the other (non-package name) keys are encountered in the config file;
+        # 3rd parameter "true" disables the printout of the contents of the
+        # configuration file, which is noisy and confusing in this case
+        options.load_configuration_file(file_name, proc {}, true)
+        return options.fetch(package_name_key, ask: false)
+      rescue
+        # any option/file error here should just be treated as identifier not found
+        nil
+      end
+
+      def guess_package_name_from_config_files
+        package_name = nil
+        package_name ||= fetch_package_name_from_file("Supplyfile", :package_name)
+        package_name ||= fetch_package_name_from_file("Screengrabfile", :app_package_name)
+        package_name
+      end
+
+      # make a best-guess for the package_name for this project, using most-reliable signals
+      #  first and then using less accurate ones afterwards; because this method only returns
+      #  a GUESS for the package_name, it is only useful for metrics or other places where
+      #  absolute accuracy is not required
+      def guess_package_name(gem_name, args)
+        package_name = nil
+        package_name ||= guess_package_name_from_args(gem_name, args)
+        package_name ||= guess_package_name_from_environment
+        package_name ||= guess_package_name_from_appfile
+        package_name ||= guess_package_name_from_config_files
+        package_name
+      end
+    end
+  end
+end

data/fastlane_core/lib/fastlane_core/build_watcher.rb

@@ -0,0 +1,80 @@
+require 'spaceship/connect_api'
+
+require_relative 'ui/ui'
+
+module FastlaneCore
+  class BuildWatcher
+    class << self
+      # @return The build we waited for. This method will always return a build
+      def wait_for_build_processing_to_be_complete(app_id: nil, platform: nil, train_version: nil, app_version: nil, build_version: nil, poll_interval: 10, strict_build_watch: false, return_spaceship_testflight_build: true)
+        # Warn about train_version being removed in the future
+        if train_version
+          UI.deprecated(":train_version is no longer a used argument on FastlaneCore::BuildWatcher. Please use :app_version instead.")
+        end
+        app_version = train_version
+
+        # Warn about strict_build_watch being removed in the future
+        if strict_build_watch
+          UI.deprecated(":strict_build_watch is no longer a used argument on FastlaneCore::BuildWatcher.")
+        end
+
+        loop do
+          matched_build, build_delivery = matching_build(watched_app_version: app_version, watched_build_version: build_version, app_id: app_id)
+
+          report_status(build: matched_build, build_delivery: build_delivery)
+
+          if matched_build && matched_build.processed?
+            if return_spaceship_testflight_build
+              return matched_build.to_testflight_build
+            else
+              return matched_build
+            end
+          end
+
+          sleep(poll_interval)
+        end
+      end
+
+      private
+
+      # Remove leading zeros ( https://developer.apple.com/library/archive/documentation/General/Reference/InfoPlistKeyReference/Articles/CoreFoundationKeys.html#//apple_ref/doc/uid/20001431-102364 )
+      def remove_version_leading_zeros(version: nil)
+        return version.instance_of?(String) ? version.split('.').map { |s| s.to_i.to_s }.join('.') : version
+      end
+
+      def matching_build(watched_app_version: nil, watched_build_version: nil, app_id: nil, platform: nil)
+        # Get build deliveries (newly uploaded processing builds)
+        watched_app_version = remove_version_leading_zeros(version: watched_app_version)
+        watched_build_version = remove_version_leading_zeros(version: watched_build_version)
+
+        build_deliveries = Spaceship::ConnectAPI::BuildDelivery.all(app_id: app_id, version: watched_app_version, build_number: watched_build_version)
+        build_delivery = build_deliveries.first
+
+        # Get processed builds when no longer in build deliveries
+        if build_delivery.nil?
+          matched_builds = Spaceship::ConnectAPI::Build.all(
+            app_id: app_id,
+            version: watched_app_version,
+            build_number: watched_build_version,
+            includes: "app,preReleaseVersion"
+          )
+          matched_build = matched_builds.first
+        end
+
+        return matched_build, build_delivery
+      end
+
+      def report_status(build: nil, build_delivery: nil)
+        if build_delivery
+          UI.message("Waiting for App Store Connect to finish processing the new build (#{build_delivery.cf_build_short_version_string} - #{build_delivery.cf_build_version})")
+        elsif build && !build.processed?
+          UI.message("Waiting for App Store Connect to finish processing the new build (#{build.app_version} - #{build.version})")
+        elsif build && build.processed?
+          UI.success("Successfully finished processing the build #{build.app_version} - #{build.version}")
+        else
+          UI.message("Build doesn't show up in the build list anymore, waiting for it to appear again (check your email for processing issues if this continues)")
+        end
+      end
+    end
+  end
+end

data/fastlane_core/lib/fastlane_core/cert_checker.rb

@@ -0,0 +1,116 @@
+require 'tempfile'
+require 'openssl'
+
+require_relative 'helper'
+
+module FastlaneCore
+  # This class checks if a specific certificate is installed on the current mac
+  class CertChecker
+    def self.installed?(path, in_keychain: nil)
+      UI.user_error!("Could not find file '#{path}'") unless File.exist?(path)
+
+      ids = installed_identies(in_keychain: in_keychain)
+      finger_print = sha1_fingerprint(path)
+
+      return ids.include?(finger_print)
+    end
+
+    # Legacy Method, use `installed?` instead
+    def self.is_installed?(path)
+      installed?(path)
+    end
+
+    def self.installed_identies(in_keychain: nil)
+      install_wwdr_certificate unless wwdr_certificate_installed?
+
+      available = list_available_identities(in_keychain: in_keychain)
+      # Match for this text against word boundaries to avoid edge cases around multiples of 10 identities!
+      if /\b0 valid identities found\b/ =~ available
+        UI.error([
+          "There are no local code signing identities found.",
+          "You can run" << " `security find-identity -v -p codesigning #{in_keychain}".rstrip << "` to get this output.",
+          "This Stack Overflow thread has more information: https://stackoverflow.com/q/35390072/774.",
+          "(Check in Keychain Access for an expired WWDR certificate: https://stackoverflow.com/a/35409835/774 has more info.)"
+        ].join("\n"))
+      end
+
+      ids = []
+      available.split("\n").each do |current|
+        next if current.include?("REVOKED")
+        begin
+          (ids << current.match(/.*\) ([[:xdigit:]]*) \".*/)[1])
+        rescue
+          # the last line does not match
+        end
+      end
+
+      return ids
+    end
+
+    def self.list_available_identities(in_keychain: nil)
+      commands = ['security find-identity -v -p codesigning']
+      commands << in_keychain if in_keychain
+      `#{commands.join(' ')}`
+    end
+
+    def self.wwdr_certificate_installed?
+      certificate_name = "Apple Worldwide Developer Relations Certification Authority"
+      keychain = wwdr_keychain
+      response = Helper.backticks("security find-certificate -c '#{certificate_name}' #{keychain.shellescape}", print: FastlaneCore::Globals.verbose?)
+      return response.include?("attributes:")
+    end
+
+    def self.install_wwdr_certificate
+      url = 'https://developer.apple.com/certificationauthority/AppleWWDRCA.cer'
+      file = Tempfile.new('AppleWWDRCA')
+      filename = file.path
+      keychain = wwdr_keychain
+      keychain = "-k #{keychain.shellescape}" unless keychain.empty?
+
+      require 'open3'
+
+      import_command = "curl -f -o #{filename} #{url} && security import #{filename} #{keychain}"
+      UI.verbose("Installing WWDR Cert: #{import_command}")
+
+      stdout, stderr, _status = Open3.capture3(import_command)
+      if FastlaneCore::Globals.verbose?
+        UI.command_output(stdout)
+        UI.command_output(stderr)
+      end
+
+      unless $?.success?
+        UI.verbose("Failed to install WWDR Certificate, checking output to see why")
+        # Check the command output, WWDR might already exist
+        unless /The specified item already exists in the keychain./ =~ stderr
+          UI.user_error!("Could not install WWDR certificate")
+        end
+        UI.verbose("WWDR Certificate was already installed")
+      end
+      return true
+    end
+
+    def self.wwdr_keychain
+      priority = [
+        "security list-keychains -d user",
+        "security default-keychain -d user"
+      ]
+      priority.each do |command|
+        keychains = Helper.backticks(command, print: FastlaneCore::Globals.verbose?).split("\n")
+        unless keychains.empty?
+          # Select first keychain name from returned keychains list
+          return keychains[0].strip.tr('"', '')
+        end
+      end
+      return ""
+    end
+
+    def self.sha1_fingerprint(path)
+      file_data = File.read(path.to_s)
+      cert = OpenSSL::X509::Certificate.new(file_data)
+      return OpenSSL::Digest::SHA1.new(cert.to_der).to_s.upcase
+    rescue => error
+      UI.error(error)
+      UI.user_error!("Error parsing certificate '#{path}'")
+    end
+  end
+end

data/fastlane_core/lib/fastlane_core/command_executor.rb

@@ -0,0 +1,99 @@
+require_relative 'ui/ui'
+require_relative 'globals'
+require_relative 'fastlane_pty'
+
+module FastlaneCore
+  # Executes commands and takes care of error handling and more
+  class CommandExecutor
+    class << self
+      # Cross-platform way of finding an executable in the $PATH. Respects the $PATHEXT, which lists
+      # valid file extensions for executables on Windows.
+      #
+      #    which('ruby') #=> /usr/bin/ruby
+      #
+      # Derived from https://stackoverflow.com/a/5471032/3005
+      def which(cmd)
+        # PATHEXT contains the list of file extensions that Windows considers executable, semicolon separated.
+        # e.g. ".COM;.EXE;.BAT;.CMD"
+        exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : []
+        exts << '' # Always have an empty string (= no file extension)
+
+        ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+          exts.each do |ext|
+            cmd_path = File.join(path, "#{cmd}#{ext}")
+            return cmd_path if Helper.executable?(cmd_path)
+          end
+        end
+
+        return nil
+      end
+
+      # @param command [String] The command to be executed
+      # @param print_all [Boolean] Do we want to print out the command output while running?
+      # @param print_command [Boolean] Should we print the command that's being executed
+      # @param error [Block] A block that's called if an error occurs
+      # @param prefix [Array] An array containing a prefix + block which might get applied to the output
+      # @param loading [String] A loading string that is shown before the first output
+      # @param suppress_output [Boolean] Should we print the command's output?
+      # @return [String] All the output as string
+      def execute(command: nil, print_all: false, print_command: true, error: nil, prefix: nil, loading: nil, suppress_output: false)
+        print_all = true if FastlaneCore::Globals.verbose?
+        prefix ||= {}
+
+        output = []
+        command = command.join(" ") if command.kind_of?(Array)
+        UI.command(command) if print_command
+
+        if print_all && loading # this is only used to show the "Loading text"...
+          UI.command_output(loading)
+        end
+
+        begin
+          status = FastlaneCore::FastlanePty.spawn(command) do |command_stdout, command_stdin, pid|
+            command_stdout.each do |l|
+              line = l.strip # strip so that \n gets removed
+              output << line
+
+              next unless print_all
+
+              # Prefix the current line with a string
+              prefix.each do |element|
+                line = element[:prefix] + line if element[:block] && element[:block].call(line)
+              end
+
+              UI.command_output(line) unless suppress_output
+            end
+          end
+        rescue => ex
+          # FastlanePty adds exit_status on to StandardError so every error will have a status code
+          status = ex.exit_status
+
+          # This could happen when the environment is wrong:
+          # > invalid byte sequence in US-ASCII (ArgumentError)
+          output << ex.to_s
+          o = output.join("\n")
+          puts(o)
+          if error
+            error.call(o, nil)
+          else
+            raise ex
+          end
+        end
+
+        # Exit status for build command, should be 0 if build succeeded
+        if status != 0
+          o = output.join("\n")
+          puts(o) unless suppress_output # the user has the right to see the raw output
+          UI.error("Exit status: #{status}")
+          if error
+            error.call(o, status)
+          else
+            UI.user_error!("Exit status: #{status}")
+          end
+        end
+
+        return output.join("\n")
+      end
+    end
+  end
+end

data/fastlane_core/lib/fastlane_core/configuration/commander_generator.rb

@@ -0,0 +1,103 @@
+require 'commander'
+
+require_relative '../module'
+require_relative '../ui/ui'
+
+module FastlaneCore
+  class CommanderGenerator
+    include Commander::Methods
+
+    # Calls the appropriate methods for commander to show the available parameters
+    def generate(options, command: nil)
+      # First, enable `always_trace`, to show the stack trace
+      always_trace!
+
+      used_switches = []
+      options.each do |option|
+        next if option.description.to_s.empty? # "private" options
+        next unless option.display_in_shell
+
+        short_switch = option.short_option
+        key = option.key
+        validate_short_switch(used_switches, short_switch, key)
+
+        type = option.data_type
+
+        # We added type: Hash to code generation, but Ruby's OptionParser doesn't like that
+        # so we need to switch that to something that is supported, luckily, we have an `is_string`
+        # property and if that is false, we'll default to nil
+        if type == Hash
+          type = option.is_string ? String : nil
+        end
+
+        # Boolean is a fastlane thing, it's either TrueClass, or FalseClass, but we won't know
+        # that until runtime, so nil is the best we get
+        if type == Fastlane::Boolean
+          type = nil
+        end
+
+        # This is an important bit of trickery to solve the boolean option situation.
+        #
+        # Typically, boolean command line flags do not accept trailing values. If the flag
+        # is present, the value is true, if it is missing, the value is false. fastlane
+        # supports this style of flag. For example, you can specify a flag like `--clean`,
+        # and the :clean option will be true.
+        #
+        # However, fastlane also supports another boolean flag style that accepts trailing
+        # values much like options for Strings and other value types. That looks like
+        # `--include_bitcode false` The problem is that this does not work out of the box
+        # for Commander and OptionsParser. So, we need to get tricky.
+        #
+        # The value_appendix below acts as a placeholder in the switch definition that
+        # states that we expect to have a trailing value for our options. When an option
+        # declares a data type, we use the name of that data type in all caps like:
+        # "--devices ARRAY". When the data type is nil, this implies that we're going
+        # to be doing some special handling on that value. One special thing we do
+        # automatically in Configuration is to coerce special Strings into boolean values.
+        #
+        # If the data type is nil, the trick we do is to specify a value placeholder, but
+        # we wrap it in [] brackets to mark it as optional. That means that the trailing
+        # value may or may not be present for this flag. If the flag is present, but the
+        # value is not, we get a value of `true`. Perfect for the boolean flag base-case!
+        # If the value is there, we'll actually get it back as a String, which we can
+        # later coerce into a boolean.
+        #
+        # In this way we support handling boolean flags with or without trailing values.
+        value_appendix = (type || '[VALUE]').to_s.upcase
+        long_switch = "--#{option.key} #{value_appendix}"
+
+        description = option.description
+        description += " (#{option.env_name})" unless option.env_name.to_s.empty?
+
+        # We compact this array here to remove the short_switch variable if it is nil.
+        # Passing a nil value to global_option has been shown to create problems with
+        # option parsing!
+        #
+        # See: https://github.com/fastlane/fastlane_core/pull/89
+        #
+        # If we don't have a data type for this option, we tell it to act like a String.
+        # This allows us to get a reasonable value for boolean options that can be
+        # automatically coerced or otherwise handled by the ConfigItem for others.
+        args = [short_switch, long_switch, (type || String), description].compact
+
+        if command
+          command.option(*args)
+        else
+          # This is the call to Commander to set up the option we've been building.
+          global_option(*args)
+        end
+      end
+    end
+
+    def validate_short_switch(used_switches, short_switch, key)
+      return if short_switch.nil?
+
+      UI.user_error!("Short option #{short_switch} already taken for key #{key}") if used_switches.include?(short_switch)
+      UI.user_error!("-v is already used for the version (key #{key})") if short_switch == "-v"
+      UI.user_error!("-h is already used for the help screen (key #{key})") if short_switch == "-h"
+      UI.user_error!("-t is already used for the trace screen (key #{key})") if short_switch == "-t"
+
+      used_switches << short_switch
+    end
+  end
+end