fastlane_hotfix 2.165.0

data/fastlane/lib/fastlane/fastlane_require.rb

@@ -0,0 +1,75 @@
+module Fastlane
+  class FastlaneRequire
+    class << self
+      def install_gem_if_needed(gem_name: nil, require_gem: true)
+        gem_require_name = format_gem_require_name(gem_name)
+
+        # check if it's installed
+        if gem_installed?(gem_name)
+          UI.success("gem '#{gem_name}' is already installed") if FastlaneCore::Globals.verbose?
+          require gem_require_name if require_gem
+          return true
+        end
+
+        if Helper.bundler?
+          # User uses bundler, we don't want to install gems on the fly here
+          # Instead tell the user how to add it to their Gemfile
+          UI.important("Missing gem '#{gem_name}', please add the following to your local Gemfile:")
+          UI.important("")
+          UI.command_output("gem \"#{gem_name}\"")
+          UI.important("")
+          UI.user_error!("Add 'gem \"#{gem_name}\"' to your Gemfile and restart fastlane") unless Helper.test?
+        end
+
+        require "rubygems/command_manager"
+        installer = Gem::CommandManager.instance[:install]
+
+        UI.important("Installing Ruby gem '#{gem_name}'...")
+
+        spec_name = self.find_gem_name(gem_name)
+        UI.important("Found gem \"#{spec_name}\" instead of the required name \"#{gem_name}\"") if spec_name != gem_name
+
+        return if Helper.test?
+
+        # We install the gem like this because we also want to gem to be available to be required
+        # at this point. If we were to shell out, this wouldn't be the case
+        installer.install_gem(spec_name, Gem::Requirement.default)
+        UI.success("Successfully installed '#{gem_name}'")
+        require gem_require_name if require_gem
+      end
+
+      def gem_installed?(name, req = Gem::Requirement.default)
+        installed = Gem::Specification.any? { |s| s.name == name and req =~ s.version }
+        return true if installed
+
+        # In special cases a gem is already preinstalled, e.g. YAML.
+        # To find out we try to load a gem with that name in a child process
+        # (so we don't actually load anything we don't want to load)
+        # See https://github.com/fastlane/fastlane/issues/6951
+        require_tester = <<-RB.gsub(/^ */, '')
+          begin
+            require ARGV.first
+          rescue LoadError
+            exit(1)
+          end
+        RB
+        system(RbConfig.ruby, "-e", require_tester.lines.map(&:chomp).join("; "), name)
+        return $?.success?
+      end
+
+      def find_gem_name(user_supplied_name)
+        fetcher = Gem::SpecFetcher.fetcher
+        gems = fetcher.suggest_gems_from_name(user_supplied_name)
+
+        return gems.first
+      end
+
+      def format_gem_require_name(gem_name)
+        # from "fastlane-plugin-xcversion" to "fastlane/plugin/xcversion"
+        gem_name = gem_name.tr("-", "/") if gem_name.start_with?("fastlane-plugin-")
+
+        return gem_name
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/features.rb

@@ -0,0 +1,4 @@
+# Use this file as the place to register Feature switches for the fastlan_core project
+
+# FastlaneCore::Feature.register(env_var: 'YOUR_FEATURE_SWITCH_ENV_VAR',
+#                            description: 'Describe what this feature switch controls')

data/fastlane/lib/fastlane/helper/README.md

@@ -0,0 +1,29 @@
+### fastlane Helper
+
+You can put shared code into this folder. Use this if you need to access the same code from multiple actions or to just clean up the actual action.
+
+To create a new helper, duplicate the `podspec_helper.rb`, rename the class and put your code inside the class. 
+
+Make sure it's structured like this:
+
+```ruby
+module Fastlane
+  module Helper
+    class PodspecHelper
+      ...
+    end
+  end
+end
+```
+
+The `git_helper` and `sh_helper` are different, please make sure to build something like `podspec_helper`.
+
+### Use of the helper class
+
+To access the helper class use
+
+```ruby
+Helper::PodspecHelper....
+```
+
+Make sure to prefix your helper with the `Helper::` module.

data/fastlane/lib/fastlane/helper/adb_helper.rb

@@ -0,0 +1,66 @@
+module Fastlane
+  module Helper
+    class AdbDevice
+      attr_accessor :serial
+
+      def initialize(serial: nil)
+        self.serial = serial
+      end
+    end
+
+    class AdbHelper
+      # Path to the adb binary
+      attr_accessor :adb_path
+
+      # Path to the adb binary
+      attr_accessor :adb_host
+
+      # All available devices
+      attr_accessor :devices
+
+      def initialize(adb_path: nil, adb_host: nil)
+        android_home = ENV['ANDROID_HOME'] || ENV['ANDROID_SDK_ROOT'] || ENV['ANDROID_SDK']
+        if (adb_path.nil? || adb_path == "adb") && android_home
+          adb_path = File.join(android_home, "platform-tools", "adb")
+        end
+
+        self.adb_path = File.expand_path(adb_path)
+        self.adb_host = adb_host
+      end
+
+      def host_option
+        return self.adb_host ? "-H #{adb_host}" : nil
+      end
+
+      # Run a certain action
+      def trigger(command: nil, serial: nil)
+        android_serial = serial != "" ? "ANDROID_SERIAL=#{serial}" : nil
+        command = [android_serial, adb_path.shellescape, host_option, command].compact.join(" ").strip
+        Action.sh(command)
+      end
+
+      def device_avalaible?(serial)
+        UI.deprecated("Please use `device_available?` instead... This will be removed in a future version of fastlane")
+        device_available?(serial)
+      end
+
+      def device_available?(serial)
+        load_all_devices
+        return devices.map(&:serial).include?(serial)
+      end
+
+      def load_all_devices
+        self.devices = []
+
+        command = [adb_path.shellescape, host_option, "devices -l"].compact.join(" ")
+        output = Actions.sh(command, log: false)
+        output.split("\n").each do |line|
+          if (result = line.match(/^(\S+)(\s+)(device )/))
+            self.devices << AdbDevice.new(serial: result[1])
+          end
+        end
+        self.devices
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/helper/crashlytics_helper.rb

@@ -0,0 +1,157 @@
+require 'shellwords'
+
+module Fastlane
+  module Helper
+    class CrashlyticsHelper
+      class << self
+        def discover_crashlytics_path(params)
+          path = params[:crashlytics_path]
+
+          # Finding submit binary inside of given Crashlytics path (for backwards compatibility)
+          if path
+            if File.basename(path) != "submit"
+              path = Dir[File.join(path, '**', 'submit')].last
+              UI.verbose(":crashlytics_path passed through parameters did not point to a submit binary. Using this submit binary on that path instead: '#{path}'")
+            else
+              UI.verbose("Using :crashlytics_path passed in through parameters: '#{path}'")
+            end
+          end
+
+          # Check for submit binary outside of Crashlytics.framework (for Crashlytics 3.4.1 and over)
+          path ||= Dir["./Pods/Crashlytics/submit"].first
+
+          # Check for submit binary in Crashlytics.framework (for Crashlytics 3.4.1 and under)
+          path ||= Dir["./Pods/iOS/Crashlytics/Crashlytics.framework/submit"].last
+          path ||= Dir["./**/Crashlytics.framework/submit"].last
+
+          downcase_path = path ? path.downcase : nil
+          if downcase_path && downcase_path.include?("pods") && downcase_path.include?("crashlytics.framework")
+            UI.deprecated("Crashlytics has moved the submit binary outside of Crashlytics.framework directory as of 3.4.1. Please change :crashlytics_path to `<PODS_ROOT>/Crashlytics/submit`")
+          end
+
+          return path
+        end
+
+        def generate_ios_command(params)
+          submit_binary = discover_crashlytics_path(params)
+          unless submit_binary
+            UI.user_error!("Couldn't find Crashlytics' submit binary in current directory. Make sure to add the 'Crashlytics' pod to your 'Podfile' and run `pod update`")
+          end
+          if File.basename(submit_binary) != "submit"
+            UI.user_error!("Invalid crashlytics path was detected with '#{submit_binary}'. Path must point to the `submit` binary (example: './Pods/Crashlytics/submit')")
+          end
+          submit_binary = "Crashlytics.framework/submit" if Helper.test?
+
+          command = []
+          command << submit_binary.shellescape
+          command << params[:api_token]
+          command << params[:build_secret]
+          command << "-ipaPath '#{params[:ipa_path]}'"
+          command << "-emails '#{params[:emails]}'" if params[:emails]
+          command << "-notesPath '#{params[:notes_path]}'" if params[:notes_path]
+          command << "-groupAliases '#{params[:groups]}'" if params[:groups]
+          command << "-notifications #{(params[:notifications] ? 'YES' : 'NO')}"
+          command << "-debug #{(params[:debug] ? 'YES' : 'NO')}"
+
+          return command
+        end
+
+        def generate_android_command(params, android_manifest_path)
+          params[:crashlytics_path] = download_android_tools unless params[:crashlytics_path]
+
+          UI.user_error!("The `crashlytics_path` must be a jar file for Android") unless params[:crashlytics_path].end_with?(".jar") || Helper.test?
+
+          if ENV['JAVA_HOME'].nil?
+            command = ["java"]
+          else
+            command = [File.join(ENV['JAVA_HOME'], "/bin/java").shellescape]
+          end
+          command << "-jar #{File.expand_path(params[:crashlytics_path])}"
+          command << "-androidRes ."
+          command << "-apiKey #{params[:api_token]}"
+          command << "-apiSecret #{params[:build_secret]}"
+          command << "-uploadDist #{File.expand_path(params[:apk_path]).shellescape}"
+          command << "-androidManifest #{File.expand_path(android_manifest_path).shellescape}"
+
+          # Optional
+          command << "-betaDistributionEmails #{params[:emails].shellescape}" if params[:emails]
+          command << "-betaDistributionReleaseNotesFilePath #{File.expand_path(params[:notes_path]).shellescape}" if params[:notes_path]
+          command << "-betaDistributionGroupAliases #{params[:groups].shellescape}" if params[:groups]
+          command << "-betaDistributionNotifications #{(params[:notifications] ? 'true' : 'false')}"
+
+          return command
+        end
+
+        def download_android_tools
+          containing = File.join(File.expand_path("~/Library"), "CrashlyticsAndroid")
+          zip_path = File.join(containing, "crashlytics-devtools.zip")
+          jar_path = File.join(containing, "crashlytics-devtools.jar")
+
+          url = "https://ssl-download-crashlytics-com.s3.amazonaws.com/android/ant/crashlytics.zip"
+          require 'net/http'
+
+          FileUtils.mkdir_p(containing)
+
+          begin
+            # Work around ruby defect, where HTTP#get_response and HTTP#post_form don't use ENV proxy settings
+            # https://bugs.ruby-lang.org/issues/12724
+            uri = URI(url)
+            http_conn = Net::HTTP.new(uri.host, uri.port)
+            http_conn.use_ssl = true
+            result = http_conn.request_head(uri.path)
+
+            # ETag is returned with quotes, which net/http does not handle. Clean that up
+            etag = result['ETag'] && result['ETag'].tr('"', '')
+
+            # This is a no-op if the current version on disk matches the file on S3
+            return jar_path if File.exist?(zip_path) && etag == Digest::MD5.file(zip_path).hexdigest
+
+            UI.important("Downloading Crashlytics Support Library - this might take a minute...")
+            result = http_conn.request_get(uri.path)
+            UI.error("#{result.message} (#{result.code})") unless result.kind_of?(Net::HTTPSuccess)
+            File.write(zip_path, result.body)
+
+            # Now unzip the file
+            Action.sh("unzip -o '#{zip_path}' -d '#{containing}'")
+
+            UI.user_error!("Couldn't find 'crashlytics-devtools.jar'") unless File.exist?(jar_path)
+
+            UI.success("Successfully downloaded Crashlytics Support Library to '#{jar_path}'")
+          rescue => ex
+            UI.user_error!("Error fetching remote file: #{ex}")
+          end
+
+          return jar_path
+        end
+
+        def generate_android_manifest_tempfile
+          # We have to generate an empty XML file to make the crashlytics CLI happy :)
+          write_to_tempfile('<?xml version="1.0" encoding="utf-8"?><manifest></manifest>', 'xml')
+        end
+
+        def write_to_tempfile(value, tempfilename)
+          require 'tempfile'
+
+          Tempfile.new(tempfilename).tap do |t|
+            t.write(value)
+            t.close
+          end
+        end
+      end
+    end
+  end
+end
+
+# java \
+# -jar ~/Desktop/crashlytics-devtools.jar \
+# -androidRes . \
+# -uploadDist /Users/fkrause/AndroidStudioProjects/AppName/app/build/outputs/apk/app-release.apk \
+# -androidManifest /Users/fkrause/Downloads/manifest.xml \
+# -apiKey api_key \
+# -apiSecret secret_key \
+
+# -betaDistributionReleaseNotes "Yeah" \
+# -betaDistributionEmails "something11@krausefx.com" \
+# -betaDistributionGroupAliases "testgroup" \
+# -betaDistributionNotifications false
+# -projectPath . \

data/fastlane/lib/fastlane/helper/dotenv_helper.rb

@@ -0,0 +1,50 @@
+module Fastlane
+  module Helper
+    class DotenvHelper
+      # @param env_cl_param [String] an optional list of dotenv environment names separated by commas, without space
+      def self.load_dot_env(env_cl_param)
+        base_path = find_dotenv_directory
+
+        return unless base_path
+
+        load_dot_envs_from(env_cl_param, base_path)
+      end
+
+      # finds the first directory of [fastlane, its parent] containing dotenv files
+      def self.find_dotenv_directory
+        path = FastlaneCore::FastlaneFolder.path
+        search_paths = [path]
+        search_paths << path + "/.." unless path.nil?
+        search_paths.compact!
+        search_paths.find do |dir|
+          Dir.glob(File.join(dir, '*.env*'), File::FNM_DOTMATCH).count > 0
+        end
+      end
+
+      # loads the dotenvs. First the .env and .env.default and
+      # then override with all speficied extra environments
+      def self.load_dot_envs_from(env_cl_param, base_path)
+        require 'dotenv'
+
+        # Making sure the default '.env' and '.env.default' get loaded
+        env_file = File.join(base_path, '.env')
+        env_default_file = File.join(base_path, '.env.default')
+        Dotenv.load(env_file, env_default_file)
+
+        return unless env_cl_param
+
+        Fastlane::Actions.lane_context[Fastlane::Actions::SharedValues::ENVIRONMENT] = env_cl_param
+
+        # multiple envs?
+        envs = env_cl_param.split(",")
+
+        # Loads .env file for the environment(s) passed in through options
+        envs.each do |env|
+          env_file = File.join(base_path, ".env.#{env}")
+          UI.success("Loading from '#{env_file}'")
+          Dotenv.overload(env_file)
+        end
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/helper/gem_helper.rb

@@ -0,0 +1,26 @@
+module Fastlane
+  module Actions
+    # will make sure a gem is installed. If it's not an appropriate error message is shown
+    # this will *not* 'require' the gem
+    def self.verify_gem!(gem_name)
+      begin
+        FastlaneRequire.install_gem_if_needed(gem_name: gem_name, require_gem: false)
+        # We don't import this by default, as it's not always the same
+        # also e.g. cocoapods is just required and not imported
+      rescue Gem::LoadError
+        UI.error("Could not find gem '#{gem_name}'")
+        UI.error("")
+        UI.error("If you installed fastlane using `sudo gem install fastlane` run")
+        UI.command("sudo gem install #{gem_name}")
+        UI.error("to install the missing gem")
+        UI.error("")
+        UI.error("If you use a Gemfile add this to your Gemfile:")
+        UI.important("  gem '#{gem_name}'")
+        UI.error("and run `bundle install`")
+
+        UI.user_error!("You have to install the `#{gem_name}` gem on this machine") unless Helper.test?
+      end
+      true
+    end
+  end
+end

data/fastlane/lib/fastlane/helper/git_helper.rb

@@ -0,0 +1,137 @@
+module Fastlane
+  module Actions
+    GIT_MERGE_COMMIT_FILTERING_OPTIONS = [:include_merges, :exclude_merges, :only_include_merges].freeze
+
+    def self.git_log_between(pretty_format, from, to, merge_commit_filtering, date_format = nil, ancestry_path)
+      command = %w(git log)
+      command << "--pretty=#{pretty_format}"
+      command << "--date=#{date_format}" if date_format
+      command << '--ancestry-path' if ancestry_path
+      command << "#{from}...#{to}"
+      command << git_log_merge_commit_filtering_option(merge_commit_filtering)
+      # "*command" syntax expands "command" array into variable arguments, which
+      # will then be individually shell-escaped by Actions.sh.
+      Actions.sh(*command.compact, log: false).chomp
+    rescue
+      nil
+    end
+
+    def self.git_log_last_commits(pretty_format, commit_count, merge_commit_filtering, date_format = nil, ancestry_path)
+      command = %w(git log)
+      command << "--pretty=#{pretty_format}"
+      command << "--date=#{date_format}" if date_format
+      command << '--ancestry-path' if ancestry_path
+      command << '-n' << commit_count.to_s
+      command << git_log_merge_commit_filtering_option(merge_commit_filtering)
+      Actions.sh(*command.compact, log: false).chomp
+    rescue
+      nil
+    end
+
+    def self.last_git_tag_hash(tag_match_pattern = nil)
+      tag_pattern_param = tag_match_pattern ? "=#{tag_match_pattern}" : ''
+      Actions.sh('git', 'rev-list', "--tags#{tag_pattern_param}", '--max-count=1').chomp
+    rescue
+      nil
+    end
+
+    def self.last_git_tag_name(match_lightweight = true, tag_match_pattern = nil)
+      hash = last_git_tag_hash(tag_match_pattern)
+      # If hash is nil (command fails), "git describe" command below will still
+      # run and provide some output, although it's definitely not going to be
+      # anything reasonably expected. Bail out early.
+      return unless hash
+
+      command = %w(git describe)
+      command << '--tags' if match_lightweight
+      command << hash
+      command << '--match' if tag_match_pattern
+      command << tag_match_pattern if tag_match_pattern
+      Actions.sh(*command.compact, log: false).chomp
+    rescue
+      nil
+    end
+
+    def self.last_git_commit_dict
+      return nil if last_git_commit_formatted_with('%an').nil?
+
+      {
+          author: last_git_commit_formatted_with('%an'),
+          author_email: last_git_commit_formatted_with('%ae'),
+          message: last_git_commit_formatted_with('%B'),
+          commit_hash: last_git_commit_formatted_with('%H'),
+          abbreviated_commit_hash: last_git_commit_formatted_with('%h')
+      }
+    end
+
+    # Gets the last git commit information formatted into a String by the provided
+    # pretty format String. See the git-log documentation for valid format placeholders
+    def self.last_git_commit_formatted_with(pretty_format, date_format = nil)
+      command = %w(git log -1)
+      command << "--pretty=#{pretty_format}"
+      command << "--date=#{date_format}" if date_format
+      Actions.sh(*command.compact, log: false).chomp
+    rescue
+      nil
+    end
+
+    # @deprecated Use <tt>git_author_email</tt> instead
+    # Get the author email of the last git commit
+    # <b>DEPRECATED:</b> Use <tt>git_author_email</tt> instead.
+    def self.git_author
+      UI.deprecated('`git_author` is deprecated. Please use `git_author_email` instead.')
+      git_author_email
+    end
+
+    # Get the author email of the last git commit
+    def self.git_author_email
+      s = last_git_commit_formatted_with('%ae')
+      return s if s.to_s.length > 0
+      return nil
+    end
+
+    # Returns the unwrapped subject and body of the last commit
+    # <b>DEPRECATED:</b> Use <tt>last_git_commit_message</tt> instead.
+    def self.last_git_commit
+      UI.important('`last_git_commit` is deprecated. Please use `last_git_commit_message` instead.')
+      last_git_commit_message
+    end
+
+    # Returns the unwrapped subject and body of the last commit
+    def self.last_git_commit_message
+      s = (last_git_commit_formatted_with('%B') || "").strip
+      return s if s.to_s.length > 0
+      nil
+    end
+
+    # Get the hash of the last commit
+    def self.last_git_commit_hash(short)
+      format_specifier = short ? '%h' : '%H'
+      string = last_git_commit_formatted_with(format_specifier).to_s
+      return string unless string.empty?
+      return nil
+    end
+
+    # Returns the current git branch - can be replaced using the environment variable `GIT_BRANCH`
+    def self.git_branch
+      return ENV['GIT_BRANCH'] if ENV['GIT_BRANCH'].to_s.length > 0 # set by Jenkins
+      s = Actions.sh("git rev-parse --abbrev-ref HEAD", log: false).chomp
+      return s.to_s.strip if s.to_s.length > 0
+      nil
+    rescue
+      nil
+    end
+
+    private_class_method
+    def self.git_log_merge_commit_filtering_option(merge_commit_filtering)
+      case merge_commit_filtering
+      when :exclude_merges
+        "--no-merges"
+      when :only_include_merges
+        "--merges"
+      when :include_merges
+        nil
+      end
+    end
+  end
+end