Merge pull request #16 from joshdholtz/feature/github-api-rate-limiter

Add GitHub API rate limiter with search API support

Author: joshdholtz

bin/wassup

@@ -6,7 +6,7 @@ debug = ARGV.delete("--debug")
 path = ARGV[0] || 'Supfile'
 port = ARGV[1] || 0
 
-unless File.exists?(path)
+unless File.exist?(path)
   raise "Missing file: #{path}"
 end
 

examples/github_api_demo.rb

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/wassup/helpers/github'
+
+# Example demonstrating how to use the new GitHub API method
+# to replace manual RestClient requests with rate-limited API calls
+
+# Instead of manual RestClient calls like:
+# resp = RestClient::Request.execute(
+#   method: :get, 
+#   url: "https://api.github.com/repos/owner/repo/pulls/123", 
+#   user: ENV["WASSUP_GITHUB_USERNAME"],
+#   password: ENV["WASSUP_GITHUB_ACCESS_TOKEN"]
+# )
+# pr = JSON.parse(resp)
+
+# Use the new GitHub API method:
+org = "your-org"
+repo = "your-repo"
+pr_number = 123
+
+# Get PR data
+pr = Wassup::Helpers::GitHub.api(path: "/repos/#{org}/#{repo}/pulls/#{pr_number}")
+
+puts "PR: #{pr['title']}"
+puts "Draft: #{pr['draft']}"
+puts "Requested reviewers: #{pr['requested_reviewers'].size}"
+puts "Requested teams: #{pr['requested_teams'].size}"
+
+# Get PR reviews
+reviews = Wassup::Helpers::GitHub.api(path: "/repos/#{org}/#{repo}/pulls/#{pr_number}/reviews")
+
+# Filter out your own reviews
+reviews = reviews.select { |review| review["user"]["login"] != "your-username" }
+
+approved = reviews.count { |review| review["state"] == "APPROVED" }
+changes_requested = reviews.count { |review| review["state"] == "CHANGES_REQUESTED" }
+
+puts "Approved: #{approved}"
+puts "Changes requested: #{changes_requested}"
+
+# Get check runs for the PR's head commit
+head_sha = pr["head"]["sha"]
+check_runs = Wassup::Helpers::GitHub.api(path: "/repos/#{org}/#{repo}/commits/#{head_sha}/check-runs")
+
+puts "Check runs: #{check_runs['check_runs'].size}"
+
+# Get commit statuses
+statuses = Wassup::Helpers::GitHub.api(path: "/repos/#{org}/#{repo}/commits/#{head_sha}/statuses")
+
+puts "Statuses: #{statuses.size}"
+
+# Count different status types
+success_count = statuses.count { |status| status["state"] == "success" }
+failure_count = statuses.count { |status| status["state"] == "failure" }
+
+puts "Success: #{success_count}, Failures: #{failure_count}"
+
+# Example with query parameters
+# Get PRs with specific state
+open_prs = Wassup::Helpers::GitHub.api(
+  path: "/repos/#{org}/#{repo}/pulls", 
+  params: { state: "open", per_page: 10 }
+)
+
+puts "Open PRs: #{open_prs.size}"
+
+# Example with POST request (creating an issue comment)
+# comment_body = { body: "This is a test comment" }
+# new_comment = Wassup::Helpers::GitHub.api(
+#   path: "/repos/#{org}/#{repo}/issues/#{pr_number}/comments",
+#   method: :post,
+#   body: comment_body
+# )

examples/rate_limiter_demo.rb

@@ -0,0 +1,68 @@
+#!/usr/bin/env ruby
+# Demo script to show how the rate limiter handles burst requests
+
+require_relative '../lib/wassup/helpers/github_rate_limiter'
+
+# Mock the RestClient for demo purposes
+class MockRestClient
+  def self.execute(**args)
+    # Simulate API response time
+    sleep(0.05)
+    
+    # Create a mock response with rate limit headers
+    response = OpenStruct.new(
+      body: '{"items": []}',
+      headers: {
+        x_ratelimit_remaining: rand(100..4999),
+        x_ratelimit_reset: (Time.now + 3600).to_i,
+        x_ratelimit_limit: 5000
+      }
+    )
+    
+    puts "Request processed: #{args[:url]} (remaining: #{response.headers[:x_ratelimit_remaining]})"
+    response.body
+  end
+end
+
+# Replace RestClient with our mock
+module RestClient
+  Request = MockRestClient
+end
+
+# Test burst handling
+puts "Testing Rate Limiter with Burst Requests"
+puts "=" * 50
+
+rate_limiter = Wassup::Helpers::GitHub::RateLimiter.instance
+
+# Send 20 requests simultaneously
+puts "\nSending 20 requests simultaneously..."
+start_time = Time.now
+
+threads = []
+20.times do |i|
+  threads << Thread.new do
+    begin
+      rate_limiter.execute_request(
+        method: :get,
+        url: "https://api.github.com/test/#{i}"
+      )
+      puts "Request #{i+1} completed"
+    rescue => e
+      puts "Request #{i+1} failed: #{e.message}"
+    end
+  end
+end
+
+# Wait for all requests to complete
+threads.each(&:join)
+
+end_time = Time.now
+puts "\nAll requests completed in #{(end_time - start_time).round(2)} seconds"
+
+# Show final status
+puts "\nFinal Rate Limiter Status:"
+puts rate_limiter.status
+
+# Cleanup
+rate_limiter.stop_worker

lib/wassup/helpers/github.rb

@@ -3,6 +3,7 @@ module Helpers
     module GitHub
       require 'json'
       require 'rest-client'
+      require_relative 'github_rate_limiter'
 
       # https://docs.github.com/en/search-github/searching-on-github/searching-issues-and-pull-requests
       def self.issues(org:, repo:nil, q: nil)
@@ -22,12 +23,9 @@ def self.issues(org:, repo:nil, q: nil)
 
         items = []
 
-        resp = RestClient::Request.execute(
+        resp = RateLimiter.execute_request(
           method: :get, 
-          url: "https://api.github.com/search/issues?q=#{q}", 
-          user: ENV["WASSUP_GITHUB_USERNAME"],
-          password: ENV["WASSUP_GITHUB_ACCESS_TOKEN"],
-          headers: { "Accept": "application/vnd.github.v3+json", "Content-Type": "application/json" },
+          url: "https://api.github.com/search/issues?q=#{q}"
         )
         partial_items = JSON.parse(resp)["items"]
         items += partial_items
@@ -36,11 +34,9 @@ def self.issues(org:, repo:nil, q: nil)
       end
 
       def self.repos(org:)
-        resp = RestClient::Request.execute(
+        resp = RateLimiter.execute_request(
           method: :get, 
-          url: "https://api.github.com/orgs/#{org}/repos", 
-          user: ENV["WASSUP_GITHUB_USERNAME"],
-          password: ENV["WASSUP_GITHUB_ACCESS_TOKEN"]
+          url: "https://api.github.com/orgs/#{org}/repos"
         )
         return JSON.parse(resp)
       end
@@ -57,27 +53,56 @@ def self.pull_requests(org:, repo: nil)
         end
 
         return repos.map do |repo|
-          resp = RestClient::Request.execute(
+          resp = RateLimiter.execute_request(
             method: :get, 
-            url: "https://api.github.com/repos/#{repo.org}/#{repo.repo}/pulls?per_page=100", 
-            user: ENV["WASSUP_GITHUB_USERNAME"],
-            password: ENV["WASSUP_GITHUB_ACCESS_TOKEN"]
+            url: "https://api.github.com/repos/#{repo.org}/#{repo.repo}/pulls?per_page=100"
           )
 
           JSON.parse(resp)
         end.flatten(1)
       end
 
       def self.releases(org:, repo:)
-        resp = RestClient::Request.execute(
+        resp = RateLimiter.execute_request(
           method: :get, 
-          url: "https://api.github.com/repos/#{org}/#{repo}/releases", 
-          user: ENV["WASSUP_GITHUB_USERNAME"],
-          password: ENV["WASSUP_GITHUB_ACCESS_TOKEN"]
+          url: "https://api.github.com/repos/#{org}/#{repo}/releases"
         )
 
         return JSON.parse(resp)
       end
+
+      # Generic GitHub API method for any endpoint
+      def self.api(path:, method: :get, params: {}, body: nil)
+        # Handle full URLs or relative paths
+        if path.start_with?('http')
+          url = path
+        else
+          # Ensure path starts with /
+          path = "/#{path}" unless path.start_with?('/')
+          url = "https://api.github.com#{path}"
+        end
+        
+        # Add query parameters if provided
+        if params.any?
+          query_string = params.map { |k, v| "#{k}=#{v}" }.join('&')
+          url += "?#{query_string}"
+        end
+        
+        # Prepare request options
+        options = {}
+        if body
+          options[:payload] = body.is_a?(String) ? body : body.to_json
+        end
+        
+        # Make the request using the rate limiter
+        resp = RateLimiter.execute_request(
+          method: method,
+          url: url,
+          **options
+        )
+        
+        return JSON.parse(resp)
+      end
     end
   end
 end