lingfennan-github_api 0.18.2

data/lib/github_api/error.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+require 'descendants_tracker'
+
+module Github
+  module Error
+    class GithubError < StandardError
+      extend DescendantsTracker
+
+      attr_reader :response_message, :response_headers
+
+      # Initialize a new Github error object.
+      #
+      def initialize(message = $!)
+        if message.respond_to?(:backtrace)
+          super(message.message)
+          @response_message = message
+        else
+          super(message.to_s)
+        end
+      end
+
+      def backtrace
+        if @response_message.respond_to?(:backtrace)
+          @response_message.backtrace
+        else
+          super
+        end
+      end
+    end # GithubError
+  end # Error
+end # Github

data/lib/github_api/error/client_error.rb

@@ -0,0 +1,89 @@
+# encoding: utf-8
+
+require_relative '../error'
+
+module Github #:nodoc
+  # Raised when Github returns the HTTP status code 404
+  module Error
+    class ClientError < GithubError
+      attr_reader :problem, :summary, :resolution
+
+      def initialize(message)
+        super(message)
+      end
+
+      def generate_message(attributes)
+        @problem = attributes[:problem]
+        @summary = attributes[:summary]
+        @resolution = attributes[:resolution]
+        "\nProblem:\n #{@problem}"+
+        "\nSummary:\n #{@summary}"+
+        "\nResolution:\n #{@resolution}"
+      end
+    end
+
+    # Raised when invalid options are passed to a request body
+    class InvalidOptions < ClientError
+      def initialize(invalid, valid)
+        super(
+          generate_message(
+            problem: "Invalid option #{invalid.keys.join(', ')} provided for this request.",
+            summary: "Github gem checks the request parameters passed to ensure that github api is not hit unnecessarily and to fail fast.",
+            resolution: "Valid options are: #{valid.join(', ')}, make sure these are the ones you are using"
+          )
+        )
+      end
+    end
+
+    # Raised when invalid options are passed to a request body
+    class RequiredParams < ClientError
+      def initialize(provided, required)
+        super(
+          generate_message(
+            problem: "Missing required parameters: #{provided.keys.join(', ')} provided for this request.",
+            summary: "Github gem checks the request parameters passed to ensure that github api is not hit unnecessarily and to fail fast.",
+            resolution: "Required parameters are: #{required.join(', ')}, make sure these are the ones you are using"
+          )
+        )
+      end
+    end
+
+    # Raised when invalid options are passed to a request body
+    class UnknownMedia < ClientError
+      def initialize(file)
+        super(
+          generate_message(
+            problem: "Unknown content type for: '#{file}' provided for this request.",
+            summary: "Github gem infers the content type of the resource by calling the mime-types gem type inference.",
+            resolution: "Please install mime-types gem to infer the resource content type."
+          )
+        )
+      end
+    end
+
+    # Raised when invalid options are passed to a request body
+    class UnknownValue < ClientError
+      def initialize(key, value, permitted)
+        super(
+          generate_message(
+            problem: "Wrong value of '#{value}' for the parameter: #{key} provided for this request.",
+            summary: "Github gem checks the request parameters passed to ensure that github api is not hit unnecessairly and fails fast.",
+            resolution: "Permitted values are: #{permitted}, make sure these are the ones you are using"
+          )
+        )
+      end
+    end
+
+    class Validations < ClientError
+      def initialize(errors)
+        super(
+          generate_message(
+            problem: "Attempted to send request with nil arguments for #{errors.keys.join(', ')}.",
+            summary: 'Each request expects certain number of required arguments.',
+            resolution: 'Double check that the provided arguments are set to some value that is neither nil nor empty string.'
+          )
+        )
+      end
+    end
+  end # Error
+end # Github

data/lib/github_api/error/service_error.rb

@@ -0,0 +1,223 @@
+# encoding: utf-8
+
+require 'json'
+
+require_relative '../error'
+
+module Github
+  # Raised when GitHub returns any of the HTTP status codes
+  module Error
+    class ServiceError < GithubError
+      # Add http status code method to error type
+      #
+      # @param [Integer] code
+      #   the status code
+      #
+      # @api public
+      def self.http_status_code(code)
+        define_method(:http_status_code) { code }
+      end
+
+      # A mapping of status codes and error types
+      #
+      # @return [Hash[Integer, Object]]
+      #
+      # @api public
+      def self.error_mapping
+        @error_mapping ||= Hash[
+          descendants.map do |klass|
+            [klass.new({}).http_status_code, klass]
+          end
+        ]
+      end
+
+      MIN_BODY_LENGTH = 2
+
+      # Crate a ServiceError
+      #
+      # @param [Hash[Symbol]] response
+      #
+      # @api public
+      def initialize(response)
+        @headers = response[:response_headers]
+        @body    = response[:body]
+        @status  = response[:status]
+
+        @response_headers = @headers
+        @response_message = @body
+
+        super(create_message(response))
+      end
+
+      # Expose response payload as JSON object if possible
+      #
+      # @return [Hash[Symbol]|String]
+      #
+      # @api public
+      def data
+        @data ||= decode_data(@body)
+      end
+
+      # Stores error message(s) returned in response body
+      #
+      # @return [Array[Hash[Symbol]]]
+      #   the array of hash error objects
+      #
+      # @api public
+      def error_messages
+        @error_messages ||= begin
+          data[:errors] ? data[:errors] : [data]
+        end
+      end
+
+      private
+
+      # Create full error message
+      #
+      # @param [Hash[Symbol]] response
+      #   the http response
+      #
+      # @return [String]
+      #   the error message
+      #
+      # @api private
+      def create_message(response)
+        return if response.nil?
+
+        message = "#{response[:method].to_s.upcase} "
+        message << "#{response[:url]}: "
+        message << "#{@status} - #{format_response}"
+        message
+      end
+
+      # Decode body information if in JSON format
+      #
+      # @param [String] body
+      #   the response body
+      #
+      # @api private
+      def decode_data(body)
+        if body.respond_to?(:to_str) &&
+           body.length >= MIN_BODY_LENGTH &&
+           @headers[:content_type] =~ /json/
+
+          JSON.parse(body, symbolize_names: true)
+        else
+          body
+        end
+      end
+
+      # Read response body and convert to human friendly format
+      #
+      # @return [String]
+      #
+      # @api private
+      def format_response
+        return '' if data.nil? || data.empty?
+
+        case data
+        when Hash
+          message = data[:message] ? data[:message] : ' '
+          docs = data[:documentation_url]
+          error = create_error_summary
+          message << error if error
+          message << "\nSee: #{docs}" if docs
+          message
+        when String
+          data
+        end
+      end
+
+      # Create error summary from response body
+      #
+      # @return [String]
+      #
+      # @api private
+      def create_error_summary
+        if data[:error]
+          "\nError: #{data[:error]}"
+        elsif data[:errors]
+          message = "\nErrors:\n"
+          message << data[:errors].map do |error|
+            case error
+            when Hash
+              "Error: #{error.map { |k, v| "#{k}: #{v}" }.join(', ')}"
+            else
+              "Error: #{error}"
+            end
+          end.join("\n")
+        end
+      end
+    end # ServiceError
+
+    # Raised when Github returns the HTTP status code 400
+    class BadRequest < ServiceError
+      http_status_code 400
+    end
+
+    # Raised when GitHub returns the HTTP status code 401
+    class Unauthorized < ServiceError
+      http_status_code 401
+    end
+
+    # Raised when Github returns the HTTP status code 403
+    class Forbidden < ServiceError
+      http_status_code 403
+    end
+
+    # Raised when Github returns the HTTP status code 404
+    class NotFound < ServiceError
+      http_status_code 404
+    end
+
+    # Raised when Github returns the HTTP status code 405
+    class MethodNotAllowed < ServiceError
+      http_status_code 405
+    end
+
+    # Raised when Github returns the HTTP status code 406
+    class NotAcceptable < ServiceError
+      http_status_code 406
+    end
+
+    # Raised when GitHub returns the HTTP status code 409
+    class Conflict < ServiceError
+      http_status_code 409
+    end
+
+    # Raised when GitHub returns the HTTP status code 414
+    class UnsupportedMediaType < ServiceError
+      http_status_code 414
+    end
+
+    # Raised when GitHub returns the HTTP status code 422
+    class UnprocessableEntity < ServiceError
+      http_status_code 422
+    end
+
+    # Raised when GitHub returns the HTTP status code 451
+    class UnavailableForLegalReasons < ServiceError
+      http_status_code 451
+    end
+
+    # Raised when Github returns the HTTP status code 500
+    class InternalServerError < ServiceError
+      http_status_code 500
+    end
+
+    # Raised when Github returns the HTTP status code 501
+    class NotImplemented < ServiceError
+      http_status_code 501
+    end
+
+    # Raised when Github returns the HTTP status code 502
+    class BadGateway < ServiceError
+      http_status_code 502
+    end
+
+    # Raised when GitHub returns the HTTP status code 503
+    class ServiceUnavailable < ServiceError
+      http_status_code 503
+    end
+  end # Error
+end # Github

data/lib/github_api/ext/faraday.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+
+module Faraday
+  module Utils
+
+    class ParamsHash
+      def params_encoder(encoder = nil)
+        if encoder
+          @encoder = encoder
+        elsif defined?(@encoder)
+          @encoder
+        end
+      end
+
+      def to_query(encoder = nil)
+        Utils.build_nested_query(self, nil, params_encoder)
+      end
+    end
+
+    def build_nested_query(value, prefix = nil, encoder = nil)
+      case value
+      when Array
+        value.map { |v| build_nested_query(v, "#{prefix}%5B%5D", encoder) }.join("&")
+      when Hash
+        value.map { |k, v|
+          processed_value = encoder ? encoder.escape(k) : escape(k)
+          build_nested_query(v, prefix ? "#{prefix}%5B#{processed_value}%5D" : processed_value, encoder)
+        }.join("&")
+      when NilClass
+        prefix
+      else
+        raise ArgumentError, "value must be a Hash" if prefix.nil?
+        processed_value = encoder ? encoder.escape(value) : escape(value)
+        "#{prefix}=#{processed_value}"
+      end
+    end
+  end
+end

data/lib/github_api/mash.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Github
+  class Mash < ::Hashie::Mash
+    disable_warnings
+  end
+end

data/lib/github_api/middleware.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+require_relative 'response'
+require_relative 'response/mashify'
+require_relative 'response/jsonize'
+require_relative 'response/atom_parser'
+require_relative 'response/raise_error'
+require_relative 'response/header'
+require_relative 'response/follow_redirects'
+
+module Github
+  class Middleware
+    def self.default(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, api.oauth_token if api.oauth_token?
+        builder.use Github::Request::BasicAuth, api.authentication if api.basic_authed?
+
+        builder.use Github::Response::FollowRedirects if api.follow_redirects
+        builder.use Faraday::Response::Logger if ENV['DEBUG']
+        unless options[:raw]
+          builder.use Github::Response::Mashify
+          builder.use Github::Response::Jsonize
+          builder.use Github::Response::AtomParser
+        end
+        if api.stack
+          api.stack.call(builder)
+        end
+        builder.use Github::Response::RaiseError
+        builder.adapter options[:adapter]
+      end
+    end
+  end # Middleware
+end # Github

data/lib/github_api/mime_type.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+module Github
+  module MimeType
+
+    MEDIA_LOOKUP = {
+      'json' => 'json',
+      'blob' => 'raw',
+      'raw'  => 'raw+json',
+      'text' => 'text+json',
+      'html' => 'html+json',
+      'full' => 'full+json'
+    }
+
+    # Parse media type param
+    #
+    def parse(media)
+      version = 'v3'
+      media.sub!(/^[.]*|[.]*$/,"")
+      media = media.include?('+') ? media.split('+')[0] : media
+      version, media = media.split('.') if media.include?('.')
+      media_type = lookup_media(media)
+      "application/vnd.github.#{version}.#{media_type}"
+    end
+
+    def lookup_media(name)
+      MEDIA_LOOKUP.fetch(name) do
+        raise ArgumentError, "Provided Media Type #{name} is not valid"
+      end
+    end
+
+  end # MimeType
+end # Github