nya_pr 0.1.0

data/lib/nya_pr/pull_request/csv_store.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module NyaPr
+  module PullRequest
+    class CsvStore
+      HEADERS = %w[
+        repository
+        number
+        title
+        author
+        draft
+        created_at
+        updated_at
+        html_url
+      ].freeze
+
+      attr_reader :path
+
+      def initialize(path)
+        @path = path
+      end
+
+      def write(pull_requests)
+        CSV.open(path, 'w', write_headers: true, headers: HEADERS) do |csv|
+          pull_requests.each do |pull_request|
+            csv << HEADERS.map { |header| pull_request[header] }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nya_pr/pull_request/finder.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module NyaPr
+  module PullRequest
+    class Finder
+      include NyaPr::Request
+
+      MAX_PULL_REQUESTS = 100
+      MAX_PER_PAGE = 100
+
+      attr_reader :client,
+                  :repositories,
+                  :limit,
+                  :progress_enabled
+
+      def initialize(
+        client,
+        repositories,
+        limit: MAX_PULL_REQUESTS,
+        progress_enabled: true
+      )
+        @client = client
+        @repositories = repositories
+        @limit = limit
+        @progress_enabled = progress_enabled
+      end
+
+      def find
+        NyaPr.logger.info(
+          "Searching for up to #{limit} open pull requests " \
+          "in #{repositories.size} repositories"
+        )
+
+        progress_bar = build_progress
+        pull_requests = collect_pull_requests(progress_bar)
+
+        progress_bar.finish
+
+        NyaPr.logger.info(
+          "Finished searching for pull requests: found #{pull_requests.size}"
+        )
+
+        pull_requests
+      end
+
+      private
+
+      def collect_pull_requests(progress_bar)
+        pull_requests = []
+
+        repositories.each do |repository|
+          break if pull_requests.size >= limit
+
+          begin
+            next unless repository.fetch('has_pull_requests', true)
+
+            remaining = limit - pull_requests.size
+
+            pull_requests.concat(
+              pull_requests_for(repository, remaining)
+            )
+          ensure
+            progress_bar.advance
+          end
+        end
+
+        pull_requests
+      end
+
+      def pull_requests_for(repository, remaining)
+        NyaPr.logger.debug(
+          "Checking pull requests in #{repository.fetch('full_name')}"
+        )
+
+        pull_requests = []
+        page = 1
+
+        loop do
+          per_page = page_size(remaining, pull_requests.size)
+          batch = get_batch(repository, per_page, page)
+
+          break if batch.empty?
+
+          pull_requests.concat(
+            batch.map do |pull_request|
+              normalize(repository, pull_request)
+            end
+          )
+
+          break if batch.size < per_page
+          break if pull_requests.size >= remaining
+
+          page += 1
+        end
+
+        pull_requests
+      end
+
+      def page_size(remaining, collected)
+        [remaining - collected, MAX_PER_PAGE].min
+      end
+
+      def get_batch(repository, per_page, page)
+        get(
+          "/repos/#{repository.fetch('full_name')}/pulls",
+          state: 'open',
+          sort: 'updated',
+          direction: 'desc',
+          per_page: per_page,
+          page: page
+        )
+      end
+
+      def build_progress
+        Progress.new(
+          '🐾 Checking pull requests',
+          total: repositories.size,
+          enabled: progress_enabled && $stderr.tty?
+        )
+      end
+
+      def normalize(repository, pull_request)
+        {
+          'repository' => repository.fetch('full_name'),
+          'number' => pull_request.fetch('number'),
+          'title' => pull_request.fetch('title'),
+          'author' => pull_request.dig('user', 'login'),
+          'draft' => pull_request.fetch('draft', false),
+          'created_at' => pull_request['created_at'],
+          'updated_at' => pull_request['updated_at'],
+          'html_url' => pull_request.fetch('html_url')
+        }
+      end
+    end
+  end
+end

data/lib/nya_pr/pull_request/printer.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module NyaPr
+  module PullRequest
+    class Printer
+      def print(pull_requests)
+        grouped_pull_requests(pull_requests).each do |repository, repository_pull_requests|
+          print_repository(repository, repository_pull_requests)
+        end
+      end
+
+      private
+
+      def grouped_pull_requests(pull_requests)
+        pull_requests.group_by do |pull_request|
+          pull_request['repository']
+        end
+      end
+
+      def print_repository(repository, pull_requests)
+        puts
+        puts repository
+        puts '-' * repository.length
+
+        pull_requests.each do |pull_request|
+          puts format_pull_request(pull_request)
+          puts
+        end
+      end
+
+      def format_pull_request(pull_request)
+        draft = pull_request['draft'] ? ' [DRAFT]' : ''
+
+        <<~OUTPUT.chomp
+          ##{pull_request['number']}#{draft} #{pull_request['title']}
+            Author: @#{pull_request['author']}
+            #{pull_request['html_url']}
+        OUTPUT
+      end
+    end
+  end
+end

data/lib/nya_pr/repository/collector.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module NyaPr
+  module Repository
+    class Collector
+      attr_reader :client, :username, :owners, :store, :options
+
+      def initialize(client, username, owners, store, **options)
+        @client = client
+        @username = username
+        @owners = owners
+        @store = store
+        @options = options
+      end
+
+      def collect
+        return load_cached if use_cache?
+
+        discover
+      end
+
+      private
+
+      def load_cached
+        NyaPr.logger.info("Loading repositories from #{store.path}")
+
+        reject_archived(store.read).tap do |repositories|
+          NyaPr.logger.info(
+            "Loaded #{repositories.size} repositories from cache"
+          )
+        end
+      end
+
+      def discover
+        NyaPr.logger.info(
+          'Repository cache unavailable or refresh requested'
+        )
+
+        repositories = Finder.
+                       new(client, username).
+                       repositories_for(owners)
+
+        repositories = filter_contributed(reject_archived(repositories))
+
+        store.write(repositories)
+
+        NyaPr.logger.info(
+          "Saved #{repositories.size} repositories to #{store.path}"
+        )
+
+        repositories
+      end
+
+      def filter_contributed(repositories)
+        own, external = repositories.partition do |repository|
+          repository_owner(repository).casecmp?(username)
+        end
+
+        own + Filter.new(client, username, progress_enabled: options[:progress]).contributed(external)
+      end
+
+      def reject_archived(repositories)
+        return repositories unless options[:skip_archived]
+
+        filtered = repositories.reject do |repository|
+          repository['archived']
+        end
+
+        NyaPr.logger.info(
+          "Skipped #{repositories.size - filtered.size} archived repositories"
+        )
+
+        filtered
+      end
+
+      def repository_owner(repository)
+        repository.dig('owner', 'login').to_s
+      end
+
+      def use_cache?
+        store.available? && !options[:refresh]
+      end
+    end
+  end
+end

data/lib/nya_pr/repository/csv_store.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module NyaPr
+  module Repository
+    class CsvStore
+      HEADERS = %w[
+        full_name
+        html_url
+        visibility
+        private
+        archived
+        has_pull_requests
+      ].freeze
+
+      attr_reader :path
+
+      def initialize(path)
+        @path = path
+      end
+
+      def available?
+        return false unless File.file?(path)
+
+        CSV.open(path, headers: true) { |csv| !csv.first.nil? }
+      end
+
+      def read
+        CSV.read(path, headers: true).map do |row|
+          {
+            'full_name' => row['full_name'],
+            'html_url' => row['html_url'],
+            'visibility' => row['visibility'],
+            'private' => row['private'] == 'true',
+            'archived' => row['archived'] == 'true',
+            'has_pull_requests' => row['has_pull_requests'] != 'false'
+          }
+        end
+      end
+
+      def write(repositories)
+        CSV.open(path, 'w', write_headers: true, headers: HEADERS) do |csv|
+          repositories.each do |repository|
+            csv << HEADERS.map { |header| repository[header] }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nya_pr/repository/filter.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module NyaPr
+  module Repository
+    class Filter
+      include NyaPr::Request
+
+      DEFAULT_WORKERS = 10
+
+      attr_reader :client, :username, :workers, :progress_enabled
+
+      def initialize(client, username, workers: DEFAULT_WORKERS, progress_enabled: true)
+        @client = client
+        @username = username
+        @workers = workers
+        @progress_enabled = progress_enabled
+      end
+
+      def contributed(repositories)
+        log_start(repositories)
+
+        progress_bar = build_progress(repositories)
+        result = process_repositories(repositories, progress_bar)
+
+        progress_bar.finish
+
+        log_result(result)
+        result
+      end
+
+      private
+
+      def log_start(repositories)
+        NyaPr.logger.info(
+          "Checking contributions in #{repositories.size} repositories " \
+          "using #{workers} workers"
+        )
+      end
+
+      def build_progress(repositories)
+        Progress.new(
+          '🐈 Checking repositories',
+          total: repositories.size,
+          enabled: progress_enabled && $stderr.tty?
+        )
+      end
+
+      def process_repositories(repositories, progress_bar)
+        queue = build_queue(repositories)
+        result = Array.new(repositories.size)
+
+        build_workers(queue, result, progress_bar).
+          each(&:value)
+
+        result.compact
+      end
+
+      def build_workers(queue, result, progress_bar)
+        Array.new(workers) do
+          Thread.new do
+            process_queue(queue, result, progress_bar)
+          end
+        end
+      end
+
+      def log_result(result)
+        NyaPr.logger.info(
+          "Finished contribution check: #{result.size} repositories matched"
+        )
+      end
+
+      def build_queue(repositories)
+        Queue.new.tap do |queue|
+          repositories.each_with_index do |repository, index|
+            queue << [index, repository]
+          end
+        end
+      end
+
+      def process_queue(queue, result, progress_bar)
+        loop do
+          index, repository = queue.pop(true)
+
+          if contributed_to?(repository)
+            result[index] = repository
+
+            NyaPr.logger.debug(
+              "Found contributions in #{repository.fetch('full_name')}"
+            )
+          end
+
+          progress_bar.advance
+        rescue ThreadError
+          break
+        end
+      end
+
+      def contributed_to?(repository)
+        commits = get(
+          "/repos/#{repository.fetch('full_name')}/commits",
+          author: username,
+          per_page: 1
+        )
+
+        commits.any?
+      rescue NyaPr::Error => e
+        raise unless e.status == 409
+
+        NyaPr.logger.debug(
+          "Skipping empty repository #{repository.fetch('full_name')}"
+        )
+
+        false
+      end
+    end
+  end
+end

data/lib/nya_pr/repository/finder.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module NyaPr
+  module Repository
+    class Finder
+      include NyaPr::Request
+
+      attr_reader :client, :username
+
+      def initialize(client, username)
+        @client = client
+        @username = username
+      end
+
+      def repositories_for(owners)
+        owners = Array(owners)
+
+        NyaPr.logger.info(
+          "Starting repository collection for #{owners.size} owners"
+        )
+
+        repositories = owners.flat_map do |owner|
+          collect_repositories_for(owner)
+        end
+
+        NyaPr.logger.info(
+          "Finished repository collection: #{repositories.size} repositories found"
+        )
+
+        repositories
+      end
+
+      private
+
+      def collect_repositories_for(owner)
+        NyaPr.logger.info("Collecting repositories for #{owner}")
+
+        repositories_for_owner(owner).tap do |repositories|
+          NyaPr.logger.info(
+            "Collected #{repositories.size} repositories for #{owner}"
+          )
+        end
+      end
+
+      def repositories_for_owner(owner)
+        return own_repositories if owner.casecmp?(username)
+
+        type = owner_type(owner)
+
+        NyaPr.logger.debug("#{owner} is a GitHub #{type}")
+
+        case type
+        when 'Organization'
+          organization_repositories(owner)
+        when 'User'
+          user_repositories(owner)
+        else
+          raise NyaPr::Error, "Unsupported GitHub owner type: #{owner}"
+        end
+      end
+
+      def owner_type(owner)
+        get("/users/#{owner}").fetch('type')
+      end
+
+      def own_repositories
+        paginate(
+          '/user/repos',
+          affiliation: 'owner',
+          visibility: 'all'
+        )
+      end
+
+      def organization_repositories(owner)
+        paginate(
+          "/orgs/#{owner}/repos",
+          type: 'all'
+        )
+      end
+
+      def user_repositories(owner)
+        paginate(
+          "/users/#{owner}/repos",
+          type: 'owner'
+        )
+      end
+    end
+  end
+end

data/lib/nya_pr/request.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require 'oj'
+
+module NyaPr
+  module Request
+    include NyaPr::Connection
+
+    MAX_PAGES = 1_000
+    PER_PAGE = 100
+
+    def get(path, params = {})
+      _response, body = do_get(path, params)
+
+      body
+    end
+
+    def paginate(path, params = {})
+      params = params.merge(per_page: params.fetch(:per_page, PER_PAGE))
+
+      page = 1
+      result = []
+
+      loop do
+        raise NyaPr::Error, 'Pagination limit exceeded' if page > MAX_PAGES
+
+        NyaPr.logger.debug("Fetching page #{page} for #{path}")
+        response, body = do_get(path, params.merge(page: page))
+
+        raise NyaPr::Error, 'Expected paginated response to be an array' unless body.is_a?(Array)
+
+        result.concat(body)
+
+        break if body.empty?
+        break unless next_page?(response)
+
+        page += 1
+      end
+
+      result
+    end
+
+    private
+
+    def do_get(path, params = {})
+      prepared_path = prepare(path)
+
+      NyaPr.logger.debug("GET #{prepared_path} #{params.inspect}")
+
+      response = connection(client).get(prepared_path, params)
+      body = parse_body(response)
+
+      NyaPr.logger.debug(
+        "GET #{prepared_path} -> HTTP #{response.status}"
+      )
+
+      raise_on_error!(response, body, prepared_path)
+
+      [response, body]
+    end
+
+    def parse_body(response)
+      return nil if response.body.nil? || response.body.empty?
+
+      Oj.load(response.body)
+    rescue Oj::ParseError
+      raise NyaPr::Error, "Failed to parse response: #{response.body}"
+    end
+
+    def raise_on_error!(response, body, path)
+      return if response.success?
+
+      message =
+        if body.is_a?(Hash)
+          body['message'] || body
+        else
+          body
+        end
+
+      raise NyaPr::Error.new(
+        "GET #{path}: GitHub API error #{response.status}: #{message}",
+        status: response.status
+      )
+    end
+
+    def next_page?(response)
+      response.headers['link']&.include?('rel="next"')
+    end
+
+    def prepare(path)
+      path.
+        delete_prefix('/').
+        gsub(%r{//}, '/').
+        gsub(%r{/+\z}, '')
+    end
+  end
+end