pronto-github_resolver 0.0.2 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 152e4319e389105c14b8c208f8b668c17a25eafbab0f1270b00c071994f9320c
-  data.tar.gz: b7a1b40e35543a93e7924e82a7b3596e35ac9e416df34855939112e5222db953
+  metadata.gz: f182d2c36206cc761770cf1a135ac78f7a345eae10b756f45da8e0410c1d68db
+  data.tar.gz: cf595336d02afaa1bb68ea04495d10177f9b453a5b3139b96b1201f65b72a51a
 SHA512:
-  metadata.gz: 46e7f768e794754c2e2d1159779332f980408d77f5fe4c88f825ed63c27c85dad49318c66da9236ca05d133532de5c6d20a3d39df9c8bd68eef7141bf1763368
-  data.tar.gz: '0758a279f57ba8c0a153528f0b2b06ab3baee909e396e92c86845b86672f18d312ec41f9efbc574f45cf5aa1ec093f988ae728fd987a72e3d571b31f074d5201'
+  metadata.gz: f58dacfa4acdf9e686cdee8d5cd81d07fc072f8be3d54814730f7a26d766b36cd34f08f5af3564cdbdbea8a33918031c763f3cc73d219185191be7f0e113f835
+  data.tar.gz: 6148af0e0865e54b6757f130cbf5a2fc9456354bfa1b4b8bb01abb5de27826ec78246ccecd07633efcfb7294042ad7768a6ac92635693146f4f690afe7fbee09

data/.rubocop.yml

@@ -1,5 +1,11 @@
+require:
+ - rubocop-rake
+ - rubocop-rspec
+ - rubocop-performance
+
 AllCops:
   TargetRubyVersion: 2.6
+  NewCops: enable
 
 Style/StringLiterals:
   Enabled: true
@@ -11,3 +17,17 @@ Style/StringLiteralsInInterpolation:
 
 Layout/LineLength:
   Max: 120
+Metrics/CyclomaticComplexity:
+  Max: 8
+Metrics/AbcSize:
+  Max: 24
+
+Metrics/BlockLength:
+  Exclude:
+    - spec/**/*.rb
+Style/OpenStructUse:
+  Exclude:
+    - spec/**/*.rb
+RSpec/AnyInstance: { Enabled: false }
+RSpec/MultipleMemoizedHelpers:
+  Max: 7

data/Gemfile

@@ -10,3 +10,6 @@ gem "rake", "~> 13.0"
 gem "rspec", "~> 3.0"
 
 gem "rubocop", "~> 1.21"
+gem "rubocop-performance"
+gem "rubocop-rake"
+gem "rubocop-rspec"

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    pronto-github_resolver (0.0.2)
+    pronto-github_resolver (0.0.6)
       pronto (~> 0.11)
 
 GEM
@@ -84,6 +84,13 @@ GEM
       unicode-display_width (>= 1.4.0, < 3.0)
     rubocop-ast (1.13.0)
       parser (>= 3.0.1.1)
+    rubocop-performance (1.12.0)
+      rubocop (>= 1.7.0, < 2.0)
+      rubocop-ast (>= 0.4.0)
+    rubocop-rake (0.6.0)
+      rubocop (~> 1.0)
+    rubocop-rspec (2.6.0)
+      rubocop (~> 1.19)
     ruby-progressbar (1.11.0)
     ruby2_keywords (0.0.5)
     rugged (1.0.1)
@@ -103,6 +110,9 @@ DEPENDENCIES
   rake (~> 13.0)
   rspec (~> 3.0)
   rubocop (~> 1.21)
+  rubocop-performance
+  rubocop-rake
+  rubocop-rspec
 
 BUNDLED WITH
    2.2.31

data/README.md

@@ -1,28 +1,53 @@
 # Pronto::GithubResolver
+[![Gem Version](https://badge.fury.io/rb/pronto-github_resolver.svg)](https://badge.fury.io/rb/pronto-github_resolver)
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/pronto/github_resolver`. To experiment with that code, run `bin/console` for an interactive prompt.
-
-TODO: Delete this and the text above, and describe your gem
+Pronto formatter to resolve old pronto messages in pull requests.
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'pronto-github_resolver'
+gem 'pronto-github_resolver', require: false
 ```
 
 And then execute:
+```sh
+bundle install
+```
 
-    $ bundle install
+Use pronto's `github_pr_review` formatter in your CI, for example:
+```yml
+- name: Run pronto
+  run: bundle exec pronto run -f github_status github_pr_review
+  env:
+    PRONTO_GITHUB_ACCESS_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+    PRONTO_PULL_REQUEST_ID: ${{ github.event.pull_request.number }}
+    PRONTO_GITHUB_BOT_ID: 12345678 # replace with your bot user id
+```
 
-Or install it yourself as:
+## Usage
 
-    $ gem install pronto-github_resolver
+Pronto will pick up this from gemfile automatically.
 
-## Usage
+- When any of pronto runners emits message with level `:error` or `:fatal` - generated PR review will have resolution 'REQUEST_CHANGES', and default in other cases.
+- On each run comment threads where message is no longer generated will be marked as resolved.
+- Set ENV['PRONTO_GITHUB_BOT_ID'] to github id of your bot user (by default it's name `github-actions[bot]`, but id is different).
+  This enables posting PR 'APPROVE' review by bot after all messages are resolved.
+
+### Getting bot's id
+
+At the time of writing, github for unknown reason does not allow bots to get own id by calling `/user`.
+If you know how to do this without user's effort - please let me know in [issues](https://github.com/Vasfed/pronto-github_resolver/issues).
+
+You can look up bot's user id by doing
+
+```sh
+curl -u "your_user:your_token" https://api.github.com/repos/[organization]/[repo]/pulls/[pull_id]/reviews
+```
+on a pull request where the bot has posted a review.
 
-TODO: Write usage instructions here
+Personal Access Token is generated in [developer settings in your GitHub profile](https://github.com/settings/tokens).
 
 ## Development
 

data/lib/pronto/github_resolver/github_client_ext.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Pronto
+  # extend stock pronto github client wrapper
+  class Github < Pronto::Client
+    # original, but with event param
+    def publish_pull_request_comments(comments, event: nil)
+      comments_left = comments.clone
+      while comments_left.any?
+        comments_to_publish = comments_left.slice!(0, warnings_per_review)
+        create_pull_request_review(comments_to_publish, event: event)
+      end
+    end
+
+    # original, but with event param
+    def create_pull_request_review(comments, event: nil)
+      options = {
+        event: event || @config.github_review_type,
+        accept: "application/vnd.github.v3.diff+json", # https://developer.github.com/v3/pulls/reviews/#create-a-pull-request-review
+        comments: comments.map do |comment|
+          { path: comment.path, position: comment.position, body: comment.body }
+        end
+      }
+      client.create_pull_request_review(slug, pull_id, options)
+    end
+
+    def approve_pull_request(message = "")
+      client.create_pull_request_review(
+        slug, pull_id,
+        { event: "APPROVE", body: message, accept: "application/vnd.github.v3.diff+json" }
+      )
+    end
+
+    def existing_pull_request_reviews
+      client.pull_request_reviews(slug, pull_id)
+    end
+
+    GET_REVIEW_THREADS_QUERY = <<~GQL
+      query getReviewThreadIds($owner: String!, $name: String!, $pull_num: Int!) {
+        repository(owner: $owner, name: $name) {
+          pullRequest: issueOrPullRequest(number: $pull_num) {
+            ... on PullRequest {
+              reviewThreads(last:100) {
+                  totalCount
+                  nodes {
+                      id
+                      comments(last: 10) {
+                          nodes {
+                              viewerDidAuthor
+                              path position body
+                          }
+                      }
+                  }
+              }
+            }
+          }
+        }
+      }
+    GQL
+
+    def fetch_review_threads # rubocop:disable Metrics/MethodLength
+      owner, repo_name = slug.split("/")
+      res = client.post :graphql, {
+        query: GET_REVIEW_THREADS_QUERY,
+        variables: { owner: owner, name: repo_name, pull_num: pull_id }
+      }.to_json
+
+      return [] if res.errors || !res.data # TODO: handle errors
+
+      res.data.repository.pullRequest.reviewThreads.nodes.to_h do |node|
+        [
+          node.id,
+          node.comments.nodes.map do |comment|
+            { authored: comment.viewerDidAuthor, path: comment.path, position: comment.position, body: comment.body }
+          end
+        ]
+      end
+    end
+
+    def resolve_review_threads(node_ids)
+      return unless node_ids.any?
+
+      query = <<~GQL
+        mutation {
+          #{node_ids.each_with_index.map do |id, index|
+              "q#{index}: resolveReviewThread(input: { threadId: \"#{id}\" }){ thread { id } } "
+            end.join("\n")}
+        }
+      GQL
+      client.post :graphql, { query: query }.to_json
+    end
+  end
+end

data/lib/pronto/github_resolver/version.rb

@@ -2,6 +2,6 @@
 
 module Pronto
   module GithubResolver
-    VERSION = "0.0.2"
+    VERSION = "0.0.6"
   end
 end

data/lib/pronto/github_resolver.rb

@@ -1,197 +1,77 @@
 # frozen_string_literal: true
 
+require "pronto"
 require_relative "github_resolver/version"
-require 'pronto'
+require_relative "github_resolver/github_client_ext"
 
 module Pronto
-
-  class Github < Client
-    # pronto messes up relative paths and does not have tests for this, patch to add repo.path.join
-    def pull_comments(sha)
-      @comment_cache["#{pull_id}/#{sha}"] ||= begin
-        client.pull_comments(slug, pull_id).map do |comment|
-          Comment.new(sha, comment.body, @repo.path.join(comment.path),
-                      comment.position || comment.original_position)
-        end
-      end
-    rescue Octokit::NotFound => e
-      @config.logger.log("Error raised and rescued: #{e}")
-      msg = "Pull request for sha #{sha} with id #{pull_id} was not found."
-      raise Pronto::Error, msg
-    end
-
-    def publish_pull_request_comments(comments, event: nil)
-      comments_left = comments.clone
-      while comments_left.any?
-        comments_to_publish = comments_left.slice!(0, warnings_per_review)
-        create_pull_request_review(comments_to_publish, event: event)
-      end
-    end
-
-    def create_pull_request_review(comments, event: nil)
-      options = {
-        event: event || @config.github_review_type,
-        accept: 'application/vnd.github.v3.diff+json', # https://developer.github.com/v3/pulls/reviews/#create-a-pull-request-review
-        comments: comments.map do |comment|
-          {
-            path:     comment.path,
-            position: comment.position,
-            body:     comment.body
-          }
-        end
-      }
-      client.create_pull_request_review(slug, pull_id, options)
-    end
-
-    def approve_pull_request(message=nil)
-      client.create_pull_request_review(slug, pull_id, {
-        event: 'APPROVE', body: message, accept: 'application/vnd.github.v3.diff+json'
-      })
-    end
-
-    def existing_pull_request_reviews
-      client.pull_request_reviews(slug, pull_id)
-    end
-
-    def bot_user_id
-      bot_user.id
-    end
-
-    def bot_user
-      @bot_user ||= client.user
-    end
-
-    def get_review_threads
-      owner, repo_name = (slug || "").split('/')
-      res = client.post :graphql, { query: <<~GQL }.to_json
-        query getUserId {
-          repository(owner: "#{owner}", name: "#{repo_name}") {
-            pullRequest: issueOrPullRequest(number: #{pull_id}) {
-              ... on PullRequest {
-                reviewThreads(last:100) {
-                    totalCount
-                    nodes {
-                        id
-                        comments(last: 10) {
-                            nodes {
-                                author { ... on Node { id } }
-                                viewerDidAuthor
-                                path position body
-                            }
-                        }
-                    }
-                }
-              }
-            }
-          }
-        }
-      GQL
-
-      if res.errors || !res.data
-        # ex: [{:message=>"Parse error on \"11\" (INT) at [1, 22]", :locations=>[{:line=>1, :column=>22}]}]
-        # TODO: handle errors
-        return []
-      end
-
-      res.data.repository.pullRequest.reviewThreads.nodes.to_h { |node|
-        [
-          node.id,
-          node.comments.nodes.map{ |comment|
-            {
-              author_id: comment.author.id,
-              path: comment.path, position: comment.position, body: comment.body
-            }
-          }
-        ]
-      }
-    end
-
-    def resolve_review_threads(node_ids)
-      return unless node_ids.any?
-
-      owner, repo_name = (slug || "").split('/')
-      query = <<~GQL
-        mutation {
-          #{
-            node_ids.each_with_index.map {|id, index|
-              "q#{index}: resolveReviewThread(input: { threadId: \"#{id}\" }){ thread { id } } "
-            }.join("\n")
-          }
-        }
-      GQL
-      client.post :graphql, { query: query }.to_json
-    end
-  end
-
   module Formatter
+    # monkey-patch stock formatter with altered behavior
     module GithubResolving
+      # TODO: we can reuse some threads from graphql for existing messages detection (but there's no pagination)
       def format(messages, repo, patches)
         client = client_module.new(repo)
         existing = existing_comments(messages, client, repo)
         comments = new_comments(messages, patches)
         additions = remove_duplicate_comments(existing, comments)
 
-        # TODO: we can reuse some threads from graphql for existing messages detection (but there's no pagination)
-        resolve_old_messages(client, repo, comments)
+        resolve_old_messages(client, comments)
+        submit_review(comments, messages, client, additions)
 
-        if comments.none?
-          bot_reviews = client.existing_pull_request_reviews.select { |review| review.user.type == 'Bot' }
-          if bot_reviews.any?
-            bot_id = client.bot_user_id
-            current_bot_review_status = bot_reviews.inject(nil) do |prev_status, review|
-              next prev_status unless review.user.id == bot_id
+        "#{additions.count} Pronto messages posted to #{pretty_name}"
+      end
 
-              case review.state
-              when 'CHANGES_REQUESTED' then review.state
-              when 'APPROVED' then nil
-              else
-                prev_status
-              end
-            end
+      def submit_review(comments, messages, client, additions)
+        return post_approve_if_needed(client) if comments.none?
+
+        request_changes_at = %i[error fatal].freeze
+        request_changes = messages.any? { |message| request_changes_at.include?(message.level) } && "REQUEST_CHANGES"
+        submit_comments(client, additions, event: request_changes || nil)
+      end
+
+      def post_approve_if_needed(client)
+        bot_reviews = client.existing_pull_request_reviews.select { |review| review.user.type == "Bot" }
+        return if bot_reviews.none?
 
-            client.approve_pull_request if current_bot_review_status == 'CHANGES_REQUESTED'
+        current_bot_review_status = bot_reviews.inject(nil) do |prev_status, review|
+          if review_by_this_bot?(review)
+            next review.state if review.state == "CHANGES_REQUESTED"
+            next nil if review.state == "APPROVED"
           end
-        else
-          submit_comments(
-            client, additions,
-            event: messages.any? { |message| %i[error fatal].include?(message.level) } && 'REQUEST_CHANGES' || nil
-          )
+          prev_status
         end
 
-        "#{additions.count} Pronto messages posted to #{pretty_name}"
+        client.approve_pull_request if current_bot_review_status == "CHANGES_REQUESTED"
+      end
+
+      def review_by_this_bot?(review)
+        ENV["PRONTO_GITHUB_BOT_ID"] && review.user.id == ENV["PRONTO_GITHUB_BOT_ID"].to_i
       end
 
+      # copied from upstream, added event param
       def submit_comments(client, comments, event: nil)
         client.publish_pull_request_comments(comments, event: event)
       rescue Octokit::UnprocessableEntity, HTTParty::Error => e
-        $stderr.puts "Failed to post: #{e.message}"
+        $stderr.puts "Failed to post: #{e.message}" # rubocop:disable Style/StderrPuts like in upstream
       end
 
-      def resolve_old_messages(client, repo, actual_comments)
-        thread_ids_to_resolve = []
-        bot_node_id = client.bot_user.node_id
-        client.get_review_threads.each_pair do |thread_id, thread_comments|
-          next unless thread_comments.all? do |comment|
-            comment[:author_id] == bot_node_id &&
-              (actual_comments[[repo.path.join(comment[:path]), comment[:position]]] || []).none? { |actual_comment|
+      def resolve_old_messages(client, actual_comments)
+        thread_ids_to_resolve = client.fetch_review_threads.select do |_thread_id, thread_comments|
+          thread_comments.all? do |comment|
+            comment[:authored] &&
+              (actual_comments[[comment[:path], comment[:position]]] || []).none? do |actual_comment|
                 comment[:body].include?(actual_comment.body)
-              }
+              end
           end
-          thread_ids_to_resolve << thread_id
-        end
+        end.keys
         client.resolve_review_threads(thread_ids_to_resolve)
       end
     end
-
-    class GithubPullRequestResolvingReviewFormatter < PullRequestFormatter
-      prepend GithubResolving
-    end
-
-    Pronto::Formatter::GithubPullRequestReviewFormatter.prepend(GithubResolving)
   end
 end
 
-module Pronto
-  module GithubResolver
-  end
-end
+# if pronto did not have formatters array frozen - instead of monkeypatch we might have
+# class GithubPullRequestResolvingReviewFormatter < PullRequestFormatter
+#   prepend GithubResolving
+# end
+Pronto::Formatter::GithubPullRequestReviewFormatter.prepend(Pronto::Formatter::GithubResolving)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pronto-github_resolver
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.6
 platform: ruby
 authors:
 - Vasily Fedoseyev
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-12-14 00:00:00.000000000 Z
+date: 2021-12-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pronto
@@ -41,6 +41,7 @@ files:
 - bin/console
 - bin/setup
 - lib/pronto/github_resolver.rb
+- lib/pronto/github_resolver/github_client_ext.rb
 - lib/pronto/github_resolver/version.rb
 - pronto-github_resolver.gemspec
 homepage: https://github.com/Vasfed/pronto-github_resolver