github

#!/usr/bin/env ruby

require 'json'
require 'net/http'
require 'cgi'
require 'open3'

class AlfredGithubError < StandardError; end
class AuthenticationError < AlfredGithubError; end
class APIError < AlfredGithubError; end

class Github
  KEYCHAIN_ENTRY = "alfred-github-workflow".freeze
  BASE_URI = "https://api.github.com"
  USER_CACHE_FILE = ".user-cache"

  def store_token(token)
    _, err, st = Open3.capture3("security add-generic-password -a $USER -s #{KEYCHAIN_ENTRY} -w #{token} -U")
    raise AuthenticationError.new("Failed to store token in keychain") unless st.success?
    File.delete(USER_CACHE_FILE) if File.exist?(USER_CACHE_FILE)
  end

  def search_repo(query)
    load_token!
    search_user_repos(query)
  end

  def refresh_users
    File.delete(USER_CACHE_FILE) if File.exist?(USER_CACHE_FILE)
    load_token!
    cache_user_and_orgs
  end

  private

  def load_token!
    token, err, st = Open3.capture3("security find-generic-password -a $USER -s #{KEYCHAIN_ENTRY} -w")
    @token = strip_non_printable_characters(token)
    if !st.success?
      raise AuthenticationError.new("Keychain entry not found. Use gh-auth to fix this.")
    elsif !@token || @token.empty?
      raise AuthenticationError.new("Invalid token retrieved from keychain. Use gh-auth to fix this.")
    end
  end

  def search_user_repos(keyword)
    return [] if !keyword || keyword.empty?
    user_params = user_and_orgs.each_with_object("") { |u, params| params << " user:#{u}" }
    results = get "/search/repositories", { "q" => "#{keyword}#{user_params} in:name sort:updated" }
    results['items'].map do |repo|
      { 'name' => repo['full_name'], 'url' => repo['html_url'] }
    end
  end

  def user_and_orgs
    @user_and_orgs ||= []
    return @user_and_orgs unless @user_and_orgs.empty?

    if File.exist?(USER_CACHE_FILE)
      @user_and_orgs = File.read(USER_CACHE_FILE).split("\n")
    end
    return @user_and_orgs unless @user_and_orgs.empty?

    @user_and_orgs = cache_user_and_orgs
  end

  def cache_user_and_orgs
    org_results = get "/user/orgs"
    found = org_results.each_with_object([]) do |org, orgs|
      orgs << org["login"]
    end

    user_result = get "/user"
    found << user_result["login"]

    File.write(USER_CACHE_FILE, found.join("\n"))
    found
  end

  def get(path, params = {})
    params['per_page'] = 15 # slightly more than shown by default
    qs = params.map {|k, v| "#{CGI.escape k.to_s}=#{CGI.escape v.to_s}"}.join("&")
    uri = URI("#{BASE_URI}#{path}?#{qs}")

    response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
      req = Net::HTTP::Get.new(uri)
      req['Accept'] = "application/vnd.github.v3+json"
      req['Authorization'] = "token #{@token}"
      http.request(req)
    end

    response_code = response.code.to_i
    if response_code == 401
      raise AuthenticationError.new("Github auth error (#{response_code}). Add a valid token using gh-auth to fix this.")
    elsif response_code == 403
      raise AuthenticationError.new("Github auth error (#{response_code}). Github token must have 'repo' and 'public_repo' permissions.")
    elsif response_code > 399
      raise APIError.new("Error communicating with Github. Details: GET #{path} #{response_code}")
    end
    JSON.parse(response.body)
  end

  def strip_non_printable_characters(string)
    string.gsub(/[^[:print:]]/i, '').strip
  end
end

case ARGV[0]
when '--auth'
  begin
    Github.new.store_token(ARGV[1])
    puts "Successfully stored auth token in keychain"
  rescue AlfredGithubError => e
    puts e.message
  end

when '--refresh'
  begin
    Github.new.refresh_users
    puts "Successfully refreshed user cache"
  rescue AlfredGithubError => e
    puts e.message
  end

when '--search'
  begin
    results = Github.new.search_repo(ARGV[1] || '')
    alfred_results = results.map do |repo|
      {
        "uid" => repo['name'],
        "title" => repo['name'],
        "subtitle" => repo['url'],
        "arg" => repo['url'],
        "autocomplete" => repo['name'],
        "quicklookurl" => repo['url']
      }
    end
    alfred_results = { "items" => alfred_results }.to_json
    puts alfred_results
  rescue AuthenticationError => e
    main_message, secondary_message = e.message.split(".", 2)
    alfred_results = [{
      "title" => main_message,
      "subtitle" => "Hit enter to use gh-auth to add a valid token.",
      "arg" => 'gh-auth'
    }]
    alfred_results = { "items" => alfred_results }.to_json
    puts alfred_results
  rescue APIError => e
    main_message, secondary_message = e.message.split(".", 2)
    alfred_results = [{
      "title" => main_message,
      "subtitle" => secondary_message
    }]
    alfred_results = { "items" => alfred_results }.to_json
    puts alfred_results
  end
end