decidim-maintainers_toolbox 0.1.0

data/lib/decidim/maintainers_toolbox/changelog_generator.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require_relative "github_manager/querier"
+
+require "json"
+require "ruby-progressbar"
+
+module Decidim
+  module MaintainersToolbox
+    class ChangeLogGenerator
+      class InvalidMetadataError < StandardError; end
+
+      TYPES = {
+        "Added" => {
+          label: "type: feature",
+          skip_modules: false
+        },
+        "Changed" => {
+          label: "type: change",
+          skip_modules: false
+        },
+        "Fixed" => {
+          label: "type: fix",
+          skip_modules: false
+        },
+        "Removed" => {
+          label: "type: removal",
+          skip_modules: false
+        },
+        "Developer improvements" => {
+          label: "target: developer-experience",
+          skip_modules: true
+        },
+        "Internal" => {
+          label: "type: internal",
+          skip_modules: false
+        }
+      }.freeze
+
+      def initialize(token:, since_sha:)
+        @token = token
+        @since_sha = since_sha
+        @output_file = []
+        @handled_ids = []
+
+        @progress_bar = ProgressBar.create(title: "PRs", total: list_of_commits.count)
+      end
+
+      def call
+        raise InvalidMetadataError if token.nil?
+
+        TYPES.each do |type_title, type_data|
+          type_prs = prs.select do |_commit_title, data|
+            next unless data
+
+            data[:type].include?(type_data[:label])
+          end
+
+          output "### #{type_title}"
+          output ""
+
+          if type_prs.any?
+            type_prs.each do |_pr_title, data|
+              process_single_pr(data, type_data)
+            end
+          else
+            output "Nothing."
+          end
+
+          output ""
+        end
+
+        process_unsorted_prs
+        write_data_file!
+      end
+
+      private
+
+      def write_data_file!
+        File.write("temporary_changelog.md", @output_file.join("\n"))
+        puts "Written file: temporary_changelog.md"
+      end
+
+      def process_single_pr(data, type_data)
+        modules_list = data[:modules].map { |l| "**decidim-#{l.delete_prefix("module: ")}**" }
+        id = data[:id]
+        title = data[:title]
+
+        @handled_ids << id
+
+        if type_data[:skip_modules] || modules_list.empty?
+          output "- #{title} #{pr_link(id)}"
+        else
+          output "- #{modules_list.join(", ")}: #{title} #{pr_link(id)}"
+        end
+      end
+
+      def process_unsorted_prs
+        return unless unsorted_prs.any?
+
+        output "### Unsorted"
+        output ""
+
+        unsorted_prs.map do |title, data|
+          pr_data = data || {}
+          output "- #{title} #{pr_link(pr_data[:id])} || #{data}"
+        end
+      end
+
+      def unsorted_prs
+        @unsorted_prs ||= prs.reject do |_commit_title, data|
+          pr_data = data || {}
+
+          @handled_ids.include?(pr_data[:id])
+        end
+      end
+
+      attr_reader :token, :since_sha
+
+      def prs
+        @prs ||= list_of_commits.inject({}) do |acc, commit|
+          next acc if crowdin?(commit)
+
+          acc.update(commit => get_pr_data(commit))
+        end
+      end
+
+      def list_of_commits
+        @list_of_commits ||= `git log #{since_sha}..HEAD --oneline`.split("\n").reverse
+      end
+
+      def crowdin?(commit)
+        !commit.match(/New Crowdin updates/).nil?
+      end
+
+      def get_pr_id(commit)
+        id = commit.scan(/#\d+/).last
+        return unless id
+
+        id.delete_prefix("#")
+      end
+
+      def get_pr_data(commit)
+        @progress_bar.increment
+
+        id = get_pr_id(commit)
+        return nil unless id
+
+        Decidim::MaintainersToolbox::GithubManager::Querier::ByIssueId.new(
+          token: token,
+          issue_id: id
+        ).call
+      end
+
+      def pr_link(id)
+        # We need to do this so that it generates the expected Markdown format.
+        # String interpolation messes with the format.
+        "[#{"\\#" + id.to_s}](https://github.com/decidim/decidim/pull/#{id})" # rubocop:disable Style/StringConcatenation
+      end
+
+      def output(str)
+        @output_file << str
+      end
+    end
+  end
+end

data/lib/decidim/maintainers_toolbox/git_backport_checker.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "ruby-progressbar"
+
+require_relative "github_manager/querier/by_label"
+require_relative "github_manager/querier/related_issues"
+require_relative "backports_reporter/csv_report"
+require_relative "backports_reporter/cli_report"
+
+module Decidim
+  module MaintainersToolbox
+    # Extracts the status of the Pull Requests on the decidim repository
+    # with the label "type: fix" and shows the status of the related Pull Requests,
+    # so we can check which PRs have pending backports
+    class GitBackportChecker
+      # @param token [String] token for GitHub authentication
+      # @param days_to_check_from [Integer] the number of days since the pull requests were merged from when we will start the check
+      # @param last_version_number [String] the version number of the last release that we want to make the backport to
+      def initialize(token:, days_to_check_from:, last_version_number:)
+        @token = token
+        @days_to_check_from = days_to_check_from
+        @last_version_number = last_version_number
+      end
+
+      def call
+        pull_requests_with_labels = by_label(
+          label: "type: fix",
+          exclude_labels: ["backport", "no-backport"],
+          days_to_check_from: @days_to_check_from
+        )
+
+        progress_bar = ProgressBar.create(title: "PRs", total: pull_requests_with_labels.count)
+        @report = []
+
+        pull_requests_with_labels.each do |pull_request|
+          progress_bar.increment
+
+          @report << {
+            id: pull_request[:id],
+            title: pull_request[:title],
+            related_issues: related_issues(pull_request[:id])
+          }
+        end
+      end
+
+      def csv_report
+        Decidim::MaintainersToolbox::BackportsReporter::CSVReport.new(
+          report: @report,
+          last_version_number: @last_version_number
+        ).call
+      end
+
+      def cli_report
+        Decidim::MaintainersToolbox::BackportsReporter::CLIReport.new(
+          report: @report,
+          last_version_number: @last_version_number
+        ).call
+      end
+
+      private
+
+      attr_reader :token
+
+      def by_label(label:, exclude_labels:, days_to_check_from:)
+        Decidim::MaintainersToolbox::GithubManager::Querier::ByLabel.new(
+          token: token,
+          label: label,
+          exclude_labels: exclude_labels,
+          days_to_check_from: days_to_check_from
+        ).call
+      end
+
+      def related_issues(issue_id)
+        Decidim::MaintainersToolbox::GithubManager::Querier::RelatedIssues.new(
+          token: token,
+          issue_id: issue_id
+        ).call
+      end
+    end
+  end
+end

data/lib/decidim/maintainers_toolbox/git_backport_manager.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require "shellwords"
+require "English"
+
+module Decidim
+  module MaintainersToolbox
+    # Handles the backport of a given pull request to a branch
+    # Uses the git commnad line client
+    # rubocop:disable Rails/Output
+    class GitBackportManager
+      # @param pull_request_id [String] the ID of the pull request that we want to backport
+      # @param release_branch [String] the name of the branch that we want to backport to
+      # @param backport_branch [String] the name of the branch that we want to create
+      # @param working_dir [String] current working directory. Useful for testing purposes
+      # @param exit_with_unstaged_changes [Boolean] wheter we should exit cowardly if there is any unstaged change
+      def initialize(pull_request_id:, release_branch:, backport_branch:, working_dir: Dir.pwd, exit_with_unstaged_changes: false)
+        @pull_request_id = pull_request_id
+        @release_branch = release_branch
+        @backport_branch = sanitize_branch(backport_branch)
+        @working_dir = working_dir
+        @exit_with_unstaged_changes = exit_with_unstaged_changes
+      end
+
+      # Handles all the different tasks involved on a backport with the git command line utility
+      # It does the following tasks:
+      # * Creates a branch based on a release branch
+      # * Apply a commit to this branch
+      # * Push it to the remote repository
+      #
+      # @return [void]
+      def call
+        Dir.chdir(working_dir) do
+          exit_if_unstaged_changes if @exit_with_unstaged_changes
+          self.class.checkout_develop
+          sha_commit = sha_commit_to_backport
+
+          error_message = <<-EOERROR
+        Could not find commit for pull request #{pull_request_id}.
+        Please make sure you have pulled the latest changes.
+          EOERROR
+          exit_with_errors(error_message) unless sha_commit
+
+          create_backport_branch!
+          cherrypick_commit!(sha_commit)
+          clean_commit_message!
+          push_backport_branch!
+        end
+      end
+
+      # Switch to the develop branch
+      # In case that it cannot do that, exits
+      #
+      # @return [void]
+      def self.checkout_develop
+        `git checkout develop`
+
+        error_message = <<-EOERROR
+      Could not checkout the develop branch.
+      Please make sure you do not have any uncommitted changes in the current branch.
+        EOERROR
+        exit_with_errors(error_message) unless $CHILD_STATUS.exitstatus.zero?
+      end
+
+      private
+
+      attr_reader :pull_request_id, :release_branch, :backport_branch, :working_dir
+
+      # Create the backport branch based on a release branch
+      # Checks that this branch does not exist already, if it does then exits
+      #
+      # @return [void]
+      def create_backport_branch!
+        `git checkout #{release_branch}`
+
+        diff_count = `git rev-list HEAD..#{remote}/#{release_branch} --count`.strip.to_i
+        `git pull #{remote} #{release_branch}` if diff_count.positive?
+        `git checkout -b #{backport_branch}`
+
+        error_message = <<-EOERROR
+      Branch already exists locally.
+      Delete it with 'git branch -D #{backport_branch}' and rerun the script.
+        EOERROR
+        exit_with_errors(error_message) unless $CHILD_STATUS.exitstatus.zero?
+      end
+
+      # Cherrypick a commit from another branch
+      # Apply the changes introduced by some existing commits
+      # Drops to a shell in case that it needs a manual conflict resolution
+      #
+      # @return [void]
+      def cherrypick_commit!(sha_commit)
+        return unless sha_commit
+
+        puts "Cherrypicking commit #{sha_commit}"
+        `git cherry-pick #{sha_commit}`
+
+        unless $CHILD_STATUS.exitstatus.zero?
+          puts "Resolve the cherrypick conflict manually and exit your shell to keep with the process."
+          system ENV.fetch("SHELL")
+        end
+      end
+
+      # Clean the commit message to remove the pull request ID of the last commit
+      # This is mostly cosmetic, but if we don´t do this, we will have the two IDs on the final commit:
+      # the ID of the original PR and the id of the backported PR.
+      #
+      # @return [void]
+      def clean_commit_message!
+        message = `git log --pretty=format:"%B" -1`
+        message = message.lines[0].gsub!(/ \(#[0-9]+\)$/, "").concat(*message.lines[1..-1])
+        message.gsub!('"', '"\""') # Escape the double quotes for bash as they are the message delimiters
+
+        `git commit --amend -m "#{message}"`
+      end
+
+      # Push the branch to a git remote repository
+      # Checks that there is actually something to push first, if not then it exits.
+      #
+      # @return [void]
+      def push_backport_branch!
+        if `git diff #{backport_branch}..#{release_branch}`.empty?
+          self.class.checkout_develop
+
+          error_message = <<-EOERROR
+        Nothing to push to remote server.
+        It was probably merged already or the cherry-pick was aborted.
+          EOERROR
+          exit_with_errors(error_message)
+        else
+          puts "Pushing branch #{backport_branch} to #{remote}"
+          `git push #{remote} #{backport_branch}`
+        end
+      end
+
+      # The name of the git remote repository in the local git repository configuration
+      # Most of the times this would be origin or upstream.
+      #
+      # @return [String] the name of the git repository
+      def remote
+        `git remote -v | grep -e 'decidim/decidim\\([^ ]*\\) (push)' | sed 's/\\s.*//'`.strip
+      end
+
+      # The SHA1 commit to backport
+      # It needs to have a pull_request_id associated in the commit message
+      #
+      # @return [String] the SHA1 commit
+      def sha_commit_to_backport
+        `git log --format=oneline | grep "(##{pull_request_id})"`.split.first
+      end
+
+      # Replace all the characters from the user supplied input that are uncontrolled
+      # and could generate a command line injection
+      #
+      # @return [String] the sanitized branch name
+      def sanitize_branch(branch_name)
+        Shellwords.escape(branch_name.gsub("`", ""))
+      end
+
+      # Exit the script execution if there are any unstaged changes
+      #
+      # @return [void]
+      def exit_if_unstaged_changes
+        return if `git diff`.empty?
+
+        error_message = <<-EOERROR
+      There are changes not staged in your project.
+      Please commit your changes or stash them.
+        EOERROR
+        exit_with_errors(error_message)
+      end
+
+      # Exit the script execution with a message
+      #
+      # @return [void]
+      def exit_with_errors(message)
+        puts message
+        exit 1
+      end
+    end
+
+    # rubocop:enable Rails/Output
+  end
+end

data/lib/decidim/maintainers_toolbox/github_manager/poster.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/hash/except"
+require "faraday"
+require "json"
+
+module Decidim
+  module MaintainersToolbox
+    module GithubManager
+      # Allows to make POST requests to GitHub Rest API about Pull Requests
+      # @see https://docs.github.com/en/rest
+      # rubocop:disable Rails/Output
+      class Poster
+        # @param token [String] token for GitHub authentication
+        # @param params [Hash] Parameters accepted by the GitHub API
+        def initialize(token:, params:)
+          @token = token
+          @params = params
+        end
+
+        # Create the pull request or give error messages
+        #
+        # @return [Faraday::Response] An instance that represents an HTTP response from making an HTTP request
+        def call
+          response = create_pull_request!
+          pull_request_id = JSON.parse(response.body)["number"]
+          unless pull_request_id
+            puts "Pull request could not be created!"
+            puts "Please make sure you have enabled the 'public_repo' scope for the access token"
+            return
+          end
+          puts "Pull request created at https://github.com/decidim/decidim/pull/#{pull_request_id}"
+
+          add_labels_to_issue!(pull_request_id)
+        end
+
+        private
+
+        attr_reader :token, :params
+
+        # Make the POST request to GitHub API of the decidim repository
+        #
+        # @param path [String] The path to do the request to the GitHub API
+        # @param some_params [Hash] The parameters of the request
+        # @return [Faraday::Response] An instance that represents an HTTP response from making an HTTP request
+        def post!(path, some_params)
+          uri = "https://api.github.com/repos/decidim/decidim/#{path}"
+          Faraday.post(uri, some_params.to_json, { Authorization: "token #{token}" })
+        end
+
+        # Create a pull request using the GitHub API
+        #
+        # @see https://docs.github.com/en/rest/pulls/pulls#create-a-pull-request GitHub API documentation
+        # @return [Faraday::Response] An instance that represents an HTTP response from making an HTTP request
+        def create_pull_request!
+          puts "Creating the PR in GitHub"
+          post!("pulls", params.except(:labels))
+        end
+
+        # Add labels to an issue or a pull request
+        # GitHub does not support adding labels while creating the PR, so we need to do it afterwards
+        #
+        # @see https://docs.github.com/en/rest/issues/labels#add-labels-to-an-issue GitHub API documentation
+        # @param issue_id [String] String of the issue to add the labels to
+        # @return [Faraday::Response] An instance that represents an HTTP response from making an HTTP request
+        def add_labels_to_issue!(issue_id)
+          puts "Adding the labels to the PR"
+          post!("issues/#{issue_id}/labels", params.slice(:labels))
+        end
+      end
+
+      # rubocop:enable Rails/Output
+    end
+  end
+end

data/lib/decidim/maintainers_toolbox/github_manager/querier/base.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require "json"
+require "faraday"
+require "uri"
+
+module Decidim
+  module MaintainersToolbox
+    module GithubManager
+      module Querier
+        # Base class that allows making GET requests to GitHub Rest API about Issues and Pull Requests
+        # This must be inherited from other class with the following methods:
+        # - call
+        # - uri
+        # @see https://docs.github.com/en/rest
+        class Base
+          class InvalidMetadataError < StandardError; end
+
+          def initialize(token:)
+            @token = token
+          end
+
+          def call
+            raise "Not implemented"
+          end
+
+          private
+
+          attr_reader :token
+
+          def headers
+            nil
+          end
+
+          def authorization_header
+            { Authorization: "token #{token}" }
+          end
+
+          def request(uri)
+            response = Faraday.get(uri, headers, authorization_header)
+
+            { body: response.body, headers: response.headers }
+          end
+
+          # Get's the JSON response from a URI
+          # Supports pagination
+          #
+          # @param uri {String} - The URL that we want to get the JSON response from
+          # @param old_json {Array} - The Array with the old_json or an empty Array if it is the first time that we are calling this method
+          def json_response(uri, old_json = [])
+            body, headers = request(uri).values_at(:body, :headers)
+            json = JSON.parse(body)
+            json.concat(old_json) if json.is_a?(Array)
+            raise InvalidMetadataError if json.is_a?(Hash) && json["message"] == "Bad credentials"
+
+            # If there are more pages, then we call ourselves redundantly to fetch the next page
+            next_json = more_pages?(headers) ? json_response(next_page(headers), json) : []
+
+            if json.is_a?(Array)
+              # For some reason we have duplicated values, so we deduplicate them
+              json.concat(next_json).uniq { |issue| issue.has_key?("number") ? issue["number"] : issue }
+            else
+              json
+            end
+          end
+
+          def more_pages?(headers)
+            return false if headers["link"].nil?
+
+            headers["link"].include?('rel="next"')
+          end
+
+          def next_page(headers)
+            URI.extract(headers["link"].split(",").select { |url| url.end_with?('rel="next"') }[0])[0]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/decidim/maintainers_toolbox/github_manager/querier/by_issue_id.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Decidim
+  module MaintainersToolbox
+    module GithubManager
+      module Querier
+        # Makes a GET request for the metadata of an Issue or Pull Request in GitHub
+        #
+        # @see https://docs.github.com/en/rest/issues/issues#get-an-issue GitHub API documentation
+        class ByIssueId < Decidim::MaintainersToolbox::GithubManager::Querier::Base
+          def initialize(issue_id:, token:)
+            @issue_id = issue_id
+            @token = token
+          end
+
+          # Makes the GET request and parses the response of an Issue or Pull Request in GitHub
+          #
+          # @return [Hash]
+          def call
+            data = json_response("https://api.github.com/repos/decidim/decidim/issues/#{@issue_id}")
+            return unless data["number"]
+
+            parse(data)
+          end
+
+          private
+
+          # Parses the response of an Issue or Pull Request in GitHub
+          #
+          # @return [Hash]
+          def parse(metadata)
+            labels = metadata["labels"].map { |l| l["name"] }.sort
+
+            {
+              id: metadata["number"],
+              title: metadata["title"],
+              labels: labels,
+              type: labels.select { |l| l.match(/^type: /) || l == "target: developer-experience" },
+              modules: labels.select { |l| l.match(/^module: /) }
+            }
+          end
+        end
+      end
+    end
+  end
+end