lingfennan-github_api 0.18.2

data/lib/github_api/params_hash.rb

@@ -0,0 +1,115 @@
+# encoding: utf-8
+
+require 'delegate'
+require 'base64'
+
+require_relative 'normalizer'
+require_relative 'mime_type'
+
+module Github
+  # Class responsible for holding request parameters
+  class ParamsHash < DelegateClass(Hash)
+    include Normalizer
+    include MimeType
+
+    REQUEST_PARAMS = [:accept, :media, :data, :raw, :headers]
+
+    def initialize(hash)
+      super(normalize!(Hash[hash]))
+    end
+
+    # Create empty hash
+    #
+    # @api public
+    def self.empty
+      new({})
+    end
+
+    # Extract and parse media type param
+    #
+    #  [.version].param[+json]
+    #
+    # @api public
+    def media
+      parse(delete('media'))
+    end
+
+    # Get accept header
+    #
+    # @api public
+    def accept
+      if key?('accept') then self['accept']
+      elsif key?('media') then media
+      else nil
+      end
+    end
+
+    # Extract request data from parameters
+    #
+    # @api public
+    def data
+      if key?('data') && !self['data'].nil?
+        self['data']
+      else
+        request_params
+      end
+    end
+
+    def encoder
+      if key?('encoder') && self['encoder']
+        self['encoder']
+      else
+        {}
+      end
+    end
+
+    # Configuration options from request
+    #
+    # @return [Hash]
+    #
+    # @api public
+    def options
+      opts    = fetch('options', {})
+      headers = fetch('headers', {})
+      if value = accept
+        headers[:accept] = value
+      end
+      opts[:raw]     = key?('raw') ? self['raw'] : false
+      opts[:headers] = headers unless headers.empty?
+      opts
+    end
+
+    # Update hash with default parameters for non existing keys
+    #
+    def merge_default(defaults)
+      if defaults && !defaults.empty?
+        defaults.each do |key, value|
+          self[key] = value unless self.key?(key)
+        end
+      end
+      self
+    end
+
+    # Base64 encode string removing newline characters
+    #
+    # @api public
+    def strict_encode64(key)
+      value = self[key]
+      encoded = if Base64.respond_to?(:strict_encode64)
+                  Base64.strict_encode64(value)
+                else
+                  [value].pack('m0')
+                end
+      self[key] = encoded.delete("\n\r")
+    end
+
+    # Filter out request params
+    #
+    # @api public
+    def request_params
+      to_hash.select do |key, value|
+        !REQUEST_PARAMS.include?(key.to_sym)
+      end
+    end
+  end # ParamsHash
+end # Github

data/lib/github_api/rate_limit.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+module Github
+  module RateLimit
+
+    def ratelimit(*args)
+      arguments(args)
+
+      get_request("/rate_limit", arguments.params).rate.limit
+    end
+
+    def ratelimit_remaining(*args)
+      arguments(args)
+
+      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

@@ -0,0 +1,85 @@
+# encoding: utf-8
+
+require_relative 'connection'
+require_relative 'response_wrapper'
+require_relative 'request/oauth2'
+require_relative 'request/basic_auth'
+require_relative 'request/jsonize'
+
+module Github
+  # A class responsible for dispatching http requests
+  class Request
+    include Connection
+
+    HTTP_METHODS = [:get, :head, :post, :put, :delete, :patch]
+
+    METHODS_WITH_BODIES = [:post, :put, :patch]
+
+    # Return http verb
+    #
+    # @return [Symbol]
+    attr_reader :action
+
+    # Return url
+    #
+    # @return [String]
+    attr_accessor :path
+
+    # Return api this request is associated with
+    #
+    # @return [Github::API]
+    attr_reader :api
+
+    # Create a new Request
+    #
+    # @return [Github::Request]
+    #
+    # @api public
+    def initialize(action, path, api)
+      @action = action
+      @path   = path
+      @api    = api
+    end
+
+    # Performs a request
+    #
+    # @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
+    #
+    # @return [Github::ResponseWrapper]
+    #
+    # @api private
+    def call(current_options, params)
+      unless HTTP_METHODS.include?(action)
+        raise ArgumentError, "unknown http method: #{method}"
+      end
+
+      puts "EXECUTED: #{action} - #{path} with PARAMS: #{params.request_params}" if ENV['DEBUG']
+
+      request_options    = params.options
+      connection_options = current_options.merge(request_options)
+      conn               = connection(api, connection_options)
+
+      self.path = Utils::Url.normalize(self.path)
+      if conn.path_prefix != '/' && self.path.index(conn.path_prefix) != 0
+        self.path = (conn.path_prefix + self.path).gsub(/\/(\/)*/, '/')
+      end
+
+      response = conn.send(action) do |request|
+        case action.to_sym
+        when *(HTTP_METHODS - METHODS_WITH_BODIES)
+          request.body = params.data if params.key?('data')
+          if params.key?('encoder')
+            request.params.params_encoder(params.encoder)
+          end
+          request.url(self.path, params.request_params)
+        when *METHODS_WITH_BODIES
+          request.url(self.path, connection_options[:query] || {})
+          request.body = params.data unless params.empty?
+        end
+      end
+      ResponseWrapper.new(response, api)
+    end
+  end # Request
+end # Github

data/lib/github_api/request/basic_auth.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+
+require 'faraday'
+require 'base64'
+
+module Github
+  class Request
+    class BasicAuth < Faraday::Middleware
+      dependency 'base64'
+
+      # @api private
+      def initialize(app, *args)
+        @app    = app
+        @auth   = nil
+        options = args.extract_options!
+
+        if options.key?(:login) && !options[:login].nil?
+          credentials = "#{options[:login]}:#{options[:password]}"
+          @auth = Base64.encode64(credentials)
+          @auth.gsub!("\n", "")
+        end
+      end
+
+      # Update request headers
+      #
+      # @api private
+      def call(env)
+        if @auth
+          env[:request_headers].merge!('Authorization' => "Basic #{@auth}")
+        end
+
+        @app.call(env)
+      end
+    end # BasicAuth
+  end # Request
+end # Github

data/lib/github_api/request/jsonize.rb

@@ -0,0 +1,54 @@
+# encoding: utf-8
+
+require 'faraday'
+
+module Github
+  class Request::Jsonize < Faraday::Middleware
+
+    CONTENT_TYPE = 'Content-Type'.freeze
+    MIME_TYPE    = 'application/json'.freeze
+
+    dependency 'multi_json'
+
+    def call(env)
+      if request_with_body?(env)
+        env[:request_headers][CONTENT_TYPE] ||= MIME_TYPE
+        env[:body] = encode_body env[:body] unless env[:body].respond_to?(:to_str)
+      elsif safe_to_modify?(env)
+        # Ensure valid body for put and post requests
+        if [:put, :patch, :post].include?(env[:method])
+          env[:body] = encode_body({})
+        end
+      end
+      @app.call env
+    end
+
+    def encode_body(value)
+      if MultiJson.respond_to?(:dump)
+        MultiJson.dump(value)
+      else
+        MultiJson.encode(value)
+      end
+    end
+
+    def request_with_body?(env)
+      has_body?(env) and safe_to_modify?(env)
+    end
+
+    def safe_to_modify?(env)
+      type = request_type(env)
+      type.empty? or type == MIME_TYPE
+    end
+
+    # Don't encode bodies in string form
+    def has_body?(env)
+      body = env[:body] and !(body.respond_to?(:to_str) and body.empty?)
+    end
+
+    def request_type(env)
+      type = env[:request_headers][CONTENT_TYPE].to_s
+      type = type.split(';', 2).first if type.index(';')
+      type
+    end
+  end # Request::Jsonize
+end # Github

data/lib/github_api/request/oauth2.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+
+require 'faraday'
+
+require_relative '../utils/url'
+
+module Github
+  class Request
+    class OAuth2 < Faraday::Middleware
+      include Github::Utils::Url
+
+      ACCESS_TOKEN = 'access_token'.freeze
+      AUTH_HEADER  = 'Authorization'.freeze
+
+      dependency 'oauth2'
+
+      def call(env)
+        # Extract parameters from the query
+        params = { ACCESS_TOKEN => @token }.update query_params(env[:url])
+
+        if token = params[ACCESS_TOKEN] and !token.empty?
+          env[:url].query = build_query params
+          env[:request_headers].merge!(AUTH_HEADER => "token #{token}")
+        end
+
+        @app.call env
+      end
+
+      def initialize(app, *args)
+        super app
+        @app = app
+        @token = args.shift
+      end
+
+      def query_params(url)
+        if url.query.nil? or url.query.empty?
+          {}
+        else
+          parse_query url.query
+        end
+      end
+    end # OAuth2
+  end # Request
+end # Github

data/lib/github_api/request/verbs.rb

@@ -0,0 +1,63 @@
+# encoding: utf-8
+
+require_relative '../request'
+require_relative '../params_hash'
+
+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

data/lib/github_api/response.rb

@@ -0,0 +1,48 @@
+# encoding: utf-8
+
+require 'faraday'
+
+module Github
+  # Contains methods and attributes that act on the response returned from the 
+  # request
+  class Response < Faraday::Response::Middleware
+    CONTENT_TYPE = 'Content-Type'.freeze
+
+    class << self
+      attr_accessor :parser
+    end
+
+    def self.define_parser(&block)
+      @parser = block
+    end
+
+    def initialize(app, options = {})
+      super(app)
+      @content_types = Array(options[:content_type])
+    end
+
+    def process_body(env)
+      env[:body] = parse(env[:body])
+    end
+
+    def parse_body?(env)
+      parse_response_type?(response_type(env)) and parse_response?(env)
+    end
+
+    def response_type(env)
+      type = env[:response_headers][CONTENT_TYPE].to_s
+      type = type.split(';', 2).first if type.index(';')
+      type
+    end
+
+    def parse_response_type?(type)
+      @content_types.empty? || @content_types.any? { |pattern|
+        pattern.is_a?(Regexp) ? type =~ pattern : type == pattern
+      }
+    end
+
+    def parse_response?(env)
+      env[:body].respond_to?(:to_str)
+    end
+  end # Response
+end # Github