standard_automation_library 0.2.1.pre.temp

data/lib/standard_automation_library/util/git.rb

@@ -0,0 +1,235 @@
+require_relative 'shell_helper'
+
+# A collection of git commands
+# Keep the method list alphabetized
+module Git
+  @repo_root_path = nil
+
+  def self.ancestor?(ancestor_git_ref, child_git_ref)
+    git("merge-base --is-ancestor #{ancestor_git_ref} #{child_git_ref}")
+    true # exit status is 0 if ancestor_git_ref is an ancestor of child_git_ref
+  rescue StandardError
+    false
+  end
+
+  def self.branch_exists?(branch_name)
+    rev_parse("--quiet --verify #{branch_name}")
+    true # exit status of zero means branch exists
+  rescue StandardError
+    false
+  end
+
+  def self.checkout(arg_string)
+    git("checkout #{arg_string}")
+  end
+
+  def self.checkout_new_branch(branch_name)
+    checkout("-b #{branch_name}")
+  end
+
+  def self.clean(arg_string = '')
+    git("clean #{arg_string}")
+  end
+
+  def self.clean_without_vendor_bundle(arg_string = '')
+    clean("-ffdx -e vendor -e .bundle #{arg_string}")
+  end
+
+  # TODO: Calling this method `config` results in a name conflict with the Git module in ruby-git.
+  def self.config_command(arg_string)
+    git("config #{arg_string}")
+  end
+
+  def self.commit(arg_string)
+    git("commit #{arg_string}")
+  end
+
+  def self.commit_author_email(git_ref = 'HEAD')
+    log("-1 --format=\"%ae\" #{git_ref}")
+  end
+
+  def self.commit_author_name(git_ref = 'HEAD')
+    log("-1 --format=\"%an\" #{git_ref}")
+  end
+
+  def self.commit_message(git_ref = 'HEAD')
+    log("-1 --format=\"%B\" #{git_ref}")
+  end
+
+  def self.commit_title(git_ref = 'HEAD')
+    log("-1 --format=\"%s\" #{git_ref}")
+  end
+
+  def self.commit_sha?(git_ref)
+    !git_ref.match(/^[a-f0-9]{9,40}$/).nil?
+  end
+
+  def self.commits_between(exclude_commit, include_commit)
+    rev_list("#{include_commit} ^#{exclude_commit}").split("\n").map(&:strip)
+  end
+
+  # Create a slack message payload containing all git related information
+  def self.create_message_payload(git_ref, remote_name = 'origin')
+    commit_or_branch_label = commit_sha?(git_ref) ? 'Commit' : 'Branch'
+    message_payload = { commit_or_branch_label => git_ref }
+    commit_hash = first_non_jenkins_commit(git_ref, remote_name)
+    message_payload['Git Author'] = commit_author_name(commit_hash)
+    message_payload['Commit Message'] = commit_message(commit_hash)
+    message_payload
+  end
+
+  def self.current_branch_name
+    rev_parse('--abbrev-ref HEAD')
+  end
+
+  # Returns the name of the current branch if there is one,
+  # otherwise return the current commit sha.
+  def self.current_branch_or_commit
+    git('symbolic-ref --short -q HEAD')
+  rescue StandardError
+    rev_parse('HEAD')
+  end
+
+  def self.current_commit_sha
+    log('-1 --format="%H"')
+  end
+
+  def self.current_commit_sha_short
+    log('-1 --format="%h"')
+  end
+
+  def self.delete_branch(branch_name)
+    git("branch -D #{branch_name}")
+  end
+
+  def self.diff?(arg_string = '')
+    git("diff --quiet #{arg_string}")
+    false # exit status 0 means that git diff --quiet reports no diff
+  rescue StandardError
+    true
+  end
+
+  def self.fetch(arg_string = '')
+    git("fetch #{arg_string}")
+  end
+
+  # Get the contents of a file from an arbitrary git ref.
+  # file_path must be specified from the top of the repository
+  # If no git ref is specified then just read the contents of
+  # the file on disk
+  def self.file_content(file_path, git_ref = nil)
+    if git_ref.nil?
+      File.read(File.join(repo_root_path, file_path))
+    else
+      git("show #{git_ref}:#{file_path}")
+    end
+  end
+
+  # When jenkins does a PR build it merges the target branch INTO the source branch so
+  # using git_ref~# will eventually get us the commit of the source branch of the PR.
+  def self.first_non_jenkins_commit(git_ref, remote_name = 'origin')
+    begin
+      commit_hash = rev_parse(git_ref)
+    rescue StandardError => e
+      puts e.message
+      commit_hash = rev_parse("#{remote_name}/#{git_ref}")
+    end
+
+    parent_count = 0
+    loop do
+      git_author = commit_author_name("#{commit_hash}~#{parent_count}")
+      break if git_author != 'Jenkins'
+
+      parent_count += 1
+    end
+    rev_parse("#{commit_hash}~#{parent_count}")
+  end
+
+  def self.git(arg_string)
+    ShellHelper.run("git #{arg_string}")
+  end
+
+  def self.local_branch_is_behind_remote?(local_branch_name, remote_name = 'origin')
+    rev_parse(local_branch_name) != rev_parse("#{remote_name}/#{local_branch_name}")
+  end
+
+  def self.log(arg_string)
+    git("log #{arg_string}")
+  end
+
+  def self.merge(arg_string)
+    git("merge #{arg_string}")
+  end
+
+  def self.merge_abort(fail_silently: true)
+    merge('--abort')
+  rescue StandardError => e
+    raise e unless fail_silently
+  end
+
+  def self.merge_driver_installed?(key)
+    config_command("--get-regexp \"^merge.#{key}\"")
+    true # exit status 0 means merge driver is installed
+  rescue StandardError
+    false
+  end
+
+  # We prefer our own implementation rather than the fastlane one so that we can dry run.
+  def self.push_to_remote(local_branch, is_dry_run, remote_branch: nil, force: false, tags: false, remote: 'origin')
+    remote_branch ||= local_branch
+
+    command = [
+      'push',
+      remote,
+      "#{local_branch.shellescape}:#{remote_branch.shellescape}"
+    ]
+
+    # optionally add the tags component
+    command << '--tags' if tags
+
+    # optionally add the force component
+    command << '--force' if force
+
+    if is_dry_run
+      puts "Would have pushed branch: #{local_branch} to remote branch: #{remote}/#{remote_branch} " \
+           "with force: #{force} and tags: #{tags}"
+    else
+      git(command.join(' '))
+    end
+  end
+
+  def self.return_to_current_ref(git_clean_args = '', &_blk)
+    current_ref = current_branch_or_commit
+    begin
+      yield
+    ensure
+      clean_without_vendor_bundle(git_clean_args)
+      checkout("#{current_ref} -f")
+    end
+  end
+
+  def self.reset(arg_string)
+    git("reset #{arg_string}")
+  end
+
+  def self.reset_hard(arg_string = '')
+    reset("--hard #{arg_string}")
+  end
+
+  def self.reset_hard_if_refs_not_equal(current_ref, reset_ref)
+    reset_hard(reset_ref) if rev_parse(current_ref) != rev_parse(reset_ref)
+  end
+
+  def self.repo_root_path
+    @repo_root_path = rev_parse('--show-toplevel') if @repo_root_path.nil?
+    @repo_root_path
+  end
+
+  def self.rev_list(arg_string)
+    git("rev-list #{arg_string}")
+  end
+
+  def self.rev_parse(arg_string)
+    git("rev-parse #{arg_string}")
+  end
+end

data/lib/standard_automation_library/util/git_merge_error_message_cleaner.rb

@@ -0,0 +1,27 @@
+# Class for cleaning up git merge error messages and turning them into
+# a message suitable for sending via slack. If different message processing
+# is desired then subclass this and override the clean_message method.
+class GitMergeErrorMessageCleaner
+  MERGE_CONFLICT_PREFIX = 'CONFLICT (content): Merge conflict in'.freeze
+
+  def clean_message(error_message)
+    merge_conflicts = []
+    other_messages = []
+    error_message.split("\n").each do |line|
+      merge_conflicts << line.gsub(MERGE_CONFLICT_PREFIX, '').strip if line.include?(MERGE_CONFLICT_PREFIX)
+    end
+
+    return error_message if merge_conflicts.empty? && other_messages.empty?
+
+    new_message = ''
+    unless merge_conflicts.empty?
+      new_message = "*Merge Conflicts*\n#{merge_conflicts.sort.map { |conflict_path| "• #{conflict_path}\n" }.join}"
+    end
+
+    unless other_messages.empty?
+      new_message += "\n*Other Messages*\n#{other_messages.map { |other_message| "• #{other_message}\n" }.join}"
+    end
+
+    new_message.strip
+  end
+end

data/lib/standard_automation_library/util/network.rb

@@ -0,0 +1,39 @@
+require 'net/http'
+require 'json'
+require 'open-uri'
+
+# Functions for performing network requests
+module Network
+  def self.get(url, headers)
+    uri = URI(url)
+    http = Net::HTTP.new(uri.host, uri.port)
+    http.use_ssl = true
+    request = Net::HTTP::Get.new(uri.path, headers)
+    http.request(request)
+  end
+
+  def self.post(url, headers, request_body)
+    uri = URI(url)
+    http = Net::HTTP.new(uri.host, uri.port)
+    http.use_ssl = true
+    request = Net::HTTP::Post.new(
+      uri.path,
+      headers
+    )
+
+    request_body = request_body.to_json if request_body.is_a?(Hash)
+
+    request.body = request_body
+    http.request(request)
+  end
+
+  def self.json_response(url, headers = {})
+    uri = URI.parse(url)
+    JSON.parse(uri.open(headers).read)
+  end
+
+  def self.download_file(url, output_path, headers = {})
+    uri = URI.parse(url)
+    File.write(output_path, uri.open(headers).read)
+  end
+end

data/lib/standard_automation_library/util/path_container.rb

@@ -0,0 +1,17 @@
+# An object to contain a collections of file paths.
+# This could be useful to specify paths to a file
+# that is known to switch places based on checking
+# out different git branches. Calling the path function
+# will return the first path that exists on the file system.
+class PathContainer
+  def initialize(paths)
+    @paths = paths
+  end
+
+  def path
+    @paths.each do |path|
+      return path if File.exist?(path)
+    end
+    nil
+  end
+end

data/lib/standard_automation_library/util/platform_picker.rb

@@ -0,0 +1,150 @@
+require_relative '../api_clients/github'
+require_relative 'shared_constants'
+
+# Functionality for filtering a list of path prefixes based on which
+# paths have been modified between two git commits. Allows us to choose
+# which platforms to build
+module PlatformPicker
+  COMMON_BUILD_FILES = %w[
+    AndroidCommon.gradle
+    build.gradle.kts
+    Gemfile
+    Gemfile.lock
+    gradle.properties
+    gradlew
+    gradlew.bat
+    Jenkinsfile.forge
+    settings.gradle.kts
+  ].freeze
+
+  COMMON_BUILD_DIRECTORIES = %w[
+    buildTools/
+    common/
+    deps/
+    gradle/
+  ].freeze
+
+  # Determines the list of platforms that require building.
+  #
+  class PlatformDetector
+    # @param [String] recent_commit - A required commit hash for comparing the base branch against to.
+    # @param [String] older_commit - An optional commit hash of an older commit.
+    # @param [String] pr_number - An optional PR# for label checking.
+    # @param [String] repo_name - A required git repo name path.
+    # @param [Array] platform - A required platforms array.
+    # @param [TrueClass] dry_run - A boolean indicating if a dry_run should be performed.
+    # @param [TrueClass] verbose - A boolean indicating if verbose logging should be enabled. Helps to determine if
+    # certain labels were matched.
+    def initialize(recent_commit:, older_commit:, pr_number:, repo_name:, platforms:, dry_run:, verbose:)
+      @recent_commit = recent_commit
+      @older_commit = older_commit
+      @pr_number = pr_number
+      @platforms = platforms
+      @verbose = verbose || false
+      @github_client = GitHub.new(
+        repo_name,
+        ENV.fetch('IOS_GITHUB_API_TOKEN', nil),
+        api_server_base_url: SharedConstants::GITHUB_API_BASE_URL,
+        is_dry_run: dry_run || false
+      )
+    end
+
+    def detect
+      log 'Determining platforms to build...'
+      if @pr_number
+        labels_to_skip = [SharedConstants::VERSION_BUMP_LABEL, SharedConstants::AUTOGENERATED_LABEL]
+        log "Fetching git labels for for PR ##{@pr_number}..."
+        has_valid_labels = @github_client.pull_request_has_labels?(pr_number: @pr_number, labels: labels_to_skip)
+        if has_valid_labels
+          log "Detected #{labels_to_skip.join(', ')} labels.
+\Skipping git revision checking as only version file(s) were changed."
+          log 'Platforms requiring build: []'
+          return []
+        else
+          log 'No labels matched'
+        end
+      end
+
+      platforms = self.class.platforms_to_build(@older_commit, @recent_commit, @platforms)
+      log "Platforms requiring build: #{platforms}"
+      platforms
+    end
+
+    def log(string)
+      puts string if @verbose
+    end
+
+    def self.check_gradle_build_files(earlier_commit, later_commit, platforms)
+      file_paths = `git diff --name-only #{earlier_commit} #{later_commit}`.strip.split("\n")
+      does_modify_common_build_files = false
+      common_platforms_to_build = []
+      file_paths.each do |file_path|
+        if COMMON_BUILD_FILES.include? file_path
+          does_modify_common_build_files = true
+          break
+        end
+
+        next unless COMMON_BUILD_DIRECTORIES.any? { |dir| file_path.start_with?(dir) }
+
+        common_platforms_to_build = if deps_contains_one_analytics_lib_change(earlier_commit, later_commit)
+                                      %w[android]
+                                    else
+                                      platforms
+                                    end
+        break
+      end
+      does_modify_common_build_files ? platforms : common_platforms_to_build
+    end
+
+    def self.platforms_to_build(earlier_commit, later_commit, platforms)
+      platform_path_prefixes = platforms.map { |platform| "#{platform}/" }
+      prefixes_to_build = filter_path_prefixes(platform_path_prefixes, earlier_commit, later_commit)
+      platforms_to_build_by_prefix = prefixes_to_build.map { |prefix| prefix.delete_suffix('/') }
+      platforms_to_build_by_gradle_build_files = check_gradle_build_files(earlier_commit, later_commit, platforms)
+      (platforms_to_build_by_prefix + platforms_to_build_by_gradle_build_files).uniq
+    end
+
+    def self.filter_path_prefixes(path_prefixes, earlier_commit, later_commit)
+      file_paths = `git diff --name-only #{earlier_commit} #{later_commit}`.strip.split("\n")
+      path_prefixes.select do |prefix|
+        should_select = false
+        file_paths.each do |file_path|
+          if file_path.start_with?(prefix)
+            should_select = true
+            break
+          end
+        end
+        should_select
+      end
+    end
+
+    # Ensure that the only change is in the file V.kt and specifically related to analytics, the following conditions
+    # must be met:
+
+    # First Condition: Verify that the total count of modified files within the /deps directory is exactly one.
+    # Second Condition: Ensure that V.kt is the only file that has been altered in the /deps directory.
+    # Third Condition: Confirm that there is precisely one modification in the V.kt file, and this modification
+    # includes the term analyticsLib.
+
+    # This method will help to avoid running the build for all platforms when only the analytics lib is changed.
+    def self.deps_contains_one_analytics_lib_change(earlier_commit, later_commit)
+      files_in_deps = `git diff --name-only #{earlier_commit} #{later_commit} | \
+                    grep '^deps/'`.strip.split("\n")
+      if files_in_deps.length == 1
+        v_is_changed = files_in_deps[0].include?('/V.kt')
+        if v_is_changed
+          changes_in_v_file = `
+          git diff --unified=0 #{earlier_commit} #{later_commit} deps/src/main/kotlin/com/plangrid/deps/V.kt  | \
+          grep '^[+]' | \
+          grep -Ev '^(--- a/|\\+\\+\\+ b/)'`.strip.split("\n")
+          if changes_in_v_file.length == 1
+            changes_in_v_file[0].include?('analyticsLib')
+          else
+            false end
+        else
+          false end
+      else
+        false end
+    end
+  end
+end

data/lib/standard_automation_library/util/shared_constants.rb

@@ -0,0 +1,27 @@
+module SharedConstants
+  AUTOMERGE_BRANCH_PREFIX = 'automerge/'.freeze
+  AUTOMERGE_LABEL = 'Automerge'.freeze
+  AUTOGENERATED_LABEL = 'Autogenerated'.freeze
+  VERSION_BUMP_LABEL = 'Version bump'.freeze
+
+  DEV = 'dev'.freeze
+  RC = 'rc'.freeze
+  HOTFIX = 'hotfix'.freeze
+
+  GITHUB_API_BASE_URL = 'https://api.github.com'.freeze
+
+  SLACK_USERNAME_MAPPING_FILE_PATH = 'common/fastlane/slack_username_mapping.yml'.freeze
+
+  INITIATION_TYPE_AUTOMATIC = 'automatic'.freeze
+  INITIATION_TYPE_MANUAL = 'manual'.freeze
+  INITIATION_TYPES = [INITIATION_TYPE_AUTOMATIC, INITIATION_TYPE_MANUAL].freeze
+
+  MERGE_METHOD_SQUASH = 'squash'.freeze
+  MERGE_METHOD_MERGE = 'merge'.freeze
+  MERGE_METHOD_REBASE = 'rebase'.freeze
+  VALID_MERGE_METHODS = [MERGE_METHOD_MERGE, MERGE_METHOD_SQUASH, MERGE_METHOD_REBASE].freeze
+
+  FAILURE_REPORTING_INSTRUCTIONS = 'Be a good citizen! Investigate and report this build failure using ' \
+                                   '<https://wiki.autodesk.com/display/ACSMOB/Reporting+Build+Flakes|' \
+                                   'these reporting instructions>.'.freeze
+end

data/lib/standard_automation_library/util/shell_helper.rb

@@ -0,0 +1,54 @@
+require 'open3'
+
+# TODO: consider refactor now that Sorbet has been removed from the codebase
+# The shell module handles running shell commands in both a Fastlane and non Fastlane context
+# The sh method only works when run in a Fastlane context but some of the library methods
+# need to be run outside of a Fastlane context and we want to use the same interface
+# for everything. This implementation removes the ability to use an error callback but
+# that could be added in the future if necessary.
+module ShellHelper
+  # Attempt to run the command with Fastlane's sh action. If we're not in a Fastlane context
+  # a NameError will be thrown in which case we'll use our own implementation.
+  # This implementation is a slightly simplified version of fastlane's sh command
+  # https://github.com/fastlane/fastlane/blob/master/fastlane/lib/fastlane/helper/sh_helper.rb
+  # Because we're not using Fastlane::Action.sh (Action without an S) sorbet will complain
+  # if this file is in strict mode without the use of T.unsafe
+  def self.run(command, log: true)
+    Fastlane::Actions.sh(command.strip, log: log).strip
+  rescue NameError => e
+    raise e unless e.message.include?('uninitialized constant') && e.message.include?('Fastlane')
+
+    previous_encoding = [Encoding.default_external, Encoding.default_internal]
+    Encoding.default_external = Encoding::UTF_8
+    Encoding.default_internal = Encoding::UTF_8
+
+    begin
+      puts "$ #{command.strip}" if log
+      result = ''
+      exit_status = 0
+      Open3.popen2e(command.strip) do |_stdin, io, thread|
+        io.sync = true
+        io.each do |line|
+          puts "▸ #{line.strip}" if log
+          result << line
+        end
+        process_status = thread.value
+        exit_status = process_status.exitstatus # Should not be nil because io.sync = true
+      end
+
+      if exit_status != 0
+        message = if log
+                    "Exit status of command '#{command.strip}' was #{exit_status} instead of 0."
+                  else
+                    "Shell command exited with exit status #{exit_status} instead of 0."
+                  end
+        message += "\n#{result}" if log
+        raise message
+      end
+      result.strip
+    ensure
+      Encoding.default_external = previous_encoding.first
+      Encoding.default_internal = previous_encoding.last
+    end
+  end
+end

data/lib/standard_automation_library/util/slack_constants.rb

@@ -0,0 +1,40 @@
+module SlackConstants
+  IOS_SLACK_EMOJI = ':apple-co:'.freeze
+  ANDROID_SLACK_EMOJI = ':android-7248:'.freeze
+  WINDOWS_SLACK_EMOJI = ':windows:'.freeze
+
+  HEADSUP = 'Headsup'.freeze
+  RELEASE = 'Release'.freeze
+
+  IOS = 'iOS'.freeze
+  ANDROID = 'Android'.freeze
+  WINDOWS = 'Windows'.freeze
+
+  ATTACHMENT_COLOR_GOOD = 'good'.freeze
+  ATTACHMENT_COLOR_YELLOW = '#ffe7c6'.freeze
+  ATTACHMENT_COLOR_GREEN = '#08a115'.freeze
+  ATTACHMENT_COLOR_RED = '#de0910'.freeze
+  ATTACHMENT_COLOR_DANGER = 'danger'.freeze
+
+  VALID_EMAIL_SUFFIXES = %w[autodesk.com].freeze
+
+  WARNING = 'warning'.freeze
+
+  # channels-ids
+  ACS_MOBILE_COMMON_CI = 'C01EZ7Q7ZV1'.freeze
+  ACS_MOBILE_RELEASE_ANNOUNCEMENT = 'CSM2T5RQQ'.freeze
+  ACS_MOBILE_CODE_HEALTH = 'C04LVDLDE8M'.freeze
+
+  ACS_IOS = 'CU8CK7MN2'.freeze
+  ACS_IOS_CI = 'CSLJSAZQC'.freeze
+  ACS_IOS_CODE = 'CU820SFMM'.freeze
+  ACS_IOS_TEST_FLAKE = 'C021WSYAMM3'.freeze
+  ACS_IOS_RELEASE_COMMUNICATION = 'C01RJBTG76U'.freeze
+  ACS_IOS_AUTOMATION_TESTING_AB = 'C026XEUCZD0'.freeze
+
+  ACS_ANDROID = 'CU66Z5X6H'.freeze
+  ACS_ANDROID_CI = 'C016HBNFD6G'.freeze
+  ACS_ANDROID_CODE = 'CU58QK1C0'.freeze
+  ACS_ANDROID_RELEASE_COMMUNICATION = 'C012JKW6EUR'.freeze
+  ACS_AN_AUTOMATION_TESTING_AB = 'C033N3891T2'.freeze
+end

data/lib/standard_automation_library/util/version.rb

@@ -0,0 +1,31 @@
+require_relative 'file_content'
+
+# Generic functions for dealing with versions.
+module Version
+  def self.app_version(version_file_path, regex, git_ref = nil)
+    match_list = FileContent.find_content_in_file(version_file_path, regex, git_ref)
+    raise "Cannot find version in #{version_file_path} at ref #{git_ref} with regex #{regex}" if match_list.empty?
+
+    match_list[0]
+  end
+
+  def self.update_app_version(version_file_path, regex, replacement_string)
+    FileContent.find_and_replace_content_in_file(version_file_path, regex, replacement_string)
+  end
+
+  def self.increment_minor_version(version, increment_value)
+    match = version.match(/^\d+\.\d+\.\d+$/)
+    raise "Version #{version} is not in the correct format." unless match
+
+    version_pieces = version.split('.').map(&:to_i)
+    [version_pieces[0], version_pieces[1] + increment_value, 0].map(&:to_s).join('.')
+  end
+
+  def self.increment_patch_version(version, increment_value)
+    match = version.match(/^\d+\.\d+\.\d+$/)
+    raise "Version #{version} is not in the correct format." unless match
+
+    version_pieces = version.split('.').map(&:to_i)
+    [version_pieces[0], version_pieces[1], version_pieces[2] + increment_value].map(&:to_s).join('.')
+  end
+end

data/lib/standard_automation_library/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module StandardAutomationLibrary
+  VERSION = '0.2.1-temp'
+end

data/lib/standard_automation_library.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+Dir["#{__dir__}/standard_automation_library/**/*.rb"].sort.each(&method(:require))
+
+module StandardAutomationLibrary
+  class Error < StandardError; end
+  # Your code goes here...
+end