github_api 0.11.3 → 0.12.0

data/lib/github_api/configuration.rb

@@ -1,126 +1,56 @@
 # encoding: utf-8
 
+require 'github_api/api/config'
+
 module Github
-  module Configuration
-
-    VALID_OPTIONS_KEYS = [
-      :adapter,
-      :client_id,
-      :client_secret,
-      :oauth_token,
-      :endpoint,
-      :site,
-      :ssl,
-      :mime_type,
-      :user_agent,
-      :connection_options,
-      :repo,
-      :user,
-      :org,
-      :login,
-      :password,
-      :basic_auth,
-      :auto_pagination
-    ].freeze
+  class Configuration < API::Config
 
     # Other adapters are :typhoeus, :patron, :em_synchrony, :excon, :test
-    DEFAULT_ADAPTER = :net_http
+    property :adapter, default: :net_http
 
     # By default, don't set an application key
-    DEFAULT_CLIENT_ID = nil
+    property :client_id
 
     # By default, don't set an application secret
-    DEFAULT_CLIENT_SECRET = nil
+    property :client_secret
 
     # By default, don't set a user oauth access token
-    DEFAULT_OAUTH_TOKEN = nil
-
-    # By default, don't set a user login name
-    DEFAULT_LOGIN = nil
-
-    # By default, don't set a user password
-    DEFAULT_PASSWORD = nil
-
-    # By default, don't set a user basic authentication
-    DEFAULT_BASIC_AUTH = nil
+    property  :oauth_token
 
     # The api endpoint used to connect to GitHub if none is set
-    DEFAULT_ENDPOINT = 'https://api.github.com'.freeze
+    property  :endpoint, default: 'https://api.github.com'.freeze
 
     # The web endpoint used to connect to GitHub if none is set
-    DEFAULT_SITE = 'https://github.com'.freeze
+    property  :site, default: 'https://github.com'.freeze
 
     # The default SSL configuration
-    DEFAULT_SSL = {
+    property  :ssl, default: {
       :ca_file => File.expand_path('../ssl_certs/cacerts.pem', __FILE__)
     }
 
-    # The value sent in the http header for 'User-Agent' if none is set
-    DEFAULT_USER_AGENT = "Github Ruby Gem #{Github::VERSION::STRING}".freeze
-
     # By default the <tt>Accept</tt> header will make a request for <tt>JSON</tt>
-    DEFAULT_MIME_TYPE = :json
+    property  :mime_type
+
+    # The value sent in the http header for 'User-Agent' if none is set
+    property  :user_agent, default: "Github Ruby Gem #{Github::VERSION::STRING}".freeze
 
     # By default uses the Faraday connection options if none is set
-    DEFAULT_CONNECTION_OPTIONS = {}
+    property  :connection_options, default: {}
+
+    property :repo
+
+    property :user
+
+    property :org
 
-    # By default, don't set user name
-    DEFAULT_USER = nil
+    property :login
 
-    # By default, don't set repository name
-    DEFAULT_REPO = nil
+    property :password
 
-    # By default, don't set organization name
-    DEFAULT_ORG = nil
+    property :basic_auth
 
     # By default, don't traverse the page links
-    DEFAULT_AUTO_PAGINATION = false
-
-    attr_accessor *VALID_OPTIONS_KEYS
-
-    # Convenience method to allow for global setting of configuration options
-    def configure
-      yield self
-    end
-
-    def self.extended(base)
-      base.reset!
-    end
-
-    class << self
-      def keys
-        VALID_OPTIONS_KEYS
-      end
-    end
-
-    def options
-      options = {}
-      VALID_OPTIONS_KEYS.each { |k| options[k] = send(k) }
-      options
-    end
-
-    # Reset configuration options to their defaults
-    #
-    def reset!
-      self.adapter            = DEFAULT_ADAPTER
-      self.client_id          = DEFAULT_CLIENT_ID
-      self.client_secret      = DEFAULT_CLIENT_SECRET
-      self.oauth_token        = DEFAULT_OAUTH_TOKEN
-      self.endpoint           = DEFAULT_ENDPOINT
-      self.site               = DEFAULT_SITE
-      self.ssl                = DEFAULT_SSL
-      self.user_agent         = DEFAULT_USER_AGENT
-      self.connection_options = DEFAULT_CONNECTION_OPTIONS
-      self.mime_type          = DEFAULT_MIME_TYPE
-      self.user               = DEFAULT_USER
-      self.repo               = DEFAULT_REPO
-      self.org                = DEFAULT_ORG
-      self.login              = DEFAULT_LOGIN
-      self.password           = DEFAULT_PASSWORD
-      self.basic_auth         = DEFAULT_BASIC_AUTH
-      self.auto_pagination    = DEFAULT_AUTO_PAGINATION
-      self
-    end
+    property :auto_pagination, default: false
 
   end # Configuration
 end # Github

data/lib/github_api/connection.rb

@@ -6,12 +6,8 @@ require 'github_api/response/mashify'
 require 'github_api/response/jsonize'
 require 'github_api/response/raise_error'
 require 'github_api/response/header'
-require 'github_api/request/oauth2'
-require 'github_api/request/basic_auth'
-require 'github_api/request/jsonize'
 
 module Github
-
   # Specifies Http connection options
   module Connection
     extend self
@@ -33,10 +29,10 @@ module Github
                             'application/vnd.github.beta+json;q=0.5,' \
                             'application/json;q=0.1',
           ACCEPT_CHARSET => 'utf-8',
-          USER_AGENT     => user_agent
+          USER_AGENT     => options[:user_agent]
         },
-        ssl: ssl,
-        url: options.fetch(:endpoint) { Github.endpoint }
+        ssl: options[:ssl],
+        url: options[:endpoint]
       }
     end
 
@@ -44,12 +40,13 @@ module Github
     # configuration stage.
     #
     def default_middleware(options = {})
+      api = options[:api]
       proc do |builder|
         builder.use Github::Request::Jsonize
         builder.use Faraday::Request::Multipart
         builder.use Faraday::Request::UrlEncoded
-        builder.use Github::Request::OAuth2, oauth_token if oauth_token?
-        builder.use Github::Request::BasicAuth, authentication if basic_authed?
+        builder.use Github::Request::OAuth2, api.oauth_token if api.oauth_token?
+        builder.use Github::Request::BasicAuth, api.authentication if api.basic_authed?
 
         builder.use Faraday::Response::Logger if ENV['DEBUG']
         unless options[:raw]
@@ -57,7 +54,7 @@ module Github
           builder.use Github::Response::Jsonize
         end
         builder.use Github::Response::RaiseError
-        builder.adapter adapter
+        builder.adapter options[:adapter]
       end
     end
 
@@ -78,10 +75,12 @@ module Github
     #
     def stack(options = {}, &block)
       @stack ||= begin
+        builder_class = defined?(Faraday::RackBuilder) ? Faraday::RackBuilder : Faraday::Builder
+
         if block_given?
-          Faraday::Builder.new(&block)
+          builder_class.new(&block)
         else
-          Faraday::Builder.new(&default_middleware(options))
+          builder_class.new(&default_middleware(options))
         end
       end
     end
@@ -89,16 +88,15 @@ module Github
     # Creates http connection
     #
     # Returns a Fraday::Connection object
-    def connection(options = {})
+    def connection(api, options = {})
       connection_options = default_options(options)
       clear_cache unless options.empty?
-      connection_options.merge!(builder: stack(options))
+      connection_options.merge!(builder: stack(options.merge!(api: api)))
       if ENV['DEBUG']
         p "Connection options : \n"
         pp connection_options
       end
       @connection ||= Faraday.new(connection_options)
     end
-
   end # Connection
 end # Github

data/lib/github_api/normalizer.rb

@@ -1,9 +1,8 @@
-# -*- encoding: utf-8 -*-
+# encoding: utf-8
 
 module Github
   # Deals with normalazing client supplied parameter keys.
   module Normalizer
-
     # Turns any keys from nested hashes including nested arrays into strings
     #
     def normalize!(params)
@@ -22,6 +21,5 @@ module Github
       end
       return params
     end
-
   end # Normalizer
 end # Github

data/lib/github_api/rate_limit.rb

@@ -15,5 +15,11 @@ module Github
       get_request("/rate_limit", arguments.params).rate.remaining
     end
 
+    def ratelimit_reset(*args)
+      arguments(args)
+
+      get_request("/rate_limit", arguments.params).rate.reset
+    end
+
   end # RateLimit
 end # Github

data/lib/github_api/request.rb

@@ -1,72 +1,84 @@
 # encoding: utf-8
 
-module Github
+require 'github_api/request/oauth2'
+require 'github_api/request/basic_auth'
+require 'github_api/request/jsonize'
 
-  # Defines HTTP verbs
-  module Request
+require 'github_api/connection'
 
-    METHODS = [:get, :post, :put, :delete, :patch]
+module Github
+  # A class responsible for dispatching http requests
+  class Request
+    include Connection
 
-    METHODS_WITH_BODIES = [:post, :put, :patch]
+    HTTP_METHODS = [:get, :head, :post, :put, :delete, :patch]
 
-    def get_request(path, params = ParamsHash.empty)
-      request(:get, path, params).auto_paginate
-    end
+    METHODS_WITH_BODIES = [:post, :put, :patch]
 
-    def patch_request(path, params = ParamsHash.empty)
-      request(:patch, path, params)
-    end
+    # Return http verb
+    #
+    # @return [Symbol]
+    attr_reader :action
 
-    def post_request(path, params = ParamsHash.empty)
-      request(:post, path, params)
-    end
+    # Return url
+    #
+    # @return [String]
+    attr_accessor :path
 
-    def put_request(path, params = ParamsHash.empty)
-      request(:put, path, params)
-    end
+    # Return api this request is associated with
+    #
+    # @return [Github::API]
+    attr_reader :api
 
-    def delete_request(path, params = ParamsHash.empty)
-      request(:delete, path, params)
+    # Create a new Request
+    #
+    # @return [Github::Request]
+    #
+    # @api public
+    def initialize(action, path, api)
+      @action = action
+      @path   = path
+      @api    = api
     end
 
     # Performs a request
     #
-    # method - The Symbol the HTTP verb
-    # path   - String relative URL to access
-    # params - ParamsHash to configure the request API
+    # @param [Symbol] method - The Symbol the HTTP verb
+    # @param [String] path   - String relative URL to access
+    # @param [ParamsHash] params - ParamsHash to configure the request API
     #
-    # Returns a Github::ResponseWrapper
+    # @return [Github::ResponseWrapper]
     #
-    def request(method, path, params) # :nodoc:
-      unless METHODS.include?(method)
-        raise ArgumentError, "unkown http method: #{method}"
+    # @api private
+    def call(current_options, params)
+      unless HTTP_METHODS.include?(action)
+        raise ArgumentError, "unknown http method: #{method}"
       end
 
-      puts "EXECUTED: #{method} - #{path} with PARAMS: #{params}" if ENV['DEBUG']
+      puts "EXECUTED: #{action} - #{path} with PARAMS: #{params}" if ENV['DEBUG']
 
       request_options    = params.options
       connection_options = current_options.merge(request_options)
-      conn               = connection(connection_options)
+      conn               = connection(api, connection_options)
 
-      if conn.path_prefix != '/' && path.index(conn.path_prefix) != 0
-        path = (conn.path_prefix + path).gsub(/\/(\/)*/, '/')
+      if conn.path_prefix != '/' && self.path.index(conn.path_prefix) != 0
+        self.path = (conn.path_prefix + self.path).gsub(/\/(\/)*/, '/')
       end
 
-      response = conn.send(method) do |request|
-        case method.to_sym
-        when *(METHODS - METHODS_WITH_BODIES)
+      response = conn.send(action) do |request|
+        case action.to_sym
+        when *(HTTP_METHODS - METHODS_WITH_BODIES)
           request.body = params.data if params.has_key?('data')
           if params.has_key?('encoder')
             request.params.params_encoder(params.encoder)
           end
-          request.url(path, params.to_hash)
+          request.url(self.path, params.to_hash)
         when *METHODS_WITH_BODIES
-          request.url(path, connection_options[:query] || {})
+          request.url(self.path, connection_options[:query] || {})
           request.body = params.data unless params.empty?
         end
       end
-      ResponseWrapper.new(response, self)
+      ResponseWrapper.new(response, api)
     end
-
   end # Request
 end # Github

data/lib/github_api/request/basic_auth.rb

@@ -4,7 +4,7 @@ require 'faraday'
 require 'base64'
 
 module Github
-  module Request
+  class Request
     class BasicAuth < Faraday::Middleware
       dependency 'base64'
 

data/lib/github_api/request/jsonize.rb

@@ -13,16 +13,19 @@ module Github
     def call(env)
       if request_with_body?(env)
         env[:request_headers][CONTENT_TYPE] ||= MIME_TYPE
-        env[:body] = encode_body env unless env[:body].respond_to?(:to_str)
+        env[:body] = encode_body env[:body] unless env[:body].respond_to?(:to_str)
+      else
+        # Ensure valid body for put and post requests
+        env[:body] = encode_body({})
       end
       @app.call env
     end
 
-    def encode_body(env)
+    def encode_body(value)
       if MultiJson.respond_to?(:dump)
-        MultiJson.dump env[:body]
+        MultiJson.dump(value)
       else
-        MultiJson.encode env[:body]
+        MultiJson.encode(value)
       end
     end
 
@@ -41,6 +44,5 @@ module Github
       type = type.split(';', 2).first if type.index(';')
       type
     end
-
   end # Request::Jsonize
 end # Github

data/lib/github_api/request/oauth2.rb

@@ -3,7 +3,7 @@
 require 'faraday'
 
 module Github
-  module Request
+  class Request
     class OAuth2 < Faraday::Middleware
       include Github::Utils::Url
 

data/lib/github_api/request/verbs.rb

@@ -0,0 +1,60 @@
+# encoding: utf-8
+
+module Github
+  # A class responsible for dispatching http requests
+  class Request
+
+    # Defines HTTP verbs
+    module Verbs
+      # Make a head request
+      #
+      # @api public
+      def head_request(path, params = ParamsHash.empty)
+        Request.new(:head, path, self).call(current_options, params)
+      end
+
+      # Make a get request
+      #
+      # @api public
+      def get_request(path, params = ParamsHash.empty)
+        request = Request.new(:get, path, self).call(current_options, params)
+        request.auto_paginate
+      end
+
+      # Make a patch request
+      #
+      # @api public
+      def patch_request(path, params = ParamsHash.empty)
+        Request.new(:patch, path, self).call(current_options, params)
+      end
+
+      # Make a post request
+      #
+      # @api public
+      def post_request(path, params = ParamsHash.empty)
+        Request.new(:post, path, self).call(current_options, params)
+      end
+
+      # Make a put request
+      #
+      # @api public
+      def put_request(path, params = ParamsHash.empty)
+        Request.new(:put, path, self).call(current_options, params)
+      end
+
+      # Make a delete request
+      #
+      # @api public
+      def delete_request(path, params = ParamsHash.empty)
+        Request.new(:delete, path, self).call(current_options, params)
+      end
+
+      # Make a options request
+      #
+      # @api public
+      def options_request(path, params = ParamsHash.empty)
+        Request.new(:options, path, self).call(current_options, params)
+      end
+    end # Verbs
+  end # Request
+end # Github