Merge enterprise-admin-client

Author: pengwynn

README.md

@@ -257,6 +257,64 @@ custom pattern for traversing large lists.
 
 [paginated]: http://developer.github.com/v3/#pagination
 
+## Working with GitHub Enterprise
+
+With a bit of setup, you can also use Octokit with your Github Enterprise instance.
+
+### Interacting with the GitHub.com APIs in GitHub Enterprise
+
+To interact with the "regular" GitHub.com APIs in GitHub Enterprise, simply configure the `api_endpoint` to match your hostname. For example:
+
+``` ruby
+Octokit.configure do |c|
+  c.api_endpoint = "<hostname>/api/v3/"
+end
+client = Octokit::Client.new(:access_token => "<your 40 char token>")
+```
+
+### Interacting with the GitHub Enterprise Admin APIs
+
+The GitHub Enterprise Admin APIs are under a different client: `EnterpriseAdminClient`. You'll need to have an administrator account in order to use these APIs.
+
+``` ruby
+admin_client = Octokit::EnterpriseAdminClient.new \
+                          :access_token => "<your 40 char token>",
+                          :api_endpoint = "https://<hostname>/api/v3/"
+
+# or
+Octokit.configure do |c|
+  c.api_endpoint = "https://hostname/api/v3/"
+  c.access_token = "<your 40 char token>"
+end
+admin_client = Octokit.enterprise_admin_client
+```
+
+### Interacting with the GitHub Enterprise Management Console APIs
+
+The GitHub Enterprise Management Console APIs are also under a separate client: `EnterpriseManagementConsoleClient`. In order to use it, you'll need to provide both your management console password as well as the endpoint to your management console. This is different than the API endpoint provided above.
+
+``` ruby
+management_console_client = Octokit::EnterpriseManagementConsoleClient.new \
+                          :management_console_password => "secret",
+                          :management_console_endpoint = "https://hostname:8633"
+# or
+Octokit.configure do |c|
+  c.management_console_endpoint = "https://hostname:8633"
+  c.management_console_password = "secret"
+end
+management_console_client = Octokit.enterprise_management_console_client
+```
+
+### SSL Connection Errors
+
+You *may* need to disable SSL temporarily while first setting up your GitHub Enterprise install. You can do that with the following configuration:
+
+``` ruby
+client.connection_options[:ssl] = { :verify => false }
+```
+
+Do remember to turn `:verify` back to `true`, as it's important for secure communication.
+
 ## Configuration and defaults
 
 While `Octokit::Client` accepts a range of options when creating a new client
@@ -510,6 +568,11 @@ ENV Variable | Description |
 `OCTOKIT_TEST_GITHUB_CLIENT_SECRET` | Test OAuth application client secret.
 `OCTOKIT_TEST_GITHUB_REPOSITORY` | Test repository to perform destructive actions against, this should not be set to any repository of importance. **Automatically created by the test suite if nonexistent** Default: `api-sandbox`
 `OCTOKIT_TEST_GITHUB_ORGANIZATION` | Test organization.
+`OCTOKIT_TEST_GITHUB_ENTERPRISE_LOGIN` | GitHub Enterprise login name
+`OCTOKIT_TEST_GITHUB_ENTERPRISE_TOKEN` | GitHub Enterprise token
+`OCTOKIT_TEST_GITHUB_ENTERPRISE_MANAGEMENT_CONSOLE_PASSWORD` | GitHub Enterprise management console password
+`OCTOKIT_TEST_GITHUB_ENTERPRISE_ENDPOINT` | GitHub Enterprise hostname
+`OCTOKIT_TEST_GITHUB_ENTERPRISE_MANAGEMENT_CONSOLE_ENDPOINT` | GitHub Enterprise Management Console endpoint
 
 Since we periodically refresh our cassettes, please keep some points in mind
 when writing new specs.
@@ -590,4 +653,3 @@ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-

lib/octokit.rb

@@ -1,4 +1,6 @@
 require 'octokit/client'
+require 'octokit/enterprise_admin_client'
+require 'octokit/enterprise_management_console_client'
 require 'octokit/default'
 
 # Ruby toolkit for the GitHub API
@@ -11,20 +13,44 @@ class << self
     #
     # @return [Octokit::Client] API wrapper
     def client
-      @client = Octokit::Client.new(options) unless defined?(@client) && @client.same_options?(options)
-      @client
+      return @client if defined?(@client) && @client.same_options?(options)
+      @client = Octokit::Client.new(options)
     end
 
-    # @private
-    def respond_to_missing?(method_name, include_private=false); client.respond_to?(method_name, include_private); end if RUBY_VERSION >= "1.9"
-    # @private
-    def respond_to?(method_name, include_private=false); client.respond_to?(method_name, include_private) || super; end if RUBY_VERSION < "1.9"
+    # 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
 
-  private
+    # 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)
-      return super unless client.respond_to?(method_name)
-      client.send(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

lib/octokit/client.rb

@@ -1,4 +1,5 @@
-require 'sawyer'
+require 'octokit/connection'
+require 'octokit/warnable'
 require 'octokit/arguments'
 require 'octokit/repo_arguments'
 require 'octokit/configurable'
@@ -53,6 +54,8 @@ class Client
 
     include Octokit::Authentication
     include Octokit::Configurable
+    include Octokit::Connection
+    include Octokit::Warnable
     include Octokit::Client::Authorizations
     include Octokit::Client::Commits
     include Octokit::Client::CommitComments
@@ -101,14 +104,6 @@ def initialize(options = {})
       login_from_netrc unless user_authenticated? || application_authenticated?
     end
 
-    # Compares client options to a Hash of requested options
-    #
-    # @param opts [Hash] Options to compare with current client options
-    # @return [Boolean]
-    def same_options?(opts)
-      opts.hash == options.hash
-    end
-
     # Text representation of the client, masking tokens and passwords
     #
     # @return [String]
@@ -117,6 +112,7 @@ def inspect
 
       # mask password
       inspected = inspected.gsub! @password, "*******" if @password
+      inspected = inspected.gsub! @management_console_password, "*******" if @management_console_password
       # Only show last 4 of token, secret
       if @access_token
         inspected = inspected.gsub! @access_token, "#{'*'*36}#{@access_token[36..-1]}"
@@ -128,126 +124,6 @@ def inspect
       inspected
     end
 
-    # Make a HTTP GET request
-    #
-    # @param url [String] The path, relative to {#api_endpoint}
-    # @param options [Hash] Query and header params for request
-    # @return [Sawyer::Resource]
-    def get(url, options = {})
-      request :get, url, parse_query_and_convenience_headers(options)
-    end
-
-    # Make a HTTP POST request
-    #
-    # @param url [String] The path, relative to {#api_endpoint}
-    # @param options [Hash] Body and header params for request
-    # @return [Sawyer::Resource]
-    def post(url, options = {})
-      request :post, url, options
-    end
-
-    # Make a HTTP PUT request
-    #
-    # @param url [String] The path, relative to {#api_endpoint}
-    # @param options [Hash] Body and header params for request
-    # @return [Sawyer::Resource]
-    def put(url, options = {})
-      request :put, url, options
-    end
-
-    # Make a HTTP PATCH request
-    #
-    # @param url [String] The path, relative to {#api_endpoint}
-    # @param options [Hash] Body and header params for request
-    # @return [Sawyer::Resource]
-    def patch(url, options = {})
-      request :patch, url, options
-    end
-
-    # Make a HTTP DELETE request
-    #
-    # @param url [String] The path, relative to {#api_endpoint}
-    # @param options [Hash] Query and header params for request
-    # @return [Sawyer::Resource]
-    def delete(url, options = {})
-      request :delete, url, options
-    end
-
-    # Make a HTTP HEAD request
-    #
-    # @param url [String] The path, relative to {#api_endpoint}
-    # @param options [Hash] Query and header params for request
-    # @return [Sawyer::Resource]
-    def head(url, options = {})
-      request :head, url, parse_query_and_convenience_headers(options)
-    end
-
-    # Make one or more HTTP GET requests, optionally fetching
-    # the next page of results from URL in Link response header based
-    # on value in {#auto_paginate}.
-    #
-    # @param url [String] The path, relative to {#api_endpoint}
-    # @param options [Hash] Query and header params for request
-    # @param block [Block] Block to perform the data concatination of the
-    #   multiple requests. The block is called with two parameters, the first
-    #   contains the contents of the requests so far and the second parameter
-    #   contains the latest response.
-    # @return [Sawyer::Resource]
-    def paginate(url, options = {}, &block)
-      opts = parse_query_and_convenience_headers(options.dup)
-      if @auto_paginate || @per_page
-        opts[:query][:per_page] ||=  @per_page || (@auto_paginate ? 100 : nil)
-      end
-
-      data = request(:get, url, opts.dup)
-
-      if @auto_paginate
-        while @last_response.rels[:next] && rate_limit.remaining > 0
-          @last_response = @last_response.rels[:next].get(:headers => opts[:headers])
-          if block_given?
-            yield(data, @last_response)
-          else
-            data.concat(@last_response.data) if @last_response.data.is_a?(Array)
-          end
-        end
-
-      end
-
-      data
-    end
-
-    # Hypermedia agent for the GitHub API
-    #
-    # @return [Sawyer::Agent]
-    def agent
-      @agent ||= Sawyer::Agent.new(api_endpoint, sawyer_options) do |http|
-        http.headers[:accept] = default_media_type
-        http.headers[:content_type] = "application/json"
-        http.headers[:user_agent] = user_agent
-        if basic_authenticated?
-          http.basic_auth(@login, @password)
-        elsif token_authenticated?
-          http.authorization 'token', @access_token
-        elsif application_authenticated?
-          http.params = http.params.merge application_authentication
-        end
-      end
-    end
-
-    # Fetch the root resource for the API
-    #
-    # @return [Sawyer::Resource]
-    def root
-      get "/"
-    end
-
-    # Response for last HTTP request
-    #
-    # @return [Sawyer::Response]
-    def last_response
-      @last_response if defined? @last_response
-    end
-
     # Duplicate client using client_id and client_secret as
     # Basic Authentication credentials.
     # @example
@@ -312,72 +188,5 @@ def client_secret=(value)
       reset_agent
       @client_secret = value
     end
-
-    # Wrapper around Kernel#warn to print warnings unless
-    # OCTOKIT_SILENT is set to true.
-    #
-    # @return [nil]
-    def octokit_warn(*message)
-      unless ENV['OCTOKIT_SILENT']
-        warn message
-      end
-    end
-
-    private
-
-    def reset_agent
-      @agent = nil
-    end
-
-    def request(method, path, data, options = {})
-      if data.is_a?(Hash)
-        options[:query]   = data.delete(:query) || {}
-        options[:headers] = data.delete(:headers) || {}
-        if accept = data.delete(:accept)
-          options[:headers][:accept] = accept
-        end
-      end
-
-      @last_response = response = agent.call(method, URI::Parser.new.escape(path.to_s), data, options)
-      response.data
-    end
-
-    # Executes the request, checking if it was successful
-    #
-    # @return [Boolean] True on success, false otherwise
-    def boolean_from_response(method, path, options = {})
-      request(method, path, options)
-      @last_response.status == 204
-    rescue Octokit::NotFound
-      false
-    end
-
-
-    def sawyer_options
-      opts = {
-        :links_parser => Sawyer::LinkParsers::Simple.new
-      }
-      conn_opts = @connection_options
-      conn_opts[:builder] = @middleware if @middleware
-      conn_opts[:proxy] = @proxy if @proxy
-      opts[:faraday] = Faraday.new(conn_opts)
-
-      opts
-    end
-
-    def parse_query_and_convenience_headers(options)
-      headers = options.delete(:headers) { Hash.new }
-      CONVENIENCE_HEADERS.each do |h|
-        if header = options.delete(h)
-          headers[h] = header
-        end
-      end
-      query = options.delete(:query)
-      opts = {:query => options}
-      opts[:query].merge!(query) if query && query.is_a?(Hash)
-      opts[:headers] = headers unless headers.empty?
-
-      opts
-    end
   end
 end

lib/octokit/client/pub_sub_hubbub.rb

@@ -93,7 +93,7 @@ def unsubscribe_service_hook(repo, service_name)
       private
 
       def pub_sub_hubbub_request(options = {})
-        # This method is janky, bypass normal stack so we don'tl
+        # This method is janky, bypass normal stack so we don't
         # serialize request as JSON
         conn = Faraday.new(:url => @api_endpoint) do |http|
           http.headers[:user_agent] = user_agent