octodoggy 4.6.2

data/Rakefile

@@ -0,0 +1,22 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+task :test => :spec
+task :default => :spec
+
+namespace :doc do
+  begin
+    require 'yard'
+    YARD::Rake::YardocTask.new do |task|
+      task.files   = ['README.md', 'LICENSE.md', 'lib/**/*.rb']
+      task.options = [
+        '--output-dir', 'doc/yard',
+        '--markup', 'markdown',
+      ]
+    end
+  rescue LoadError
+  end
+end

data/lib/ext/sawyer/relation.rb

@@ -0,0 +1,10 @@
+require 'sawyer'
+
+patch = Module.new do
+  def href(options=nil)
+    # Temporary workaround for: https://github.com/octokit/octokit.rb/issues/727
+    name.to_s == "ssh" ? @href : super
+  end
+end
+
+Sawyer::Relation.send(:prepend, patch)

data/lib/octokit.rb

@@ -0,0 +1,59 @@
+require 'octokit/client'
+require 'octokit/enterprise_admin_client'
+require 'octokit/enterprise_management_console_client'
+require 'octokit/default'
+
+# Ruby toolkit for the GitHub API
+module Octokit
+
+  class << self
+    include Octokit::Configurable
+
+    # API client based on configured options {Configurable}
+    #
+    # @return [Octokit::Client] API wrapper
+    def client
+      return @client if defined?(@client) && @client.same_options?(options)
+      @client = Octokit::Client.new(options)
+    end
+
+    # EnterpriseAdminClient client based on configured options {Configurable}
+    #
+    # @return [Octokit::EnterpriseAdminClient] API wrapper
+    def enterprise_admin_client
+      return @enterprise_admin_client if defined?(@enterprise_admin_client) && @enterprise_admin_client.same_options?(options)
+      @enterprise_admin_client = Octokit::EnterpriseAdminClient.new(options)
+    end
+
+    # EnterpriseManagementConsoleClient client based on configured options {Configurable}
+    #
+    # @return [Octokit::EnterpriseManagementConsoleClient] API wrapper
+    def enterprise_management_console_client
+      return @enterprise_management_console_client if defined?(@enterprise_management_console_client) && @enterprise_management_console_client.same_options?(options)
+      @enterprise_management_console_client = Octokit::EnterpriseManagementConsoleClient.new(options)
+    end
+
+    private
+
+    def respond_to_missing?(method_name, include_private=false)
+      client.respond_to?(method_name, include_private) ||
+      enterprise_admin_client.respond_to?(method_name, include_private) ||
+      enterprise_management_console_client.respond_to?(method_name, include_private)
+    end
+
+    def method_missing(method_name, *args, &block)
+      if client.respond_to?(method_name)
+        return client.send(method_name, *args, &block)
+      elsif enterprise_admin_client.respond_to?(method_name)
+        return enterprise_admin_client.send(method_name, *args, &block)
+      elsif enterprise_management_console_client.respond_to?(method_name)
+        return enterprise_management_console_client.send(method_name, *args, &block)
+      end
+
+      super
+    end
+
+  end
+end
+
+Octokit.setup

data/lib/octokit/arguments.rb

@@ -0,0 +1,14 @@
+module Octokit
+
+  # Extracts options from method arguments
+  # @private
+  class Arguments < Array
+    attr_reader :options
+
+    def initialize(args)
+      @options = args.last.is_a?(::Hash) ? args.pop : {}
+      super(args)
+    end
+
+  end
+end

data/lib/octokit/authentication.rb

@@ -0,0 +1,82 @@
+module Octokit
+
+  # Authentication methods for {Octokit::Client}
+  module Authentication
+
+    # Indicates if the client was supplied  Basic Auth
+    # username and password
+    #
+    # @see https://developer.github.com/v3/#authentication
+    # @return [Boolean]
+    def basic_authenticated?
+      !!(@login && @password)
+    end
+
+    # Indicates if the client was supplied an OAuth
+    # access token
+    #
+    # @see https://developer.github.com/v3/#authentication
+    # @return [Boolean]
+    def token_authenticated?
+      !!@access_token
+    end
+
+    # Indicates if the client was supplied a bearer token
+    #
+    # @see https://developer.github.com/early-access/integrations/authentication/#as-an-integration
+    # @return [Boolean]
+    def bearer_authenticated?
+      !!@bearer_token
+    end
+
+    # Indicates if the client was supplied an OAuth
+    # access token or Basic Auth username and password
+    #
+    # @see https://developer.github.com/v3/#authentication
+    # @return [Boolean]
+    def user_authenticated?
+      basic_authenticated? || token_authenticated?
+    end
+
+    # Indicates if the client has OAuth Application
+    # client_id and secret credentials to make anonymous
+    # requests at a higher rate limit
+    #
+    # @see https://developer.github.com/v3/#unauthenticated-rate-limited-requests
+    # @return Boolean
+    def application_authenticated?
+      !!application_authentication
+    end
+
+    private
+
+    def application_authentication
+      if @client_id && @client_secret
+        {
+          :client_id     => @client_id,
+          :client_secret => @client_secret
+        }
+      end
+    end
+
+    def login_from_netrc
+      return unless netrc?
+
+      require 'netrc'
+      info = Netrc.read netrc_file
+      netrc_host = URI.parse(api_endpoint).host
+      creds = info[netrc_host]
+      if creds.nil?
+        # creds will be nil if there is no netrc for this end point
+        octokit_warn "Error loading credentials from netrc file for #{api_endpoint}"
+      else
+        creds = creds.to_a
+        self.login = creds.shift
+        self.password = creds.shift
+      end
+    rescue LoadError
+      octokit_warn "Please install netrc gem for .netrc support"
+    end
+
+  end
+end

data/lib/octokit/client.rb

@@ -0,0 +1,238 @@
+require 'octokit/connection'
+require 'octokit/warnable'
+require 'octokit/arguments'
+require 'octokit/repo_arguments'
+require 'octokit/configurable'
+require 'octokit/authentication'
+require 'octokit/gist'
+require 'octokit/rate_limit'
+require 'octokit/repository'
+require 'octokit/user'
+require 'octokit/organization'
+require 'octokit/preview'
+require 'octokit/client/authorizations'
+require 'octokit/client/commits'
+require 'octokit/client/commit_comments'
+require 'octokit/client/contents'
+require 'octokit/client/downloads'
+require 'octokit/client/deployments'
+require 'octokit/client/emojis'
+require 'octokit/client/events'
+require 'octokit/client/feeds'
+require 'octokit/client/gists'
+require 'octokit/client/gitignore'
+require 'octokit/client/hooks'
+require 'octokit/client/integrations'
+require 'octokit/client/issues'
+require 'octokit/client/labels'
+require 'octokit/client/legacy_search'
+require 'octokit/client/licenses'
+require 'octokit/client/meta'
+require 'octokit/client/markdown'
+require 'octokit/client/milestones'
+require 'octokit/client/notifications'
+require 'octokit/client/objects'
+require 'octokit/client/organizations'
+require 'octokit/client/pages'
+require 'octokit/client/projects'
+require 'octokit/client/pub_sub_hubbub'
+require 'octokit/client/pull_requests'
+require 'octokit/client/rate_limit'
+require 'octokit/client/reactions'
+require 'octokit/client/refs'
+require 'octokit/client/releases'
+require 'octokit/client/repositories'
+require 'octokit/client/repository_invitations'
+require 'octokit/client/reviews'
+require 'octokit/client/say'
+require 'octokit/client/search'
+require 'octokit/client/service_status'
+require 'octokit/client/source_import'
+require 'octokit/client/stats'
+require 'octokit/client/statuses'
+require 'octokit/client/traffic'
+require 'octokit/client/users'
+require 'ext/sawyer/relation'
+
+module Octokit
+
+  # Client for the GitHub API
+  #
+  # @see https://developer.github.com
+  class Client
+
+    include Octokit::Authentication
+    include Octokit::Configurable
+    include Octokit::Connection
+    include Octokit::Preview
+    include Octokit::Warnable
+    include Octokit::Client::Authorizations
+    include Octokit::Client::Commits
+    include Octokit::Client::CommitComments
+    include Octokit::Client::Contents
+    include Octokit::Client::Deployments
+    include Octokit::Client::Downloads
+    include Octokit::Client::Emojis
+    include Octokit::Client::Events
+    include Octokit::Client::Feeds
+    include Octokit::Client::Gists
+    include Octokit::Client::Gitignore
+    include Octokit::Client::Hooks
+    include Octokit::Client::Integrations
+    include Octokit::Client::Issues
+    include Octokit::Client::Labels
+    include Octokit::Client::LegacySearch
+    include Octokit::Client::Licenses
+    include Octokit::Client::Meta
+    include Octokit::Client::Markdown
+    include Octokit::Client::Milestones
+    include Octokit::Client::Notifications
+    include Octokit::Client::Objects
+    include Octokit::Client::Organizations
+    include Octokit::Client::Pages
+    include Octokit::Client::Projects
+    include Octokit::Client::PubSubHubbub
+    include Octokit::Client::PullRequests
+    include Octokit::Client::RateLimit
+    include Octokit::Client::Reactions
+    include Octokit::Client::Refs
+    include Octokit::Client::Releases
+    include Octokit::Client::Repositories
+    include Octokit::Client::RepositoryInvitations
+    include Octokit::Client::Reviews
+    include Octokit::Client::Say
+    include Octokit::Client::Search
+    include Octokit::Client::ServiceStatus
+    include Octokit::Client::SourceImport
+    include Octokit::Client::Stats
+    include Octokit::Client::Statuses
+    include Octokit::Client::Traffic
+    include Octokit::Client::Users
+
+    # Header keys that can be passed in options hash to {#get},{#head}
+    CONVENIENCE_HEADERS = Set.new([:accept, :content_type])
+
+    def initialize(options = {})
+      # Use options passed in, but fall back to module defaults
+      Octokit::Configurable.keys.each do |key|
+        instance_variable_set(:"@#{key}", options[key] || Octokit.instance_variable_get(:"@#{key}"))
+      end
+
+      login_from_netrc unless user_authenticated? || application_authenticated?
+    end
+
+    # Text representation of the client, masking tokens and passwords
+    #
+    # @return [String]
+    def inspect
+      inspected = super
+
+      # mask password
+      inspected = inspected.gsub! @password, "*******" if @password
+      inspected = inspected.gsub! @management_console_password, "*******" if @management_console_password
+      inspected = inspected.gsub! @bearer_token, '********' if @bearer_token
+      # Only show last 4 of token, secret
+      if @access_token
+        inspected = inspected.gsub! @access_token, "#{'*'*36}#{@access_token[36..-1]}"
+      end
+      if @client_secret
+        inspected = inspected.gsub! @client_secret, "#{'*'*36}#{@client_secret[36..-1]}"
+      end
+
+      inspected
+    end
+
+    # Duplicate client using client_id and client_secret as
+    # Basic Authentication credentials.
+    # @example
+    #   Octokit.client_id = "foo"
+    #   Octokit.client_secret = "bar"
+    #
+    #   # GET https://api.github.com/?client_id=foo&client_secret=bar
+    #   Octokit.get "/"
+    #
+    #   Octokit.client.as_app do |client|
+    #     # GET https://foo:bar@api.github.com/
+    #     client.get "/"
+    #   end
+    def as_app(key = client_id, secret = client_secret, &block)
+      if key.to_s.empty? || secret.to_s.empty?
+        raise ApplicationCredentialsRequired, "client_id and client_secret required"
+      end
+      app_client = self.dup
+      app_client.client_id = app_client.client_secret = nil
+      app_client.login    = key
+      app_client.password = secret
+
+      yield app_client if block_given?
+    end
+
+    # Set username for authentication
+    #
+    # @param value [String] GitHub username
+    def login=(value)
+      reset_agent
+      @login = value
+    end
+
+    # Set password for authentication
+    #
+    # @param value [String] GitHub password
+    def password=(value)
+      reset_agent
+      @password = value
+    end
+
+    # Set OAuth access token for authentication
+    #
+    # @param value [String] 40 character GitHub OAuth access token
+    def access_token=(value)
+      reset_agent
+      @access_token = value
+    end
+
+    # Set Bearer Token for authentication
+    #
+    # @param value [String] JWT
+    def bearer_token=(value)
+      reset_agent
+      @bearer_token = value
+    end
+
+    # Set OAuth app client_id
+    #
+    # @param value [String] 20 character GitHub OAuth app client_id
+    def client_id=(value)
+      reset_agent
+      @client_id = value
+    end
+
+    # Set OAuth app client_secret
+    #
+    # @param value [String] 40 character GitHub OAuth app client_secret
+    def client_secret=(value)
+      reset_agent
+      @client_secret = value
+    end
+
+    def client_without_redirects(options = {})
+      conn_opts = @connection_options
+      conn_opts[:url] = @api_endpoint
+      conn_opts[:builder] = @middleware.dup if @middleware
+      conn_opts[:proxy] = @proxy if @proxy
+      conn = Faraday.new(conn_opts) do |http|
+        if basic_authenticated?
+          http.basic_auth(@login, @password)
+        elsif token_authenticated?
+          http.authorization 'token', @access_token
+        elsif bearer_authenticated?
+          http.authorization 'Bearer', @bearer_token
+        end
+        http.headers['accept'] = options[:accept] if options.key?(:accept)
+      end
+      conn.builder.delete(Octokit::Middleware::FollowRedirects)
+
+      conn
+    end
+  end
+end

data/lib/octokit/client/authorizations.rb

@@ -0,0 +1,244 @@
+module Octokit
+  class Client
+
+    # Methods for the Authorizations API
+    #
+    # @see https://developer.github.com/v3/oauth_authorizations/#oauth-authorizations-api
+    module Authorizations
+
+      # List the authenticated user's authorizations
+      #
+      # API for users to manage their own tokens.
+      # You can only access your own tokens, and only through
+      # Basic Authentication.
+      #
+      # @return [Array<Sawyer::Resource>] A list of authorizations for the authenticated user
+      # @see https://developer.github.com/v3/oauth_authorizations/#list-your-authorizations
+      # @example List authorizations for user ctshryock
+      #  client = Octokit::Client.new(:login => 'ctshryock', :password => 'secret')
+      #  client.authorizations
+      def authorizations(options = {})
+        paginate 'authorizations', options
+      end
+
+      # Get a single authorization for the authenticated user.
+      #
+      # You can only access your own tokens, and only through
+      # Basic Authentication.
+      #
+      # @return [Sawyer::Resource] A single authorization for the authenticated user
+      # @see https://developer.github.com/v3/oauth_authorizations/#get-a-single-authorization
+      # @example Show authorization for user ctshryock's Travis auth
+      #  client = Octokit::Client.new(:login => 'ctshryock', :password => 'secret')
+      #  client.authorization(999999)
+      def authorization(number, options = {})
+        get "authorizations/#{number}", options
+      end
+
+      # Create an authorization for the authenticated user.
+      #
+      # You can create your own tokens, and only through
+      # Basic Authentication.
+      #
+      # @param options [Hash] A customizable set of options.
+      # @option options [Array] :scopes A list of scopes that this authorization is in.
+      # @option options [String] :note A note to remind you what the OAuth token is for.
+      # @option options [String] :note_url A URL to remind you what app the OAuth token is for.
+      # @option options [Boolean] :idempotent If true, will return an existing authorization if one has already been created.
+      # @option options [String] :client_id  Client Id we received when our application was registered with GitHub.
+      # @option options [String] :client_secret  Client Secret we received when our application was registered with GitHub.
+      #
+      # @return [Sawyer::Resource] A single authorization for the authenticated user
+      # @see https://developer.github.com/v3/oauth/#scopes Available scopes
+      # @see https://developer.github.com/v3/oauth_authorizations/#create-a-new-authorization
+      # @see https://developer.github.com/v3/oauth_authorizations/#get-or-create-an-authorization-for-a-specific-app
+      # @example Create a new authorization for user ctshryock's project Zoidberg
+      #  client = Octokit::Client.new(:login => 'ctshryock', :password => 'secret')
+      #  client.create_authorization({:scopes => ["public_repo", "gist"], :note => "Why not Zoidberg?", :note_url=> "https://en.wikipedia.org/wiki/Zoidberg"})
+      # @example Create a new OR return an existing authorization to be used by a specific client for user ctshryock's project Zoidberg
+      #  client = Octokit::Client.new(:login => 'ctshryock', :password => 'secret')
+      #  client.create_authorization({:idempotent => true, :client_id => 'xxxx', :client_secret => 'yyyy', :scopes => ["user"]})
+      def create_authorization(options = {})
+        # Techincally we can omit scopes as GitHub has a default, however the
+        # API will reject us if we send a POST request with an empty body.
+
+        if options.delete :idempotent
+          client_id, client_secret = fetch_client_id_and_secret(options)
+          raise ArgumentError.new("Client ID and Secret required for idempotent authorizations") unless client_id && client_secret
+
+          if fingerprint = options.delete(:fingerprint)
+            put "authorizations/clients/#{client_id}/#{fingerprint}", options.merge(:client_secret => client_secret)
+          else
+            put "authorizations/clients/#{client_id}", options.merge(:client_secret => client_secret)
+          end
+
+        else
+          post 'authorizations', options
+        end
+      end
+
+      # Update an authorization for the authenticated user.
+      #
+      # You can update your own tokens, but only through
+      # Basic Authentication.
+      #
+      # @param options [Hash] A customizable set of options.
+      # @option options [Array] :scopes Replace the authorization scopes with these.
+      # @option options [Array] :add_scopes A list of scopes to add to this authorization.
+      # @option options [Array] :remove_scopes A list of scopes to remove from this authorization.
+      # @option options [String] :note A note to remind you what the OAuth token is for.
+      # @option options [String] :note_url A URL to remind you what app the OAuth token is for.
+      #
+      # @return [Sawyer::Resource] A single (updated) authorization for the authenticated user
+      # @see https://developer.github.com/v3/oauth_authorizations/#update-an-existing-authorization
+      # @see https://developer.github.com/v3/oauth/#scopes for available scopes
+      # @example Update the authorization for user ctshryock's project Zoidberg
+      #  client = Octokit::Client.new(:login => 'ctshryock', :password => 'secret')
+      #  client.update_authorization(999999, {:add_scopes => ["gist", "repo"], :note => "Why not Zoidberg possibly?"})
+      def update_authorization(number, options = {})
+        patch "authorizations/#{number}", options
+      end
+
+      # Delete an authorization for the authenticated user.
+      #
+      # You can delete your own tokens, and only through
+      # Basic Authentication.
+      #
+      # @param number [Number] An existing Authorization ID
+      #
+      # @return [Boolean] Success
+      # @see https://developer.github.com/v3/oauth_authorizations/#delete-an-authorization
+      # @example Delete an authorization
+      #  client = Octokit::Client.new(:login => 'ctshryock', :password => 'secret')
+      #  client.delete_authorization(999999)
+      def delete_authorization(number, options = {})
+        boolean_from_response :delete, "authorizations/#{number}", options
+      end
+
+      # Check scopes for a token
+      #
+      # @param token [String] GitHub OAuth token
+      # @param options [Hash] Header params for request
+      # @return [Array<String>] OAuth scopes
+      # @see https://developer.github.com/v3/oauth/#scopes
+      def scopes(token = @access_token, options = {})
+        raise ArgumentError.new("Access token required") if token.nil?
+
+        auth = { "Authorization" => "token #{token}" }
+        headers = (options.delete(:headers) || {}).merge(auth)
+
+        agent.call(:get, "user", :headers => headers).
+          headers['X-OAuth-Scopes'].
+          to_s.
+          split(',').
+          map(&:strip).
+          sort
+      end
+
+      # Check if a token is valid.
+      #
+      # Applications can check if a token is valid without rate limits.
+      #
+      # @param token [String] 40 character GitHub OAuth access token
+      #
+      # @return [Sawyer::Resource] A single authorization for the authenticated user
+      # @see https://developer.github.com/v3/oauth_authorizations/#check-an-authorization
+      # @example
+      #  client = Octokit::Client.new(:client_id => 'abcdefg12345', :client_secret => 'secret')
+      #  client.check_application_authorization('deadbeef1234567890deadbeef987654321')
+      def check_application_authorization(token, options = {})
+        opts = options.dup
+        key    = opts.delete(:client_id)     || client_id
+        secret = opts.delete(:client_secret) || client_secret
+
+        as_app(key, secret) do |app_client|
+          app_client.get "applications/#{client_id}/tokens/#{token}", opts
+        end
+      end
+
+      # Reset a token
+      #
+      # Applications can reset a token without requiring a user to re-authorize.
+      #
+      # @param token [String] 40 character GitHub OAuth access token
+      #
+      # @return [Sawyer::Resource] A single authorization for the authenticated user
+      # @see https://developer.github.com/v3/oauth_authorizations/#reset-an-authorization
+      # @example
+      #  client = Octokit::Client.new(:client_id => 'abcdefg12345', :client_secret => 'secret')
+      #  client.reset_application_authorization('deadbeef1234567890deadbeef987654321')
+      def reset_application_authorization(token, options = {})
+        opts = options.dup
+        key    = opts.delete(:client_id)     || client_id
+        secret = opts.delete(:client_secret) || client_secret
+
+        as_app(key, secret) do |app_client|
+          app_client.post "applications/#{client_id}/tokens/#{token}", opts
+        end
+      end
+
+      # Revoke a token
+      #
+      # Applications can revoke (delete) a token
+      #
+      # @param token [String] 40 character GitHub OAuth access token
+      #
+      # @return [Boolean] Result
+      # @see https://developer.github.com/v3/oauth_authorizations/#revoke-an-authorization-for-an-application
+      # @example
+      #  client = Octokit::Client.new(:client_id => 'abcdefg12345', :client_secret => 'secret')
+      #  client.revoke_application_authorization('deadbeef1234567890deadbeef987654321')
+      def revoke_application_authorization(token, options = {})
+        opts = options.dup
+        key    = opts.delete(:client_id)     || client_id
+        secret = opts.delete(:client_secret) || client_secret
+
+        as_app(key, secret) do |app_client|
+          app_client.delete "applications/#{client_id}/tokens/#{token}", opts
+
+          app_client.last_response.status == 204
+        end
+      rescue Octokit::NotFound
+        false
+      end
+      alias :delete_application_authorization :revoke_application_authorization
+
+      # Revoke all tokens for an app
+      #
+      # Applications can revoke all of their tokens in a single request
+      #
+      # @deprecated As of January 25th, 2016: https://developer.github.com/changes/2014-04-08-reset-api-tokens/
+      # @return [Boolean] false
+      def revoke_all_application_authorizations(options = {})
+        octokit_warn("Deprecated: If you need to revoke all tokens for your application, you can do so via the settings page for your application.")
+        false
+      end
+
+      # Get the URL to authorize a user for an application via the web flow
+      #
+      # @param app_id [String] Client Id we received when our application was registered with GitHub.
+      # @option options [String] :redirect_uri The url to redirect to after authorizing.
+      # @option options [String] :scope The scopes to request from the user.
+      # @option options [String] :state A random string to protect against CSRF.
+      # @return [String] The url to redirect the user to authorize.
+      # @see Octokit::Client
+      # @see https://developer.github.com/v3/oauth/#web-application-flow
+      # @example
+      #   @client.authorize_url('xxxx')
+      def authorize_url(app_id = client_id, options = {})
+        if app_id.to_s.empty?
+          raise Octokit::ApplicationCredentialsRequired.new "client_id required"
+        end
+        authorize_url = options.delete(:endpoint) || Octokit.web_endpoint
+        authorize_url << "login/oauth/authorize?client_id=#{app_id}"
+
+        require 'cgi'
+        options.each do |key, value|
+          authorize_url << "&#{key}=#{CGI.escape value}"
+        end
+
+        authorize_url
+      end
+    end
+  end
+end