camper 0.0.5

data/lib/camper/configuration.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Camper
+  # Defines constants and methods related to configuration.
+  class Configuration
+    include Logging
+
+    # An array of valid keys in the options hash when configuring a Basecamp::API.
+    VALID_OPTIONS_KEYS = %i[
+      client_id
+      client_secret
+      redirect_uri
+      account_number
+      refresh_token 
+      access_token
+      user_agent
+    ].freeze
+
+    # The user agent that will be sent to the API endpoint if none is set.
+    DEFAULT_USER_AGENT = "Camper Ruby Gem #{Camper::VERSION}"
+
+    # @private
+    attr_accessor(*VALID_OPTIONS_KEYS)
+
+    def initialize(options = {})
+      options[:user_agent] ||= DEFAULT_USER_AGENT
+      VALID_OPTIONS_KEYS.each do |key|
+        send("#{key}=", options[key]) if options[key]
+      end
+    end
+
+    # Creates a hash of options and their values.
+    def options
+      VALID_OPTIONS_KEYS.inject({}) do |option, key|
+        option.merge!(key => send(key))
+      end
+    end
+
+    # rubocop:disable Metrics/AbcSize
+    # Resets all configuration options to the defaults.
+    def reset
+      logger.debug 'Resetting attributes to default environment values'
+      self.client_id      = ENV['BASECAMP3_CLIENT_ID']
+      self.client_secret  = ENV['BASECAMP3_CLIENT_SECRET']
+      self.redirect_uri   = ENV['BASECAMP3_REDIRECT_URI']
+      self.account_number = ENV['BASECAMP3_ACCOUNT_NUMBER']
+      self.refresh_token  = ENV['BASECAMP3_REFRESH_TOKEN']
+      self.access_token   = ENV['BASECAMP3_ACCESS_TOKEN']
+      self.user_agent     = ENV['BASECAMP3_USER_AGENT'] || DEFAULT_USER_AGENT
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    def authz_endpoint
+      'https://launchpad.37signals.com/authorization/new'
+    end
+
+    def token_endpoint
+      'https://launchpad.37signals.com/authorization/token'
+    end
+
+    def api_endpoint
+      raise Camper::Error::InvalidConfiguration, "missing basecamp account" unless self.account_number
+      
+      "#{self.base_api_endpoint}/#{self.account_number}"
+    end
+
+    def base_api_endpoint
+      self.class.base_api_endpoint
+    end
+
+    def self.base_api_endpoint
+      "https://3.basecampapi.com"
+    end
+  end
+end

data/lib/camper/error.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module Camper
+  module Error
+    # Custom error class for rescuing from all Camper errors.
+    class Error < StandardError; end
+
+    # Raised when there is a configuration error
+    class InvalidConfiguration < Error; end
+
+    # Raised when API endpoint credentials not configured.
+    class MissingCredentials < Error; end
+
+    # Raised when impossible to parse response body.
+    class Parsing < Error; end
+
+    # Custom error class for rescuing from HTTP response errors.
+    class ResponseError < Error
+      POSSIBLE_MESSAGE_KEYS = %i[message error_description error].freeze
+
+      def initialize(response)
+        @response = response
+        super(build_error_message)
+      end
+
+      # Status code returned in the HTTP response.
+      #
+      # @return [Integer]
+      def response_status
+        @response.code
+      end
+
+      # Body content returned in the HTTP response
+      #
+      # @return [String]
+      def response_message
+        @response.parsed_response.message
+      end
+
+      private
+
+      # Human friendly message.
+      #
+      # @return [String]
+      def build_error_message
+        parsed_response = classified_response
+        message = check_error_keys(parsed_response)
+        "Server responded with code #{@response.code}, message: " \
+        "#{handle_message(message)}. " \
+        "Request URI: #{@response.request.base_uri}#{@response.request.path}"
+      end
+
+      # Error keys vary across the API, find the first key that the parsed_response
+      # object responds to and return that, otherwise return the original.
+      def check_error_keys(resp)
+        key = POSSIBLE_MESSAGE_KEYS.find { |k| resp.respond_to?(k) }
+        key ? resp.send(key) : resp
+      end
+
+      # Parse the body based on the classification of the body content type
+      #
+      # @return parsed response
+      def classified_response
+        if @response.respond_to?('headers')
+          @response.headers['content-type'] == 'text/plain' ? { message: @response.to_s } : @response.parsed_response
+        else
+          @response.parsed_response
+        end
+      rescue Camper::Error::Parsing
+        # Return stringified response when receiving a
+        # parsing error to avoid obfuscation of the
+        # api error.
+        #
+        # note: The Camper API does not always return valid
+        # JSON when there are errors.
+        @response.to_s
+      end
+
+      # Handle error response message in case of nested hashes
+      def handle_message(message)
+        case message
+        when Camper::Resource
+          message.to_h.sort.map do |key, val|
+            "'#{key}' #{(val.is_a?(Hash) ? val.sort.map { |k, v| "(#{k}: #{v.join(' ')})" } : [val].flatten).join(' ')}"
+          end.join(', ')
+        when Array
+          message.join(' ')
+        else
+          message
+        end
+      end
+    end
+
+    # Raised when API endpoint returns the HTTP status code 400.
+    class BadRequest < ResponseError; end
+
+    # Raised when API endpoint returns the HTTP status code 401.
+    class Unauthorized < ResponseError; end
+
+    # Raised when API endpoint returns the HTTP status code 403.
+    class Forbidden < ResponseError; end
+
+    # Raised when API endpoint returns the HTTP status code 404.
+    class NotFound < ResponseError; end
+
+    # Raised when API endpoint returns the HTTP status code 405.
+    class MethodNotAllowed < ResponseError; end
+
+    # Raised when API endpoint returns the HTTP status code 406.
+    class NotAcceptable < ResponseError; end
+
+    # Raised when API endpoint returns the HTTP status code 409.
+    class Conflict < ResponseError; end
+
+    # Raised when API endpoint returns the HTTP status code 422.
+    class Unprocessable < ResponseError; end
+
+    # Raised when API endpoint returns the HTTP status code 429.
+    class TooManyRequests < ResponseError; end
+
+    # Raised when API endpoint returns the HTTP status code 500.
+    class InternalServerError < ResponseError; end
+
+    # Raised when API endpoint returns the HTTP status code 502.
+    class BadGateway < ResponseError; end
+
+    # Raised when API endpoint returns the HTTP status code 503.
+    class ServiceUnavailable < ResponseError; end
+
+    # HTTP status codes mapped to error classes.
+    STATUS_MAPPINGS = {
+      400 => BadRequest,
+      401 => Unauthorized,
+      403 => Forbidden,
+      404 => NotFound,
+      405 => MethodNotAllowed,
+      406 => NotAcceptable,
+      409 => Conflict,
+      422 => Unprocessable,
+      429 => TooManyRequests,
+      500 => InternalServerError,
+      502 => BadGateway,
+      503 => ServiceUnavailable
+    }.freeze
+  end
+end

data/lib/camper/logging.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module Camper
+  module Logging
+
+    class << self
+      attr_writer :logger
+    end
+
+    # @!attribute [rw] logger
+    # @return [Logger] The logger.
+    def logger
+      @logger ||= default_logger
+    end
+
+    private
+
+    # Create and configure a logger
+    # @return [Logger]
+    def default_logger
+      logger = Logger.new($stdout)
+      logger.level = ENV['BASECAMP3_LOG_LEVEL'] || Logger::WARN
+      logger
+    end
+  end
+end

data/lib/camper/paginated_response.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Camper
+  # Wrapper class of paginated response.
+  class PaginatedResponse
+    include Logging
+    extend Forwardable
+
+    def_delegators :@array, :to_ary, :first
+
+    attr_accessor :client
+
+    def initialize(array)
+      @array = array
+    end
+
+    def ==(other)
+      @array == other
+    end
+
+    def count
+      @pagination_data.total_count
+    end
+
+    def inspect
+      @array.inspect
+    end
+
+    def parse_headers!(headers)
+      @pagination_data = PaginationData.new headers
+      logger.debug("Pagination data: #{@pagination_data.inspect}")
+    end
+
+    def auto_paginate(limit = nil, &block)
+      limit = count if limit.nil?
+      return lazy_paginate.take(limit).to_a unless block_given?
+
+      lazy_paginate.take(limit).each(&block)
+    end
+
+    def next_page?
+      !(@pagination_data.nil? || @pagination_data.next.nil?)
+    end
+    alias has_next_page? next_page?
+
+    def next_page
+      return nil if @client.nil? || !has_next_page?
+
+      @client.get(@pagination_data.next, override_path: true)
+    end
+
+    private
+
+    def lazy_paginate
+      to_enum(:each_page).lazy.flat_map(&:to_ary)
+    end
+
+    def each_page
+      current = self
+      yield current
+      while current.has_next_page?
+        current = current.next_page
+        yield current
+      end
+    end
+  end
+end

data/lib/camper/pagination_data.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Camper
+  # Parses link header.
+  #
+  # @private
+  class PaginationData
+    include Logging
+
+    HEADER_LINK = 'Link'
+    HEADER_TOTAL_COUNT = 'X-Total-Count'
+
+    DELIM_LINKS = ','
+    LINK_REGEX = /<([^>]+)>; rel="([^"]+)"/.freeze
+    METAS = %w[next].freeze
+
+    attr_accessor(*METAS)
+    attr_accessor :total_count
+
+    def initialize(headers)
+      link_header = headers[HEADER_LINK]
+
+      @total_count = headers[HEADER_TOTAL_COUNT].to_i
+
+      extract_links(link_header) if link_header && link_header =~ /(next)/
+    end
+
+    def inspect
+      "Next URL: #{@next}; Total Count: #{@total_count}"
+    end
+
+    private
+
+    def extract_links(header)
+      header.split(DELIM_LINKS).each do |link|
+        LINK_REGEX.match(link.strip) do |match|
+          url = match[1]
+          meta = match[2]
+          next if !url || !meta || METAS.index(meta).nil?
+
+          send("#{meta}=", url)
+        end
+      end
+    end
+  end
+end
+

data/lib/camper/request.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require 'httparty'
+require 'json'
+
+module Camper
+  class Request
+    include HTTParty
+    include Logging
+    format :json
+    headers 'Accept' => 'application/json', 'Content-Type' => 'application/json'
+    parser(proc { |body, _| parse(body) })
+
+    module Result
+      ACCESS_TOKEN_EXPIRED = 'AccessTokenExpired'
+
+      VALID = 'Valid'
+    end
+
+    def initialize(access_token, user_agent, client)
+      @access_token = access_token
+      @client = client
+
+      self.class.headers 'User-Agent' => user_agent
+    end
+
+    # Converts the response body to a Resource.
+    def self.parse(body)
+      body = decode(body)
+
+      if body.is_a? Hash
+        Resource.create(body)
+      elsif body.is_a? Array
+        PaginatedResponse.new(body.collect! { |e| Resource.create(e) })
+      elsif body
+        true
+      elsif !body
+        false
+      elsif body.nil?
+        false
+      else
+        raise Error::Parsing, "Couldn't parse a response body"
+      end
+    end
+
+    # Decodes a JSON response into Ruby object.
+    def self.decode(response)
+      response ? JSON.parse(response) : {}
+    rescue JSON::ParserError
+      raise Error::Parsing, 'The response is not a valid JSON'
+    end
+
+    %w[get post put delete].each do |method|
+      define_method method do |path, options = {}|
+        params = options.dup
+        override_path = params.delete(:override_path)
+
+        params[:headers] ||= {}
+
+        full_endpoint = override_path ? path : @client.api_endpoint + path
+
+        execute_request(method, full_endpoint, params)
+      end
+    end
+
+    private
+
+    # Executes the request
+    def execute_request(method, endpoint, params)
+      params[:headers].merge!(self.class.headers)
+      params[:headers].merge!(authorization_header)
+
+      logger.debug("Method: #{method}; URL: #{endpoint}")
+      response, result = validate self.class.send(method, endpoint, params)
+
+      response = extract_parsed(response) if result == Result::VALID
+
+      return response, result
+    end
+
+    # Checks the response code for common errors.
+    # Informs that a retry needs to happen if request failed due to access token expiration
+    # @raise [Error::ResponseError] if response is an HTTP error
+    # @return [Response, Request::Result]
+    def validate(response)
+      error_klass = Error::STATUS_MAPPINGS[response.code]
+
+      if error_klass == Error::Unauthorized && response.parsed_response.error.include?('OAuth token expired (old age)')
+        logger.debug('Access token expired. Please obtain a new access token')
+        return response, Result::ACCESS_TOKEN_EXPIRED
+      end
+
+      raise error_klass, response if error_klass
+
+      return response, Result::Valid
+    end
+
+    def extract_parsed(response)
+      parsed = response.parsed_response
+
+      parsed.client = @client if parsed.respond_to?(:client=)
+      parsed.parse_headers!(response.headers) if parsed.respond_to?(:parse_headers!)
+
+      parsed
+    end
+
+    # Returns an Authorization header hash
+    #
+    # @raise [Error::MissingCredentials] if access_token and auth_token are not set.
+    def authorization_header
+      raise Error::MissingCredentials, 'Please provide a access_token' if @access_token.to_s.empty?
+
+      { 'Authorization' => "Bearer #{@access_token}" }
+    end
+  end
+end