camp3 0.0.1

data/lib/camp3/authorization.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Camp3
+  module Authorization
+
+    def authorization_uri
+      client = authz_client
+
+      client.authorization_uri type: :web_server
+    end
+
+    def authz_client
+      Rack::OAuth2::Client.new(
+        identifier: Camp3.client_id,
+        secret: Camp3.client_secret,
+        redirect_uri: Camp3.redirect_uri,
+        authorization_endpoint: Camp3.authz_endpoint,
+        token_endpoint: Camp3.token_endpoint,
+      )
+    end
+
+    def authorize!(auth_code)
+      client = authz_client
+      client.authorization_code = auth_code
+
+      # Passing secrets as query string
+      token = client.access_token!(
+        client_auth_method: nil,
+        client_id: Camp3.client_id,
+        client_secret: Camp3.client_secret,
+        type: :web_server
+        # code: auth_code
+      )
+
+      store_tokens(token)
+
+      token
+    end
+
+    def update_access_token!(refresh_token = nil)
+      Camp3.logger.debug "Update access token using refresh token"
+      
+      refresh_token = Camp3.refresh_token unless refresh_token
+      client = authz_client
+      client.refresh_token = refresh_token
+
+      token = client.access_token!(
+        client_auth_method: nil,
+        client_id: Camp3.client_id,
+        client_secret: Camp3.client_secret,
+        type: :refresh
+      )
+
+      store_tokens(token)
+
+      token
+    end
+
+    private
+
+    def store_tokens(token)
+      Camp3.access_token = token.access_token
+      Camp3.refresh_token = token.refresh_token
+    end
+  end
+end

data/lib/camp3/client.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Camp3
+  # Wrapper for the Gitlab REST API.
+  class Client < Request
+    Dir[File.expand_path('api/*.rb', __dir__)].each { |f| require f }
+    
+    # Keep in alphabetical order
+    include Authorization
+    include ProjectAPI
+    include MessageAPI
+    include TodoAPI
+
+    # @private
+    attr_accessor(*Configuration::VALID_OPTIONS_KEYS)
+
+    # Creates a new API.
+    # @raise [Error:MissingCredentials]
+    def initialize(options = {})
+      options = Camp3.options.merge(options)
+      
+      (Configuration::VALID_OPTIONS_KEYS).each do |key|
+        send("#{key}=", options[key]) if options[key]
+      end
+
+      self.class.headers 'User-Agent' => user_agent
+    end
+
+    # Text representation of the client, masking private token.
+    #
+    # @return [String]
+    def inspect
+      inspected = super
+      inspected.sub! @access_token, only_show_last_four_chars(@access_token) if @access_token
+      inspected
+    end
+
+    # Utility method for URL encoding of a string.
+    # Copied from https://ruby-doc.org/stdlib-2.7.0/libdoc/erb/rdoc/ERB/Util.html
+    #
+    # @return [String]
+    def url_encode(url)
+      url.to_s.b.gsub(/[^a-zA-Z0-9_\-.~]/n) { |m| sprintf('%%%02X', m.unpack1('C')) } # rubocop:disable Style/FormatString, Style/FormatStringToken
+    end
+
+    private
+
+    def only_show_last_four_chars(token)
+      "#{'*' * (token.size - 4)}#{token[-4..-1]}"
+    end
+  end
+end

data/lib/camp3/configuration.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Camp3
+  # Defines constants and methods related to configuration.
+  module 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 = "Camp3 Ruby Gem #{Camp3::VERSION}"
+
+    # @private
+    attr_accessor(*VALID_OPTIONS_KEYS)
+
+    def configure
+      yield self
+    end
+
+    # Sets all configuration options to their default values
+    # when this module is extended.
+    def self.extended(base)
+      base.reset
+    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
+
+    # 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
+
+    def authz_endpoint
+      'https://launchpad.37signals.com/authorization/new'
+    end
+
+    def token_endpoint
+      'https://launchpad.37signals.com/authorization/token'
+    end
+
+    def api_endpoint
+      raise Camp3::Error::InvalidConfiguration, "missing basecamp account" unless self.account_number
+      
+      "#{self.base_api_endpoint}/#{self.account_number}"
+    end
+
+    def base_api_endpoint
+      "https://3.basecampapi.com"
+    end
+  end
+end

data/lib/camp3/error.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module Camp3
+  module Error
+    # Custom error class for rescuing from all Camp3 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 Camp3::Error::Parsing
+        # Return stringified response when receiving a
+        # parsing error to avoid obfuscation of the
+        # api error.
+        #
+        # note: The Camp3 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 Camp3::ObjectifiedHash
+          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/camp3/logging.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module Camp3
+  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/camp3/objectified_hash.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Camp3
+  # Converts hashes to the objects.
+  class ObjectifiedHash
+    # Creates a new ObjectifiedHash object.
+    def initialize(hash)
+      @hash = hash
+      @data = objectify_data
+    end
+
+    # @return [Hash] The original hash.
+    def to_hash
+      hash
+    end
+    alias to_h to_hash
+
+    # @return [String] Formatted string with the class name, object id and original hash.
+    def inspect
+      "#<#{self.class}:#{object_id} {hash: #{hash.inspect}}"
+    end
+
+    private
+
+    attr_reader :hash, :data
+
+    def objectify_data
+      result = @hash.each_with_object({}) do |(key, value), data|
+        value = objectify_value(value)
+
+        data[key.to_s] = value
+      end
+
+      result
+    end
+
+    def objectify_value(input)  
+      return ObjectifiedHash.new(input) if input.is_a? Hash
+
+      return input unless input.is_a? Array
+
+      input.map { |curr| objectify_value(curr) }
+    end
+
+    # Respond to messages for which `self.data` has a key
+    def method_missing(method_name, *args, &block)
+      @data.key?(method_name.to_s) ? @data[method_name.to_s] : super
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      @hash.keys.map(&:to_sym).include?(method_name.to_sym) || super
+    end
+  end
+end

data/lib/camp3/page_links.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Camp3
+  # Parses link header.
+  #
+  # @private
+  class PageLinks
+    HEADER_LINK = 'Link'
+    DELIM_LINKS = ','
+    LINK_REGEX = /<([^>]+)>; rel="([^"]+)"/.freeze
+    METAS = %w[last next first prev].freeze
+
+    attr_accessor(*METAS)
+
+    def initialize(headers)
+      link_header = headers[HEADER_LINK]
+
+      extract_links(link_header) if link_header && link_header =~ /(next|first|last|prev)/
+    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
+