github_api2 1.0.0

data/lib/github_api2/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_api2/request/oauth2.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+require 'faraday'
+require 'oauth2'
+
+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_api2/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_api2/request.rb

@@ -0,0 +1,84 @@
+# 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 current_options [Hash]
+    # @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: #{action}"
+      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_api2/response/atom_parser.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+require 'faraday'
+
+module Github
+  class Response::AtomParser < Response
+    define_parser do |body|
+      require 'rss'
+      RSS::Parser.parse(body)
+    end
+
+    def initialize(app, options = {})
+      super(app, options.merge(content_type: /(\batom|\brss)/))
+    end
+
+    def on_complete(env)
+      if parse_body?(env)
+        process_body(env)
+      end
+    end
+  end
+end

data/lib/github_api2/response/follow_redirects.rb

@@ -0,0 +1,140 @@
+require 'faraday'
+require 'set'
+
+# First saw on octokit, then copied from lostisland/faraday_middleware
+# and adapted for this library.
+#
+# faraday_middleware/lib/faraday_middleware/response/follow_redirects.rb
+
+module Github
+  # Public: Exception thrown when the maximum amount of requests is exceeded.
+  class RedirectLimitReached < Faraday::ClientError
+    attr_reader :response
+
+    def initialize(response)
+      super "too many redirects; last one to: #{response['location']}"
+      @response = response
+    end
+  end
+
+  # Public: Follow HTTP 301, 302, 303, 307, and 308 redirects.
+  #
+  # For HTTP 301, 302, and 303, the original GET, POST, PUT, DELETE, or PATCH
+  # request gets converted into a GET. With `:standards_compliant => true`,
+  # however, the HTTP method after 301/302 remains unchanged. This allows you
+  # to opt into HTTP/1.1 compliance and act unlike the major web browsers.
+  #
+  # This middleware currently only works with synchronous requests; i.e. it
+  # doesn't support parallelism.
+  #
+  # If you wish to persist cookies across redirects, you could use
+  # the faraday-cookie_jar gem:
+  #
+  #   Faraday.new(:url => url) do |faraday|
+  #     faraday.use FaradayMiddleware::FollowRedirects
+  #     faraday.use :cookie_jar
+  #     faraday.adapter Faraday.default_adapter
+  #   end
+
+  class Response::FollowRedirects < Faraday::Middleware
+    # HTTP methods for which 30x redirects can be followed
+    ALLOWED_METHODS = Set.new [:head, :options, :get, :post, :put, :patch, :delete]
+    # HTTP redirect status codes that this middleware implements
+    REDIRECT_CODES  = Set.new [301, 302, 303, 307, 308]
+    # Keys in env hash which will get cleared between requests
+    ENV_TO_CLEAR    = Set.new [:status, :response, :response_headers]
+
+    # Default value for max redirects followed
+    FOLLOW_LIMIT = 3
+
+    # Regex that matches characters that need to be escaped in URLs, sans
+    # the "%" character which we assume already represents an escaped sequence.
+    URI_UNSAFE = /[^\-_.!~*'()a-zA-Z\d;\/?:@&=+$,\[\]%]/
+
+    # Public: Initialize the middleware.
+    #
+    # options - An options Hash (default: {}):
+    #           :limit               - A Numeric redirect limit (default: 3)
+    #           :standards_compliant - A Boolean indicating whether to respect
+    #                                  the HTTP spec when following 301/302
+    #                                  (default: false)
+    #           :callback            - A callable that will be called on redirects
+    #                                  with the old and new envs
+    def initialize(app, options = {})
+      super(app)
+      @options = options
+
+      @convert_to_get = Set.new [303]
+      @convert_to_get << 301 << 302 unless standards_compliant?
+    end
+
+    def call(env)
+      perform_with_redirection(env, follow_limit)
+    end
+
+    private
+
+    def convert_to_get?(response)
+      ![:head, :options].include?(response.env[:method]) &&
+        @convert_to_get.include?(response.status)
+    end
+
+    def perform_with_redirection(env, follows)
+      request_body = env[:body]
+      response = @app.call(env)
+
+      response.on_complete do |response_env|
+        if follow_redirect?(response_env, response)
+          raise RedirectLimitReached, response if follows.zero?
+          new_request_env = update_env(response_env.dup, request_body, response)
+          callback.call(response_env, new_request_env) if callback
+          response = perform_with_redirection(new_request_env, follows - 1)
+        end
+      end
+      response
+    end
+
+    def update_env(env, request_body, response)
+      env[:url] += safe_escape(response['location'])
+
+      if convert_to_get?(response)
+        env[:method] = :get
+        env[:body] = nil
+      else
+        env[:body] = request_body
+      end
+
+      ENV_TO_CLEAR.each {|key| env.delete key }
+
+      env
+    end
+
+    def follow_redirect?(env, response)
+      ALLOWED_METHODS.include? env[:method] and
+        REDIRECT_CODES.include? response.status
+    end
+
+    def follow_limit
+      @options.fetch(:limit, FOLLOW_LIMIT)
+    end
+
+    def standards_compliant?
+      @options.fetch(:standards_compliant, false)
+    end
+
+    def callback
+      @options[:callback]
+    end
+
+    # Internal: escapes unsafe characters from an URL which might be a path
+    # component only or a fully qualified URI so that it can be joined onto an
+    # URI:HTTP using the `+` operator. Doesn't escape "%" characters so to not
+    # risk double-escaping.
+    def safe_escape(uri)
+      uri = uri.split('#')[0] # we want to remove the fragment if present
+      uri.to_s.gsub(URI_UNSAFE) { |match|
+        '%' + match.unpack('H2' * match.bytesize).join('%').upcase
+      }
+    end
+  end
+end

data/lib/github_api2/response/header.rb

@@ -0,0 +1,87 @@
+# encoding: utf-8
+
+require_relative '../constants'
+
+module Github
+  class Response
+
+    # Represents http response header
+    class Header < Struct.new(:env)
+      include Github::Constants
+
+      SUCCESSFUL_STATUSES = 200..299
+
+      def loaded?
+        !!env
+      end
+
+      def [](property)
+        loaded? ? env[:response_headers][property] : nil
+      end
+
+      def oauth_scopes
+        loaded? ? env[:response_headers][OAUTH_SCOPES] : nil
+      end
+
+      def accepted_oauth_scopes
+        loaded? ? env[:response_headers][ACCEPTED_OAUTH_SCOPES] : nil
+      end
+
+      # Requests are limited to API v3 to 5000 per hour.
+      def ratelimit_limit
+        loaded? ? env[:response_headers][RATELIMIT_LIMIT] : nil
+      end
+
+      def ratelimit_remaining
+        loaded? ? env[:response_headers][RATELIMIT_REMAINING] : nil
+      end
+
+      # A unix timestamp describing when the ratelimit will
+      # be reset
+      def ratelimit_reset
+        loaded? ? env[:response_headers][RATELIMIT_RESET] : nil
+      end
+
+      def cache_control
+        loaded? ? env[:response_headers][CACHE_CONTROL] : nil
+      end
+
+      def content_type
+        loaded? ? env[:response_headers][CONTENT_TYPE] : nil
+      end
+
+      def content_length
+        loaded? ? env[:response_headers][CONTENT_LENGTH] : nil
+      end
+
+      def etag
+        loaded? ? env[:response_headers][ETAG] : nil
+      end
+
+      def date
+        loaded? ? env[:response_headers][DATE] : nil
+      end
+
+      def location
+        loaded? ? env[:response_headers][LOCATION] : nil
+      end
+
+      def server
+        loaded? ? env[:response_headers][SERVER] : nil
+      end
+
+      def status
+        loaded? ? env[:status] : nil
+      end
+
+      def success?
+        SUCCESSFUL_STATUSES.include? status
+      end
+
+      # Returns raw body
+      def body
+        loaded? ? env[:body] : nil
+      end
+    end # Header
+  end # Response
+end # Github

data/lib/github_api2/response/jsonize.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+require 'faraday'
+require 'json'
+
+module Github
+  class Response::Jsonize < Response
+
+    # dependency 'json'
+
+    define_parser do |body|
+      JSON.parse(body)
+    end
+
+    def parse(body)
+      case body
+      when ''
+        nil
+      when 'true'
+        true
+      when 'false'
+        false
+      else
+        self.class.parser.call(body)
+      end
+    end
+  end # Response::Jsonize
+end # Github

data/lib/github_api2/response/mashify.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+require 'faraday'
+require 'hashie'
+require 'github_api2/mash'
+
+module Github
+  class Response::Mashify < Response
+    define_parser do |body|
+      ::Github::Mash.new body
+    end
+
+    def parse(body)
+      case body
+      when Hash
+        self.class.parser.call body
+      when Array
+        body.map { |item| item.is_a?(Hash) ? self.class.parser.call(item) : item }
+      else
+        body
+      end
+    end
+  end # Response::Mashify
+end # Github

data/lib/github_api2/response/raise_error.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+require 'faraday'
+
+require_relative '../error/service_error'
+
+module Github
+  class Response::RaiseError < Faraday::Response::Middleware
+    # Check if status code requires raising a ServiceError
+    #
+    # @api private
+    def on_complete(env)
+      status_code   = env[:status].to_i
+      service_error = Github::Error::ServiceError
+      error_class = service_error.error_mapping[status_code]
+      if !error_class and (400...600) === status_code
+        error_class = service_error
+      end
+      raise error_class.new(env) if error_class
+    end
+  end # Response::RaiseError
+end # Github

data/lib/github_api2/response/xmlize.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+require 'faraday'
+require 'nokogiri'
+
+module Github
+  class Response::Xmlize < Response
+
+    # dependency 'nokogiri'
+
+    define_parser do |body|
+      ::Nokogiri::XML body
+    end
+
+    def parse(body)
+      case body
+      when ''
+        nil
+      when 'true'
+        true
+      when 'false'
+        false
+      else
+        self.class.parser.call(body)
+      end
+    end
+  end # Response::Xmlize
+end # Github

data/lib/github_api2/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