michael 0.1.0

data/lib/michael/commands/repos/pull_requests.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require 'parallel'
+
+require_relative '../../command'
+require_relative '../../models/github/pull_request'
+require_relative '../../models/guard'
+require_relative '../../models/pull_request_formatter'
+require_relative '../../models/repository_formatter'
+require_relative '../../models/github/user'
+
+module Michael
+  module Commands
+    class Repos
+      class PullRequests < Models::Guard
+        def initialize(options)
+          super()
+
+          @prs = Michael::Models::Github::PullRequest.new
+          @user = Michael::Models::Github::User.new
+          @repos = repos_config.fetch(:repos)
+          abort 'No repositories configured' if @repos.nil? || @repos.empty?
+
+          @options = options
+        end
+
+        def execute(out: $stdout)
+          list = get_repos_with_spinner(out)
+
+          print_good_prs(out, repos_with_prs(list))
+          print_repos_w_no_prs(out, repos_no_prs(list)) if options[:show_empty]
+          print_broken_repos(out, list.select { |item| item[:state] == :failed })
+        end
+
+        private
+
+        attr_reader :prs, :options, :repos, :user
+
+        def get_repos_with_spinner(out)
+          progress = 0
+          spin = spinner(
+            "[:spinner] :progress/#{repos.length} processing...",
+            output: out
+          )
+
+          spin.update(progress: 0)
+
+          result = Parallel.map(repos, in_threads: 5) do |repo|
+            progress += 1
+            spin.update(progress: progress)
+            spin.spin
+            out = prs.process_repo(repo)
+            spin.spin
+            out
+          end
+
+          spin.stop('done')
+
+          result
+        end
+
+        def repos_no_prs(list_all)
+          list_all
+            .select { |item| item[:state] == :success && item[:prs].empty? }
+            .map { |item| item[:repo] }
+        end
+
+        def repos_with_prs(list)
+          list = needs_review(list) if options[:needs_review]
+          list = skip_self(list) if options[:skip_self]
+          list = hide_approved_or_commented(list) if options[:hide_approved]
+          list = actionable(list) if options[:actionable]
+          list = select_repos_w_prs(list)
+
+          list.map { |item| Michael::Models::RepositoryFormatter.new(item[:repo], item[:prs]).pretty }
+        end
+
+        def skip_self(list)
+          list.each do |item|
+            item[:prs] = item[:prs].reject { |pr| pr.author == user.username }
+          end
+        end
+
+        def hide_approved_or_commented(list)
+          list.each do |item|
+            item[:prs] = item[:prs].reject do |pr|
+              pr.reviews.all? { |review| review.approved? || review.commented? }
+            end
+          end
+        end
+
+        def select_repos_w_prs(list)
+          list.select { |item| item[:state] == :success && item[:prs].any? }
+        end
+
+        def needs_review(list)
+          list.each do |item|
+            item[:prs] = item[:prs].reject do |pr|
+              pr.reviews.any?
+            end
+          end
+        end
+
+        def actionable(list)
+          list.each do |item|
+            item[:prs] = item[:prs].reject do |pr|
+              reviewed = pr.reviews.any? { |review| review.author == user.username }
+              new_changes = pr.last_update_head?
+
+              reviewed && !new_changes
+            end
+          end
+        end
+
+        def print_good_prs(out, list)
+          out.puts "\n" + list.join("\n\n")
+        end
+
+        def print_repos_w_no_prs(out, list)
+          out.puts "\nRepos with no opened PRs: #{list.join(', ')}" if list.any?
+        end
+
+        def print_broken_repos(out, list)
+          return if list.empty?
+
+          list = list.map { |repo| pastel.on_red.black(repo[:repo]) }
+          out.puts "\nBad repos: #{list.join(', ')}"
+        end
+      end
+    end
+  end
+end

data/lib/michael/commands/repos.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'thor'
+
+module Michael
+  module Commands
+    class Repos < Thor
+      namespace :repos
+
+      desc 'edit', 'Edit list of repos to follow'
+      method_option :help, aliases: '-h', type: :boolean,
+                           desc: 'Display usage information'
+      def edit(*)
+        if options[:help]
+          invoke :help, ['edit']
+        else
+          require_relative 'repos/edit'
+          Michael::Commands::Repos::Edit.new(options).execute
+        end
+      end
+
+      desc 'prs', 'List open PRs'
+      method_option :help, aliases: '-h', type: :boolean,
+                           desc: 'Display usage information'
+      method_option :show_empty, aliases: '-e', type: :boolean,
+                                 desc: 'List watched repos that have no open PRs'
+      method_option :skip_self, aliases: '-s', type: :boolean,
+                                desc: 'Skip PRs created by the current user'
+      method_option :hide_approved, aliases: '-p', type: :boolean,
+                                    desc: 'Hide PRs that are approved and have'\
+                                          ' no requests for changes'
+      method_option :needs_review, aliases: '-n', type: :boolean,
+                                   desc: 'Show only ones which do not have any '\
+                                         'reviews yet'
+      method_option :actionable, aliases: '-t', type: :boolean,
+                                 desc: 'List only actionable PRs. These are '\
+      'PRs which you did not review yet, or ones which were updated after '\
+      'your review'
+      def prs(*)
+        if options[:help]
+          invoke :help, ['prs']
+        else
+          require_relative 'repos/pull_requests'
+          Michael::Commands::Repos::PullRequests.new(options).execute
+        end
+      end
+    end
+  end
+end

data/lib/michael/models/configuration.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+require 'tty-config'
+
+module Michael
+  module Models
+    class Configuration
+      CONFIG_ALLOWED_SYMBOLS = %i[set append fetch remove].freeze
+
+      def initialize(
+        config_dir: default_config_dir, config_name: default_filename
+      )
+        @config_dir = config_dir
+        @config_name = config_name
+        @config = create_config
+      end
+
+      def nuke
+        create_config.write(force: true)
+        self
+      end
+
+      def config_file_path
+        config_dir + '/' + config_name + '.yml'
+      end
+
+      def respond_to_missing?(symbol)
+        CONFIG_ALLOWED_SYMBOLS.include?(symbol)
+      end
+
+      def method_missing(symbol, *args)
+        return super unless CONFIG_ALLOWED_SYMBOLS.include?(symbol)
+
+        mkdir_once
+        config.read if config.exist?
+        resp = config.public_send(symbol, *args)
+        config.write(force: true)
+
+        resp
+      end
+
+      private
+
+      attr_reader :config_dir, :config_name, :config
+
+      def create_config
+        config = TTY::Config.new
+        config.filename = config_name
+        config.append_path(config_dir)
+
+        config
+      end
+
+      def default_config_dir
+        "#{ENV['HOME']}/.config/kudrykv/michael"
+      end
+
+      def default_filename
+        'config'
+      end
+
+      def mkdir_once
+        @mkdir_once ||= FileUtils.mkdir_p(config_dir)
+      end
+    end
+  end
+end

data/lib/michael/models/github/octokit_initializer.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'octokit'
+
+require_relative '../configuration'
+
+module Michael
+  module Models
+    module Github
+      class OctokitInitializer
+        attr_reader :octokit
+
+        def initialize
+          token = Configuration.new.fetch(:token)
+          @octokit = Octokit::Client.new(access_token: token)
+          @octokit.auto_paginate = true
+        end
+      end
+    end
+  end
+end

data/lib/michael/models/github/pr_wrapper.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require_relative 'reviewer'
+require_relative 'team'
+
+module Michael
+  module Models
+    module Github
+      class PRWrapper
+        attr_accessor :statuses, :reviews
+
+        def initialize(pull_request)
+          @pr = pull_request
+          @statuses = []
+          @reviews = []
+        end
+
+        def title
+          pr[:title]
+        end
+
+        def number
+          pr[:number]
+        end
+
+        def author
+          pr[:user][:login]
+        end
+
+        def head_sha
+          pr[:head][:sha]
+        end
+
+        def reviewed?
+          reviewers.any? || teams.any?
+        end
+
+        def reviewers
+          pr[:requested_reviewers].map { |reviewer| Reviewer.new(reviewer) }
+        end
+
+        def teams
+          pr[:requested_teams].map { |team| Team.new(team) }
+        end
+
+        def labels
+          pr[:labels].map { |label| label[:name] }
+        end
+
+        def requested_changes
+          reviews.select(&:changes_requested?).map(&:author)
+        end
+
+        def commented_on_pr
+          reviews
+            .reject { |review| author == review.author }
+            .select(&:commented?).map(&:author)
+        end
+
+        def last_update_head?
+          pr_last_update = pr[:updated_at]
+          review_last_update = pr.reviews&.map(&:submitted_at)&.sort&.pop
+
+          return false unless review_last_update
+
+          pr_last_update > review_last_update
+        end
+
+        def last_updated_at
+          updates = [pr[:updated_at]]
+
+          updates.concat pr.statuses.map(&:updated_at) unless pr.statuses.nil? || pr.statuses.any?
+          updates.concat pr.reviews.map(&:submitted_at) unless pr.reviews.nil? || pr.reviews.any?
+
+          updates.sort.pop
+        end
+
+        private
+
+        attr_reader :pr
+      end
+    end
+  end
+end

data/lib/michael/models/github/pull_request.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'octokit'
+
+require_relative 'octokit_initializer'
+require_relative 'pr_wrapper'
+require_relative 'review'
+require_relative 'status'
+
+module Michael
+  module Models
+    module Github
+      class PullRequest < OctokitInitializer
+        def process_repo(org_repo, hsh = {})
+          list = search(org_repo, hsh)
+
+          return {repo: org_repo, state: :failed} unless list
+
+          {repo: org_repo, state: :success, prs: list}
+        end
+
+        private
+
+        def search(org_repo, state: 'open', with_statuses: true, with_reviews: true)
+          octokit.pull_requests(org_repo, state: state).map do |pr|
+            pr = PRWrapper.new(pr)
+            pr.statuses = statuses(org_repo, pr.head_sha) if with_statuses
+            pr.reviews = reviews(org_repo, pr.number) if with_reviews
+
+            pr
+          end
+        rescue Octokit::InvalidRepository
+          false
+        end
+
+        def statuses(org_repo, ref)
+          combined = octokit.combined_status(org_repo, ref)
+          combined[:statuses]&.map { |status| Status.new(status) }
+        end
+
+        def reviews(org_repo, pr_number)
+          octokit
+            .pull_request_reviews(org_repo, pr_number)
+            .map { |review| Review.new(review) }
+            .group_by(&:author).to_a
+            .map { |_author, reviews| reviews.sort_by(&:submitted_at).pop }
+        end
+      end
+    end
+  end
+end

data/lib/michael/models/github/review.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Michael
+  module Models
+    module Github
+      class Review
+        def initialize(review)
+          @review = review
+        end
+
+        def author
+          review[:user][:login]
+        end
+
+        def state
+          review[:state].to_sym
+        end
+
+        def submitted_at
+          review[:submitted_at]
+        end
+
+        def approved?
+          state == :APPROVED
+        end
+
+        def changes_requested?
+          state == :CHANGES_REQUESTED
+        end
+
+        def commented?
+          state == :COMMENTED
+        end
+
+        private
+
+        attr_reader :review
+      end
+    end
+  end
+end

data/lib/michael/models/github/reviewer.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Michael
+  module Models
+    module Github
+      class Reviewer
+        def initialize(reviewer)
+          @reviewer = reviewer
+        end
+
+        private
+
+        attr_reader :reviewer
+      end
+    end
+  end
+end

data/lib/michael/models/github/status.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Michael
+  module Models
+    module Github
+      class Status
+        def initialize(status)
+          @status = status
+        end
+
+        def state
+          status[:state].to_sym
+        end
+
+        def updated_at
+          status[:updated_at]
+        end
+
+        private
+
+        attr_reader :status
+      end
+    end
+  end
+end

data/lib/michael/models/github/team.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Michael
+  module Models
+    module Github
+      class Team
+        def initialize(team)
+          @team = team
+        end
+
+        private
+
+        attr_reader :team
+      end
+    end
+  end
+end

data/lib/michael/models/github/token_validator.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'octokit'
+
+require_relative '../configuration'
+
+module Michael
+  module Models
+    module Github
+      class TokenValidator
+        class << self
+          def token_valid?(token)
+            scopes = Octokit::Client.new(access_token: token).scopes
+
+            return true if scopes.include?('repo')
+
+            puts 'Token should have `repo` scope'
+            false
+          rescue StandardError
+            false
+          end
+
+          def save_token(token)
+            Configuration.new.set(:token, value: token)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/michael/models/github/user.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative 'octokit_initializer'
+
+module Michael
+  module Models
+    module Github
+      class User < OctokitInitializer
+        def username
+          me[:login]
+        end
+
+        private
+
+        def me
+          @me ||= octokit.user
+        end
+      end
+    end
+  end
+end

data/lib/michael/models/guard.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative '../command'
+require_relative 'github/token_validator'
+
+module Michael
+  module Models
+    class Guard < Michael::Command
+      attr_reader :config, :repos_config
+
+      def initialize
+        @config = Configuration.new
+        @repos_config = Configuration.new(config_name: 'repositories')
+
+        token_valid = Github::TokenValidator.token_valid?(config.fetch(:token))
+        abort 'Your token is invalid' unless token_valid
+      end
+    end
+  end
+end

data/lib/michael/models/pull_request_formatter.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require 'pastel'
+require 'ruby-duration'
+
+module Michael
+  module Models
+    class PullRequestFormatter
+      class << self
+        def pretty(reponame, prs)
+          [
+            pastel.bold(reponame + ':'),
+            prs.map { |pr| PullRequestFormatter.new(pr).pretty }.join("\n")
+          ].join("\n")
+        end
+      end
+
+      def initialize(pr)
+        @pastel = Pastel.new
+        @pr = pr
+      end
+
+      def pretty
+        format(
+          '#%<number>s %<statuses>s %<reviews>s %<title>s %<variable>s',
+          number: pastel.bold(pr.number),
+          statuses: statuses_in_dots,
+          reviews: reviews_in_dots,
+          title: pr.title,
+          variable: variable_line
+        )
+      end
+
+      private
+
+      attr_reader :pastel, :pr
+
+      def statuses_in_dots
+        return '-' if pr.statuses.empty?
+
+        pr.statuses.map { |status| dot_status[status.state] }.join
+      end
+
+      def reviews_in_dots
+        return pastel.yellow('-') unless pr.reviewed? || pr.reviews.any?
+        return pastel.yellow('.') if pr.reviews.empty?
+
+        pr.reviews
+          .reject { |review| review.author == pr.author }
+          .map { |review| dot_status[review.state] }
+          .join
+      end
+
+      def variable_line
+        [
+          labels_stringified(pr.labels),
+          pastel.cyan(pr.author),
+          last_update,
+          who_req_changes_stringified,
+          who_commented_stringified,
+        ].reject(&:empty?).join(' ')
+      end
+
+      def labels_stringified(labels)
+        return '' if labels.empty?
+
+        pastel.bold.yellow("[#{labels.join(', ')}]")
+      end
+
+      def who_commented_stringified
+        names = pr.commented_on_pr
+        return '' if names.empty?
+
+        '| Commented: ' + names.join(', ')
+      end
+
+      def who_req_changes_stringified
+        names = pr.requested_changes
+        return '' if names.empty?
+
+        '| ' + pastel.bold('Requested changes: ') << names.map { |name| pastel.underscore(name) }.join(', ')
+      end
+
+      def last_update
+        time_diff = Duration.new(Time.now - pr.last_updated_at)
+        'last update ' + last_update_when(time_diff) + ' ago'
+      end
+
+      def last_update_when(duration)
+        if duration.weeks.positive?
+          pastel.yellow.bold("#{duration.weeks} week(s)")
+        elsif duration.days.positive?
+          pastel.yellow("#{duration.days} day(s)")
+        elsif duration.hours.positive?
+          "#{duration.hours} hour(s)"
+        elsif duration.minutes.positive?
+          "#{duration.minutes} minute(s)"
+        else
+          'seconds'
+        end
+      end
+
+      def dot_status
+        @dot_status ||= {
+          success: pastel.green('+'),
+          pending: pastel.yellow('.'),
+          error: pastel.red('x'),
+          failure: pastel.red('x'),
+          APPROVED: pastel.green('^'),
+          CHANGES_REQUESTED: pastel.red('X'),
+          COMMENTED: '?'
+        }
+      end
+    end
+  end
+end