decidim 0.27.9 → 0.28.0.rc4

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

@@ -0,0 +1,78 @@
+# 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

@@ -0,0 +1,46 @@
+# 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

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

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/time/zones"
+require_relative "base"
+
+module Decidim
+  module GithubManager
+    module Querier
+      # Makes a GET request for the list of Issues or Pull Requests in GitHub.
+      # They must comply the following conditions:
+      # * To be merged in the period between the days to check from and today. (90 days by default)
+      # * To have the label that we are querying ("type: fix" by default)
+      # * To not have any of the excluded labels (["backport", "no-backport"] by default)
+      # * To have been merged
+      #
+      # @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 label [String] the label that we want to search by
+      # @param exclude_labels [Array] the labels that we want to exclude in the search
+      #
+      # @see https://docs.github.com/en/rest/issues/issues#list-repository-issues GitHub API documentation
+      class ByLabel < Decidim::GithubManager::Querier::Base
+        def initialize(token:, days_to_check_from: 90, label: "type: fix", exclude_labels: ["backport", "no-backport"])
+          @label = label
+          @exclude_labels = exclude_labels
+          @token = token
+          @days_to_check_from = days_to_check_from
+        end
+
+        # Makes the GET request and parses the response of an Issue or Pull Request in GitHub
+        #
+        # @return [Hash]
+        def call
+          parse json_response("https://api.github.com/repos/decidim/decidim/issues")
+        end
+
+        private
+
+        attr_reader :label, :exclude_labels, :days_to_check_from
+
+        def headers
+          Time.zone = "UTC"
+
+          {
+            labels: label,
+            state: "closed",
+            per_page: 100,
+            since: since.iso8601
+          }
+        end
+
+        def since
+          Time.zone.today - days_to_check_from
+        end
+
+        # Parses the response of an Issue or Pull Request in GitHub
+        #
+        # @return [Hash]
+        def parse(metadata)
+          metadata.map do |item|
+            next if has_any_of_excluded_labels?(item)
+            next unless merged?(item)
+            next unless merged_in_date_range?(item)
+
+            {
+              id: item["number"],
+              title: item["title"]
+            }
+          end.compact
+        end
+
+        def has_any_of_excluded_labels?(item)
+          item["labels"].map { |label| label.map { |_key, val| exclude_labels.include?(val) } }.flatten.any? true
+        end
+
+        def merged_at(item)
+          Date.parse(item["pull_request"]["merged_at"])
+        end
+
+        def merged?(item)
+          return false if item["pull_request"].nil?
+          return false if item["pull_request"]["merged_at"].nil?
+
+          merged_at(item).present?
+        rescue TypeError, Date::Error
+          false
+        end
+
+        def merged_in_date_range?(item)
+          merged_at(item) > since
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Decidim
+  module GithubManager
+    module Querier
+      # Makes a GET request for the related issues of an Issue or Pull Request in GitHub
+      # Uses the Timeline events API endpoint
+      #
+      # @see https://docs.github.com/en/rest/issues/timeline?apiVersion=2022-11-28 GitHub API documentation
+      class RelatedIssues < 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
+          parse(json_response("https://api.github.com/repos/decidim/decidim/issues/#{@issue_id}/timeline"))
+        end
+
+        private
+
+        def headers
+          { per_page: 100 }
+        end
+
+        # Parses the response of an Issue or Pull Request in GitHub
+        #
+        # @return [Hash]
+        def parse(metadata)
+          references = metadata.select do |item|
+            item["event"] == "cross-referenced" && item["source"]["issue"]["repository"]["full_name"] == "decidim/decidim"
+          end
+          references.map do |item|
+            issue = item["source"]["issue"]
+
+            {
+              id: issue["number"],
+              title: issue["title"].strip,
+              state: issue.dig("pull_request", "merged_at").nil? ? issue["state"] : "merged"
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/decidim/github_manager/querier.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "json"
+
+require_relative "querier/by_issue_id"
+require_relative "querier/by_label"
+require_relative "querier/related_issues"
+
+module Decidim
+  module GithubManager
+    # Allows to make GET requests to GitHub Rest API about Issues and Pull Requests
+    # @see https://docs.github.com/en/rest
+    module Querier
+      autoload :ByIssueId, "decidim/github_manager/querier/by_issue_id"
+      autoload :ByLabel, "decidim/github_manager/querier/by_label"
+      autoload :RelatedIssues, "decidim/github_manager/querier/related_issues"
+    end
+  end
+end

data/lib/decidim/release_manager.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/module/delegation"
+require "open3"
+
+module Decidim
+  # Provides utilities for performing the releases.
+  class ReleaseManager
+    # Resolves the remote where the tags will be pushed during the release.
+    def self.git_remote
+      @git_remote ||= `git remote -v | grep -e 'decidim/decidim\\([^ ]*\\) (push)' | sed 's/\\s.*//'`.strip
+    end
+
+    def self.git_remote_set?
+      git_remote.present?
+    end
+  end
+end

data/lib/decidim/releaser.rb

@@ -0,0 +1,260 @@
+# frozen_string_literal: true
+
+require "open3"
+require "decidim/github_manager/poster"
+
+module Decidim
+  class Releaser
+    class InvalidMetadataError < StandardError; end
+
+    class InvalidBranchError < StandardError; end
+
+    class InvalidVersionTypeError < StandardError; end
+
+    DECIDIM_VERSION_FILE = ".decidim-version"
+
+    # @param token [String] token for GitHub authentication
+    # @param version_type [String] The kind of release that you want to prepare. Supported values: rc, minor, patch
+    # @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(token:, version_type:, working_dir: Dir.pwd, exit_with_unstaged_changes: false)
+      @token = token
+      @version_type = version_type
+      @working_dir = working_dir
+      @exit_with_unstaged_changes = exit_with_unstaged_changes
+    end
+
+    def call
+      Dir.chdir(@working_dir) do
+        exit_if_unstaged_changes if @exit_with_unstaged_changes
+
+        run("git checkout #{release_branch}")
+        run("git pull origin #{release_branch}")
+        bump_decidim_version
+        run("bin/rake update_versions")
+        run("bin/rake bundle")
+        run("npm install")
+
+        check_tests
+
+        generate_changelog
+
+        run("git checkout -b chore/prepare/#{version_number}")
+        run("git commit -a -m 'Prepare #{version_number} release'")
+        run("git push origin chore/prepare/#{version_number}")
+
+        create_pull_request
+      end
+    end
+
+    private
+
+    # The git branch
+    #
+    # @return [String]
+    def branch
+      @branch ||= capture("git rev-parse --abbrev-ref HEAD")[0].strip
+    end
+
+    # Raise an error if the branch does not start with the preffix "release/"
+    # or returns the branch name
+    #
+    # @raise [InvalidBranchError]
+    #
+    # @return [String]
+    def release_branch
+      raise InvalidBranchError, "This is not a release branch, aborting" unless branch.start_with?("release/")
+
+      branch
+    end
+
+    # Changes the decidim version in the file
+    #
+    # @return [void]
+    def bump_decidim_version
+      File.write(DECIDIM_VERSION_FILE, version_number)
+    end
+
+    # The version number for the release that we are preparing
+    #
+    # @todo support the "minor" type version
+    #
+    # @return [String] the version number
+    def version_number
+      @version_number ||= case @version_type
+                          when "rc"
+                            next_version_number_for_release_candidate(old_version_number)
+                          when "patch"
+                            next_version_number_for_patch_release(old_version_number)
+                          else
+                            raise InvalidVersionTypeError, "This is not a supported version type"
+                          end
+    end
+
+    def parsed_version_number(version_number)
+      /(?<major>\d+)\.(?<minor>\d+)\.(?<patch>\d+)/ =~ version_number
+
+      { major: major.to_i, minor: minor.to_i, patch: patch.to_i }
+    end
+
+    # Given a version number, returns the next release candidate
+    #
+    # If the current version number is `dev`, then we return the `rc1` version
+    # If the current version number is `rc`, then we return the next `rc` version
+    # Else, it means is a `minor` or `patch` version. On those cases we raise an Exception, as releases candidates should
+    # be only done from a `dev` or a `rc` version.
+    #
+    # @raise [InvalidVersionTypeError]
+    #
+    # @param current_version_number [String] - The version number of the current version
+    #
+    # @return [String] - the new version number
+    def next_version_number_for_release_candidate(current_version_number)
+      if current_version_number.include? "dev"
+        parsed_version_number(current_version_number) => { major:, minor:, patch: }
+        new_version_number = "#{major}.#{minor}.#{patch}.rc1"
+      elsif current_version_number.include? "rc"
+        new_rc_number = current_version_number.match(/rc(\d)/)[1].to_i + 1
+        new_version_number = current_version_number.gsub(/rc\d/, "rc#{new_rc_number}")
+      else
+        error_message = <<-EOMESSAGE
+          Trying to do a release candidate version from patch release. Bailing out.
+          You need to do a release candidate from a `dev` or from another `rc` version
+        EOMESSAGE
+        raise InvalidVersionTypeError, error_message
+      end
+
+      new_version_number
+    end
+
+    # Given a version number, returns the next patch release
+    #
+    # If the current version number is `dev`, then we raise an Exception, as you need to first do a release candidate.
+    # If the current version number is `rc`, then we return the `0` patch version
+    # Else, it means is a `patch` version, so we return the next patch version
+    #
+    # @raise [InvalidVersionTypeError]
+    #
+    # @param current_version_number [String] - The version number of the current version
+    #
+    # @return [String] - the new version number
+    def next_version_number_for_patch_release(current_version_number)
+      parsed_version_number(current_version_number) => { major:, minor:, patch: }
+
+      if current_version_number.include? "dev"
+        error_message = <<-EOMESSAGE
+          Trying to do a patch version from dev release. Bailing out.
+          You need to do first a release candidate.
+        EOMESSAGE
+        raise InvalidVersionTypeError, error_message
+      elsif current_version_number.include? "rc"
+        new_version_number = "#{major}.#{minor}.0"
+      else
+        new_version_number = "#{major}.#{minor}.#{patch.to_i + 1}"
+      end
+
+      new_version_number
+    end
+
+    # The version number from the file
+    #
+    # @return [String] the version number
+    def old_version_number
+      File.read(DECIDIM_VERSION_FILE).strip
+    end
+
+    # Run the tests and if fails restore the changes using git and exit with an error
+    #
+    # @return [void]
+    def check_tests
+      # rubocop:disable Rails/Output
+      puts "Running specs"
+      output, status = capture("bin/rspec")
+
+      unless status.success?
+        run("git restore .")
+        puts output
+        exit_with_errors("Tests execution failed. Fix the errors and run again.")
+      end
+      # rubocop:enable Rails/Output
+    end
+
+    # Generates the changelog taking into account the last time the version changed
+    #
+    # @return [void]
+    def generate_changelog
+      sha_version = capture("git log -n 1 --pretty=format:%h -- .decidim-version")[0]
+      run("bin/changelog_generator #{@token} #{sha_version}")
+      temporary_changelog = File.read("./temporary_changelog.md")
+      legacy_changelog = File.read("./CHANGELOG.md")
+      version_changelog = "## [#{version_number}](https://github.com/decidim/decidim/tree/#{version_number})\n\n#{temporary_changelog}\n"
+      changelog = legacy_changelog.gsub("# Changelog\n\n", "# Changelog\n\n#{version_changelog}")
+      File.write("./CHANGELOG.md", changelog)
+    end
+
+    # Creates the pull request for bumping the version
+    #
+    # @return [void]
+    def create_pull_request
+      base_branch = release_branch
+      head_branch = "chore/prepare/#{version_number}"
+
+      params = {
+        title: "Bump to v#{version_number} version",
+        body: "#### :tophat: What? Why?
+
+This PR changes the version of the #{release_branch} branch, so we can publish the release once this is approved and merged.
+
+#### Testing
+
+All the tests should pass, except for some generators tests, that will fail because the gems and NPM packages have not
+been actually published yet (as in sent to rubygems/npm).
+You will see errors such as `No matching version found for @decidim/browserslist-config@~0.xx.y` in the CI logs.
+
+:hearts: Thank you!
+        ",
+        labels: ["type: internal"],
+        head: head_branch,
+        base: base_branch
+      }
+      Decidim::GithubManager::Poster.new(token: @token, params:).call
+    end
+
+    # Captures to output of a command
+    #
+    # @return [Array<String, Process::Status>] The stdout and stderr of the command and its status (aka error code)
+    def capture(cmd, env: {})
+      Open3.capture2e(env, cmd)
+    end
+
+    # Runs a command
+    #
+    # @return [void]
+    def run(cmd, out: $stdout)
+      system(cmd, out:)
+    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)
+      # rubocop:disable Rails/Output, Rails/Exit
+      puts message
+      exit 1
+      # rubocop:enable Rails/Output, Rails/Exit
+    end
+  end
+end

data/lib/decidim/version.rb

@@ -3,6 +3,6 @@
 # This holds the decidim version and the faker version it uses.
 module Decidim
   def self.version
-    "0.27.9"
+    "0.28.0.rc4"
   end
 end

data/lib/tasks/decidim_tasks.rake

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
 def ensure_log_goes_to_stdout
-  old_logger = Webpacker.logger
-  Webpacker.logger = ActiveSupport::Logger.new($stdout)
+  old_logger = Shakapacker.logger
+  Shakapacker.logger = ActiveSupport::Logger.new($stdout)
   yield
 ensure
-  Webpacker.logger = old_logger
+  Shakapacker.logger = old_logger
 end
 
 namespace :decidim do
@@ -16,25 +16,6 @@ namespace :decidim do
         system "npm install"
       end
     end
-
-    desc "Compile JavaScript packs using webpack for production with digests"
-    task compile: [:npm_install, :environment] do
-      Webpacker.with_node_env("production") do
-        ensure_log_goes_to_stdout do
-          if Decidim.webpacker.commands.compile
-            # Successful compilation!
-            puts "SUCCESS"
-            Dir.chdir(File.join(__dir__, "../..")) do
-              system "cp -r public/* #{Rails.public_path}"
-            end
-          else
-            # Failed compilation
-            puts "FAIL"
-            exit!
-          end
-        end
-      end
-    end
   end
 end
 
@@ -45,25 +26,9 @@ def npm_install_available?
   rails_major > 5 || (rails_major == 5 && rails_minor >= 1)
 end
 
-def enhance_assets_precompile
-  # npm:install was added in Rails 5.1
-  deps = npm_install_available? ? [] : ["decidim:webpacker:npm_install"]
-  Rake::Task["assets:precompile"].enhance(deps) do
-    Rake::Task["decidim:webpacker:compile"].invoke
-  end
-end
-
-# Compile packs after we've compiled all other assets during precompilation
+# Compile packs after we have compiled all other assets during precompilation
 skip_webpacker_precompile = %w(no false n f).include?(ENV.fetch("WEBPACKER_PRECOMPILE", nil))
 
-unless skip_webpacker_precompile
-  if Rake::Task.task_defined?("assets:precompile")
-    enhance_assets_precompile
-  else
-    Rake::Task.define_task("assets:precompile" => "decidim:webpacker:compile")
-  end
-end
-
 namespace :decidim do
   namespace :assets do
     desc "Remove 'node_modules' folder"
@@ -76,16 +41,12 @@ namespace :decidim do
   end
 end
 
-def enhance_assets_clean
-  # npm:install was added in Rails 5.1
-  Rake::Task["assets:clean"].enhance([]) do
-    Rake::Task["decidim:assets:rm_node_modules"].invoke
-  end
-end
-
 unless skip_webpacker_precompile
   if Rake::Task.task_defined?("assets:clean")
-    enhance_assets_clean
+    # npm:install was added in Rails 5.1
+    Rake::Task["assets:clean"].enhance([]) do
+      Rake::Task["decidim:assets:rm_node_modules"].invoke
+    end
   else
     Rake::Task.define_task("assets:clean" => "decidim:assets:rm_node_modules")
   end