fastlane-plugin-wpmreleasetoolkit 1.0.0

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

@@ -0,0 +1,224 @@
+require 'git'
+
+module Fastlane
+  module Helper
+    # Helper methods to execute git-related operations
+    #
+    module GitHelper
+      # Checks if the given path, or current directory if no path is given, is
+      # inside a Git repository
+      #
+      # @param [String] path An optional path where to check if a Git repo
+      #        exists.
+      #
+      # @return [Bool] True if the current directory is the root of a git repo
+      #         (i.e. a local working copy) or a subdirectory of one.
+      #
+      def self.is_git_repo?(path: Dir.pwd)
+        # If the path doesn't exist, find its first ancestor.
+        path = first_existing_ancestor_of(path: path)
+        # Get the path's directory, so we can look in it for the Git folder
+        dir = path.directory? ? path : path.dirname
+
+        # Recursively look for the Git folder until it's found or we read the
+        # the file system root
+        dir = dir.parent until Dir.entries(dir).include?('.git') || dir.root?
+
+        # If we reached the root, we haven't found a repo. (Technically, there
+        # could be a repo in the root of the system, but that's a usecase that
+        # we don't need to support at this time)
+        return dir.root? == false
+      end
+
+      # Travels back the hierarchy of the given path until it finds an existing
+      # ancestor, or it reaches the root of the file system.
+      #
+      # @param [String] path The path to inspect
+      #
+      # @return [Pathname] The first existing ancestor, or `path` itself if it
+      #         exists
+      #
+      def self.first_existing_ancestor_of(path:)
+        p = Pathname(path).expand_path
+        p = p.parent until p.exist? || p.root?
+        return p
+      end
+
+      # Check if the current directory has git-lfs enabled
+      #
+      # @return [Bool] True if the current directory is a git working copy and has git-lfs enabled.
+      #
+      def self.has_git_lfs?
+        return false unless is_git_repo?
+
+        `git config --get-regex lfs`.length > 0
+      end
+
+      # Switch to the given branch and pull its latest commits.
+      #
+      # @param [String,Hash] branch Name of the branch to pull.
+      #        If you provide a Hash with a single key=>value pair, it will build the branch name as `"#{key}/#{value}"`,
+      #        i.e. `checkout_and_pull(release: version)` is equivalent to `checkout_and_pull("release/#{version}")`.
+      #
+      # @return [Bool] True if it succeeded switching and pulling, false if there was an error during the switch or pull.
+      #
+      def self.checkout_and_pull(branch)
+        branch = branch.first.join('/') if branch.is_a?(Hash)
+        Action.sh('git', 'checkout', branch)
+        Action.sh('git', 'pull')
+        return true
+      rescue
+        return false
+      end
+
+      # Update every submodule in the current git repository
+      #
+      def self.update_submodules
+        Action.sh('git', 'submodule', 'update', '--init', '--recursive')
+      end
+
+      # Create a new branch named `branch_name`, cutting it from branch/commit/tag `from`, and push it
+      #
+      # If the branch with that name already exists, it will instead switch to it and pull new commits.
+      #
+      # @param [String] branch_name The full name of the new branch to create, e.g "release/1.2"
+      # @param [String?] from The branch or tag from which to cut the branch from.
+      #        If `nil`, will cut the new branch from the current commit. Otherwise, will checkout that commit/branch/tag before cutting the branch.
+      # @param [Bool] push If true, will also push the branch to `origin`, tracking the upstream branch with the local one.
+      #
+      def self.create_branch(branch_name, from: nil, push: true)
+        if branch_exists?(branch_name)
+          UI.message("Branch #{branch_name} already exists. Skipping creation.")
+          Action.sh('git', 'checkout', branch_name)
+          Action.sh('git', 'pull', 'origin', branch_name)
+        else
+          Action.sh('git', 'checkout', from) unless from.nil?
+          Action.sh('git', 'checkout', '-b', branch_name)
+          Action.sh('git', 'push', '-u', 'origin', branch_name) if push
+        end
+      end
+
+      # `git add` the specified files (if any provided) then commit them using the provided message.
+      # Optionally, push the commit to the remote too.
+      #
+      # @param [String] message The commit message to use
+      # @param [String|Array<String>] files A file or array of files to git-add before creating the commit.
+      #        use `nil` or `[]` if you already added the files in a separate step and don't wan't this method to add any new file before commit.
+      #        Also accepts the special symbol `:all` to add all the files (`git commit -a -m …`).
+      # @param [Bool] push If true, will `git push` to `origin` after the commit has been created. Defaults to `false`.
+      #
+      # @return [Bool] True if commit and push were successful, false if there was an issue during commit & push (most likely being "nothing to commit").
+      #
+      def self.commit(message:, files: nil, push: false)
+        files = [files] if files.is_a?(String)
+        args = []
+        if files == :all
+          args = ['-a']
+        elsif !files.nil? && !files.empty?
+          Action.sh('git', 'add', *files)
+        end
+        begin
+          Action.sh('git', 'commit', *args, '-m', message)
+          Action.sh('git', 'push', 'origin', 'HEAD') if push
+          return true
+        rescue
+          return false
+        end
+      end
+
+      # Get the SHA of a given git ref. Typically useful to get the SHA of the current HEAD commit.
+      #
+      # @param [String] ref The git ref (commit, branch name, 'HEAD', …) to resolve as a SHA
+      # @return [String] The commit SHA of the ref
+      #
+      def self.get_commit_sha(ref: 'HEAD')
+        Git.open(Dir.pwd).revparse(ref)
+      end
+
+      # Creates a tag for the given version, and optionally push it to the remote.
+      #
+      # @param [String] version The name of the tag to push, e.g. "1.2"
+      # @param [Bool] push If true (the default), the tag will also be pushed to `origin`
+      #
+      def self.create_tag(version, push: true)
+        Action.sh('git', 'tag', version)
+        Action.sh('git', 'push', 'origin', version) if push
+      end
+
+      # Returns the list of tags that are pointing to the current commit (HEAD)
+      #
+      # @return [Array<String>] List of tags associated with the HEAD commit
+      #
+      def self.list_tags_on_current_commit
+        Action.sh('git', 'tag', '--points-at', 'HEAD').split("\n")
+      end
+
+      # List all the tags in the local working copy, optionally filtering the list using a pattern
+      #
+      # @param [String] matching The pattern of the tag(s) to match and filter on; use "*" for wildcards.
+      #        For example, `"1.2.*"` will match every tag starting with `"1.2."`. Defaults to '*' which lists all tags.
+      #
+      # @return [Array<String>] The list of local tags matching the pattern
+      #
+      def self.list_local_tags(matching: '*')
+        Action.sh('git', 'tag', '--list', matching).split("\n")
+      end
+
+      # Delete the mentioned local tags in the local working copy, and optionally delete them on the remote too.
+      #
+      # @param [Array<String>] tags_to_delete The list of tags to delete
+      # @param [Bool] delete_on_remote If true, will also delete the tag from the remote. Otherwise, it will only be deleted locally.
+      #
+      def self.delete_tags(tags_to_delete, delete_on_remote: false)
+        g = Git.open(Dir.pwd)
+        local_tag_names = g.tags.map(&:name)
+
+        Array(tags_to_delete).each do |tag|
+          g.delete_tag(tag) if local_tag_names.include?(tag)
+          g.push('origin', ":refs/tags/#{tag}") if delete_on_remote
+        end
+      end
+
+      # Fetch all the tags from the remote.
+      #
+      def self.fetch_all_tags
+        Action.sh('git', 'fetch', '--tags')
+      end
+
+      # Checks if a branch exists locally.
+      #
+      # @param [String] branch_name The name of the branch to check for
+      #
+      # @return [Bool] True if the branch exists in the local working copy, false otherwise.
+      #
+      def self.branch_exists?(branch_name)
+        !Action.sh('git', 'branch', '--list', branch_name).empty?
+      end
+
+      # Ensure that we are on the expected branch, and abort if not.
+      #
+      # @param [String] branch_name The name of the branch we expect to be on
+      #
+      # @raise [UserError] Raises a user_error! and interrupts the lane if we are not on the expected branch.
+      #
+      def self.ensure_on_branch!(branch_name)
+        current_branch_name = Action.sh('git', 'symbolic-ref', '-q', 'HEAD')
+        UI.user_error!("This command works only on #{branch_name} branch") unless current_branch_name.include?(branch_name)
+      end
+
+      # Checks whether a given path is ignored by Git, relying on Git's
+      # `check-ignore` under the hood.
+      #
+      # @param [String] path The path to check against `.gitignore`
+      #
+      # @return [Bool] True if the given path is ignored or outside a Git repository, false otherwise.
+      def self.is_ignored?(path:)
+        return true unless is_git_repo?(path: path)
+
+        Actions.sh('git', 'check-ignore', path) do |status, _, _|
+          status.success?
+        end
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/wpmreleasetoolkit/helper/github_helper.rb

@@ -0,0 +1,135 @@
+require 'fastlane_core/ui/ui'
+require 'octokit'
+require 'open-uri'
+
+module Fastlane
+  UI = FastlaneCore::UI unless Fastlane.const_defined?('UI')
+
+  module Helper
+    class GithubHelper
+      def self.github_client
+        client = Octokit::Client.new(access_token: ENV['GHHELPER_ACCESS'])
+
+        # Fetch the current user
+        user = client.user
+        UI.message("Logged in as: #{user.name}")
+
+        # Auto-paginate to ensure we're not missing data
+        client.auto_paginate = true
+
+        client
+      end
+
+      def self.get_milestone(repository, release)
+        miles = github_client().list_milestones(repository)
+        mile = nil
+
+        miles&.each do |mm|
+          mile = mm if mm[:title].start_with?(release)
+        end
+
+        return mile
+      end
+
+      # Fetch all the PRs for a given milestone
+      #
+      # @param [String] repository The repository name, including the organization (e.g. `wordpress-mobile/wordpress-ios`)
+      # @param [String] milestone The name of the milestone we want to fetch the list of PRs for (e.g.: `16.9`)
+      # @return [<Sawyer::Resource>] A list of the PRs for the given milestone, sorted by number
+      #
+      def self.get_prs_for_milestone(repository, milestone)
+        github_client.search_issues(%(type:pr milestone:"#{milestone}" repo:#{repository}))[:items].sort_by(&:number)
+      end
+
+      def self.get_last_milestone(repository)
+        options = {}
+        options[:state] = 'open'
+
+        milestones = github_client().list_milestones(repository, options)
+        return nil if milestones.nil?
+
+        last_stone = nil
+        milestones.each do |mile|
+          if last_stone.nil?
+            last_stone = mile unless mile[:title].split(' ')[0].split('.').length < 2
+          else
+            begin
+              if mile[:title].split(' ')[0].split('.')[0] > last_stone[:title].split(' ')[0].split('.')[0]
+                last_stone = mile
+              elsif mile[:title].split(' ')[0].split('.')[1] > last_stone[:title].split(' ')[0].split('.')[1]
+                last_stone = mile
+              end
+            rescue StandardError
+              puts 'Found invalid milestone'
+            end
+          end
+        end
+
+        last_stone
+      end
+
+      def self.create_milestone(repository, newmilestone_number, newmilestone_duedate, need_submission)
+        submission_date = need_submission ? newmilestone_duedate.to_datetime.next_day(11) : newmilestone_duedate.to_datetime.next_day(14)
+        release_date = newmilestone_duedate.to_datetime.next_day(14)
+        comment = "Code freeze: #{newmilestone_duedate.to_datetime.strftime('%B %d, %Y')} App Store submission: #{submission_date.strftime('%B %d, %Y')} Release: #{release_date.strftime('%B %d, %Y')}"
+
+        options = {}
+        options[:due_on] = newmilestone_duedate
+        options[:description] = comment
+        github_client().create_milestone(repository, newmilestone_number, options)
+      end
+
+      # Creates a Release on GitHub as a Draft
+      #
+      # @param [String] repository The repository to create the GitHub release on. Typically a repo slug (<org>/<repo>).
+      # @param [String] version The version for which to create this release. Will be used both as the name of the tag and the name of the release.
+      # @param [String?] target The commit SHA or branch name that this release will point to when it's published and creates the tag.
+      #        If nil (the default), will use the repo's current HEAD commit at the time this method is called.
+      #        Unused if the tag already exists.
+      # @param [String] description The text to use as the release's body / description (typically the release notes)
+      # @param [Array<String>] assets List of file paths to attach as assets to the release
+      # @param [TrueClass|FalseClass] prerelease Indicates if this should be created as a pre-release (i.e. for alpha/beta)
+      #
+      def self.create_release(repository:, version:, target: nil, description:, assets:, prerelease:)
+        release = github_client().create_release(
+          repository,
+          version, # tag name
+          name: version, # release name
+          target_commitish: target || Git.open(Dir.pwd).log.first.sha,
+          draft: true,
+          prerelease: prerelease,
+          body: description
+        )
+        assets.each do |file_path|
+          github_client().upload_asset(release[:url], file_path, content_type: 'application/octet-stream')
+        end
+      end
+
+      # Downloads a file from the given GitHub tag
+      #
+      # @param [String] repository The repository name (including the organization)
+      # @param [String] tag The name of the tag we're downloading from
+      # @param [String] file_path The path, inside the project folder, of the file to download
+      # @param [String] download_folder The folder which the file should be downloaded into
+      # @return [String] The path of the downloaded file, or nil if something went wrong
+      #
+      def self.download_file_from_tag(repository:, tag:, file_path:, download_folder:)
+        repository = repository.delete_prefix('/').chomp('/')
+        file_path = file_path.delete_prefix('/').chomp('/')
+        file_name = File.basename(file_path)
+        download_path = File.join(download_folder, file_name)
+
+        begin
+          uri = URI.parse("https://raw.githubusercontent.com/#{repository}/#{tag}/#{file_path}")
+          uri.open do |remote_file|
+            File.write(download_path, remote_file.read)
+          end
+        rescue OpenURI::HTTPError
+          return nil
+        end
+
+        download_path
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/wpmreleasetoolkit/helper/ios/ios_adc_app_sizes_helper.rb

@@ -0,0 +1,74 @@
+require 'spaceship'
+
+module Fastlane
+  module Helper
+    module Ios
+      module ADCAppSizesHelper
+        DEFAULT_DEVICES = ['Universal', 'iPhone 8', 'iPhone X']
+
+        # Fetch the App Sizes stats from ADC
+        #
+        # @return [Array<Hash>] app build details, one entry per app version found
+        #         Each entry is a hash with keys `cfBundleVersion` and `sizesInBytes`.
+        #         Value for key `sizeInBytes` is itself a Hash with one entry per device name (including special name "Universal")
+        #         whose value is a Hash with keys `compressed` and `uncompressed`
+        #
+        def self.get_adc_sizes(adc_user:, adc_team: 'Automattic, Inc.', bundle_id:, only_version: nil, limit: 10)
+          UI.message 'Connecting to ADC...'
+          Spaceship::ConnectAPI.login(adc_user, team_name: adc_team)
+          app = Spaceship::ConnectAPI::App.find(bundle_id)
+
+          UI.message 'Fetching the list of versions...'
+          versions = app.app_store_versions.select { |v| v.version_string == only_version && !v.build.nil? }
+          versions = app.get_app_store_versions.reject { |v| v.build.nil? } if versions.empty?
+          UI.message "Found #{versions.count} versions." + (limit == 0 ? '' : " Limiting to last #{limit}")
+          versions = versions.first(limit) unless limit == 0
+
+          UI.message 'Fetching App Sizes...'
+
+          builds_details = versions.each_with_index.map do |v, idx|
+            print "Fetching info for: #{v.version_string.rjust(8)} (#{v.build.version.rjust(11)}) [#{idx.to_s.rjust(3)}/#{versions.count}]\r"
+            Spaceship::Tunes.client.build_details(app_id: app.id, train: v.version_string, build_number: v.build.version, platform: 'ios') rescue nil
+          end.compact.reverse
+          print(' ' * 55 + "\n")
+
+          builds_details
+        end
+
+        def self.sz(bytes)
+          (bytes.to_f / (1024 * 1024)).round(1)
+        end
+
+        def self.sz_mb(bytes)
+          sz(bytes).to_s.rjust(5) + ' MB'
+        end
+
+        def self.format_csv(app_sizes, devices: nil)
+          devices = DEFAULT_DEVICES if devices.nil? || devices.empty?
+          csv = "Version\t" + devices.join("\t") + "\n"
+          app_sizes.each do |details|
+            build_number = details['cfBundleVersion']
+            sizes = details['sizesInBytes'].select { |name, _| devices.include?(name) }
+            csv += "#{build_number}\t" + devices.map { |d| sz(sizes[d]['compressed']) }.join("\t") + "\n"
+          end
+          csv
+        end
+
+        def self.format_markdown(app_sizes, devices: nil)
+          devices = DEFAULT_DEVICES if devices.nil? || devices.empty?
+          app_sizes.map do |details|
+            build_number = details['cfBundleVersion']
+            sizes = details['sizesInBytes'].select { |name, _| devices.include?(name) }
+            col_size = devices.map(&:length).max
+            table = "| #{build_number.ljust(col_size)} | Download | Install  |\n"
+            table += "|:#{'-' * col_size}-|---------:|---------:|\n"
+            sizes.each do |(device_name, size_info)|
+              table += "| #{device_name.ljust(col_size)} | #{sz_mb(size_info['compressed'])} | #{sz_mb(size_info['uncompressed'])} |\n"
+            end
+            table
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/wpmreleasetoolkit/helper/ios/ios_git_helper.rb

@@ -0,0 +1,80 @@
+module Fastlane
+  module Helper
+    module Ios
+      # Helper methods to execute git-related operations that are specific to iOS projects
+      #
+      module GitHelper
+        # Commit and push the files that are modified when we bump version numbers on an iOS project
+        #
+        # This typically commits and pushes:
+        #  - The files in `./config/*` – especially `Version.*.xcconfig` files
+        #  - The `fastlane/Deliverfile` file (which contains the `app_version` line)
+        #  - The `<ProjectRoot>/<ProjectName>/Resources/AppStoreStrings.pot` file, containing a key for that version's release notes
+        #
+        # @env PROJECT_ROOT_FOLDER The path to the git root of the project
+        # @env PROJECT_NAME The name of the directory containing the project code (especially containing the Resources/ subfolder)
+        #
+        # @param [Bool] include_deliverfile If true (the default), includes the `fastlane/Deliverfile` in files being commited
+        # @param [Bool] include_metadata If true (the default), includes the `fastlane/download_metadata.swift` file and the `.pot` file (which typically contains an entry or release notes for the new version)
+        #
+        def self.commit_version_bump(include_deliverfile: true, include_metadata: true)
+          files_list = [File.join(ENV['PROJECT_ROOT_FOLDER'], 'config', '.')]
+          files_list.append File.join('fastlane', 'Deliverfile') if include_deliverfile
+          if include_metadata
+            files_list.append File.join('fastlane', 'download_metadata.swift')
+            files_list.append File.join(ENV['PROJECT_ROOT_FOLDER'], ENV['PROJECT_NAME'], 'Resources', ENV['APP_STORE_STRINGS_FILE_NAME'])
+          end
+
+          Fastlane::Helper::GitHelper.commit(message: 'Bump version number', files: files_list, push: true)
+        end
+
+        # Calls the `Scripts/localize.py` script in the project root folder and push the `*.strings` files
+        #
+        # That script updates the `.strings` files with translations from GlotPress.
+        #
+        # @env PROJECT_ROOT_FOLDER The path to the git root of the project
+        # @env PROJECT_NAME The name of the directory containing the project code (especially containing the `build.gradle` file)
+        #
+        # @todo Migrate the scripts, currently in each host repo and called by this method, to be helpers and actions
+        #       in the release-toolkit instead, and move this code away from `ios_git_helper`.
+        #
+        def self.localize_project
+          Action.sh("cd #{get_from_env!(key: 'PROJECT_ROOT_FOLDER')} && ./Scripts/localize.py")
+
+          Fastlane::Helper::GitHelper.commit(message: 'Update strings for localization', files: strings_files, push: true) || UI.message('No new strings, skipping commit')
+        end
+
+        # Call the `Scripts/update-translations.rb` then the `fastlane/download_metadata` Scripts from the host project folder
+        #
+        # @env PROJECT_ROOT_FOLDER The path to the git root of the project
+        # @env PROJECT_NAME The name of the directory containing the project code (especially containing the `build.gradle` file)
+        #
+        # @todo Migrate the scripts, currently in each host repo and called by this method, to be helpers and actions
+        #       in the release-toolkit instead, and move this code away from `ios_git_helper`.
+        #
+        def self.update_metadata
+          Action.sh("cd #{get_from_env!(key: 'PROJECT_ROOT_FOLDER')} && ./Scripts/update-translations.rb")
+
+          Fastlane::Helper::GitHelper.commit(message: 'Update translations', files: strings_files, push: false)
+
+          Action.sh('cd fastlane && ./download_metadata.swift')
+
+          Fastlane::Helper::GitHelper.commit(message: 'Update metadata translations', files: './fastlane/metadata/', push: true)
+        end
+
+        def self.strings_files
+          project_root = get_from_env!(key: 'PROJECT_ROOT_FOLDER')
+          project_name = get_from_env!(key: 'PROJECT_NAME')
+
+          Dir.glob(File.join(project_root, project_name, '**', '*.strings'))
+        end
+
+        def self.get_from_env!(key:)
+          ENV.fetch(key) do
+            UI.user_error! "Could not find value for \"#{key}\" in environment."
+          end
+        end
+      end
+    end
+  end
+end