decidim 0.28.4 → 0.29.0.rc1

data/lib/decidim/backporter.rb

@@ -1,98 +0,0 @@
-# frozen_string_literal: true
-
-module Decidim
-  class Backporter
-    class InvalidMetadataError < StandardError; end
-
-    # @param token [String] token for GitHub authentication
-    # @param pull_request_id [String] the ID of the pull request that we want to backport
-    # @param version_number [String] the version number of the release that we want to make the backport to
-    # @param exit_with_unstaged_changes [Boolean] wheter we should exit cowardly if there is any unstaged change
-    def initialize(token:, pull_request_id:, version_number:, exit_with_unstaged_changes:)
-      @token = token
-      @pull_request_id = pull_request_id
-      @version_number = version_number
-      @exit_with_unstaged_changes = exit_with_unstaged_changes
-    end
-
-    # Handles the different tasks to create a backport:
-    # * Gets the metadata of a pull request on GitHub
-    # * Appls thi commit to another brach and push it to the remote repository
-    # * Creates the pull request on GitHub
-    #
-    # @raise [InvalidMetadataError] if we could not get the information of this pull quest
-    # @return [void]
-    def call
-      metadata = pull_request_metadata
-      make_cherrypick_and_branch(metadata)
-      create_pull_request(metadata)
-      Decidim::GitBackportManager.checkout_develop
-    end
-
-    private
-
-    attr_reader :token, :pull_request_id, :version_number, :exit_with_unstaged_changes
-
-    # Asks the metadata for a given issue or pull request on GitHub API
-    #
-    # @return [Faraday::Response] An instance that represents an HTTP response from making an HTTP request
-    def pull_request_metadata
-      Decidim::GithubManager::Querier::ByIssueId.new(
-        token:,
-        issue_id: pull_request_id
-      ).call
-    end
-
-    # Handles all the different tasks involved on a backport with the git command line utility
-    #
-    # @return [void]
-    def make_cherrypick_and_branch(metadata)
-      Decidim::GitBackportManager.new(
-        pull_request_id:,
-        release_branch:,
-        backport_branch: backport_branch(metadata[:title]),
-        exit_with_unstaged_changes:
-      ).call
-    end
-
-    # Creates the pull request with GitHub API
-    #
-    # @return [Faraday::Response] An instance that represents an HTTP response from making an HTTP request
-    def create_pull_request(metadata)
-      params = {
-        title: "Backport '#{metadata[:title]}' to v#{version_number}",
-        body: "#### :tophat: What? Why?\n\nBackport ##{pull_request_id} to v#{version_number}\n\n:hearts: Thank you!",
-        labels: (metadata[:labels] << "backport"),
-        head: backport_branch(metadata[:title]),
-        base: release_branch
-      }
-
-      Decidim::GithubManager::Poster.new(
-        token:,
-        params:
-      ).call
-    end
-
-    # Name of the release branch
-    #
-    # @return [String] name of the release branch
-    def release_branch
-      "release/#{version_number}-stable"
-    end
-
-    # Name of the backport branch
-    #
-    # @return [String] name of the backport branch
-    def backport_branch(pull_request_title)
-      "backport/#{version_number}/#{slugify(pull_request_title).slice!(0, 30)}-#{pull_request_id}"
-    end
-
-    # Converts a string with spaces to a slug
-    # It changes it to lowercase and removes spaces
-    #
-    # @return [String] slugged string
-    def slugify(string)
-      string.downcase.strip.gsub(" ", "-").gsub(/[^\w-]/, "")
-    end
-  end
-end

data/lib/decidim/backports_reporter/cli_report.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/string/filters"
-require_relative "report"
-
-module Decidim
-  module BackportsReporter
-    class CLIReport < Decidim::BackportsReporter::Report
-      private
-
-      def output_head
-        head = "| #{"ID".center(6)} | #{"Title".center(83)} | Backport v#{last_version_number} | Backport v#{penultimate_version_number} |\n"
-        head += "|#{"-" * 8}|#{"-" * 85}|#{"-" * 16}|#{"-" * 16}|\n"
-        head
-      end
-
-      def output_line(line)
-        output = "| ##{line[:id].to_s.center(5)} "
-        output += "| #{line[:title].truncate(83).ljust(84, " ")}"
-        output += "| #{format_backport(line[:related_issues], "v#{last_version_number}")}"
-        output += "| #{format_backport(line[:related_issues], "v#{penultimate_version_number}")}|\n"
-        output
-      end
-
-      def format_backport(related_issues, version)
-        none = "None".center(15, " ")
-        return none if related_issues.empty?
-
-        pull_request = extract_backport_pull_request_for_version(related_issues, version)
-        return none if pull_request.nil?
-
-        "\e[#{state_color(pull_request[:state])}m##{pull_request[:id]}\e[0m".center(24, " ")
-      end
-
-      def state_color(state)
-        {
-          closed: "35",
-          merged: "34",
-          open: "32"
-        }[state.to_sym]
-      end
-    end
-  end
-end

data/lib/decidim/backports_reporter/csv_report.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "report"
-
-module Decidim
-  module BackportsReporter
-    class CSVReport < Decidim::BackportsReporter::Report
-      private
-
-      def output_head
-        "ID;Title;Backport v#{last_version_number};Backport v#{penultimate_version_number}\n"
-      end
-
-      def output_line(line)
-        output = "#{line[:id]};"
-        output += "#{line[:title]};"
-        output += "#{format_backport(line[:related_issues], "v#{last_version_number}")};"
-        output += "#{format_backport(line[:related_issues], "v#{penultimate_version_number}")}\n"
-        output
-      end
-
-      def format_backport(related_issues, version)
-        return if related_issues.empty?
-
-        pull_request = extract_backport_pull_request_for_version(related_issues, version)
-        return if pull_request.nil?
-
-        "#{pull_request[:state]}|#{pull_request[:id]}"
-      end
-    end
-  end
-end

data/lib/decidim/backports_reporter/report.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-module Decidim
-  module BackportsReporter
-    # Abstract class for the different formats
-    class Report
-      attr_reader :report, :last_version_number
-
-      def initialize(report:, last_version_number:)
-        @report = report
-        @last_version_number = last_version_number
-      end
-
-      def call = output_report
-
-      private
-
-      def penultimate_version_number
-        major, minor = last_version_number.split(".")
-
-        "#{major}.#{minor.to_i - 1}"
-      end
-
-      def output_report
-        output = output_head
-        report.each do |line|
-          output += output_line(line)
-        end
-        output
-      end
-
-      def output_head = raise "Called abstract method: output_head"
-
-      def output_line(_line) = raise "Called abstract method: output_line"
-
-      def extract_backport_pull_request_for_version(related_issues, version)
-        related_issues = related_issues.select do |pull_request|
-          pull_request[:title].start_with?("Backport") && pull_request[:title].include?(version)
-        end
-        return if related_issues.empty?
-
-        related_issues.first
-      end
-    end
-  end
-end

data/lib/decidim/git_backport_checker.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-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
-  # 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
-      @report = by_label(
-        label: "type: fix",
-        exclude_labels: ["backport", "no-backport"],
-        days_to_check_from: @days_to_check_from
-      ).map do |pull_request|
-        {
-          id: pull_request[:id],
-          title: pull_request[:title],
-          related_issues: related_issues(pull_request[:id])
-        }
-      end
-    end
-
-    def csv_report
-      Decidim::BackportsReporter::CSVReport.new(
-        report: @report,
-        last_version_number: @last_version_number
-      ).call
-    end
-
-    def cli_report
-      Decidim::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::GithubManager::Querier::ByLabel.new(
-        token:,
-        label:,
-        exclude_labels:,
-        days_to_check_from:
-      ).call
-    end
-
-    def related_issues(issue_id)
-      Decidim::GithubManager::Querier::RelatedIssues.new(
-        token:,
-        issue_id:
-      ).call
-    end
-  end
-end

data/lib/decidim/git_backport_manager.rb

@@ -1,179 +0,0 @@
-# frozen_string_literal: true
-
-require "shellwords"
-require "English"
-
-module Decidim
-  # Handles the backport of a given pull request to a branch
-  # Uses the git commnad line client
-  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
-end

data/lib/decidim/github_manager/poster.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/hash/except"
-require "faraday"
-require "json"
-
-module Decidim
-  module GithubManager
-    # Allows to make POST requests to GitHub Rest API about Pull Requests
-    # @see https://docs.github.com/en/rest
-    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
-  end
-end

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

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-require "faraday"
-require "uri"
-
-module Decidim
-  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's the first time that we're 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

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

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "base"
-
-module Decidim
-  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::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:,
-            type: labels.select { |l| l.match(/^type: /) || l == "target: developer-experience" },
-            modules: labels.select { |l| l.match(/^module: /) }
-          }
-        end
-      end
-    end
-  end
-end