x 0.7.1 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2dafb18f25e26e173b7496a0c304578e9466bcfe72b964a4af5139200d584f63
-  data.tar.gz: 87d50d5fdda739560a269435ac8572ed3ebc05b5e7245e6234c3d88c5d3e9483
+  metadata.gz: 0b97ab44334b647867e9fdd400531d6e925a10533fb51be399c669c28d441c67
+  data.tar.gz: 03e6b5b78f62cdef778dea21128e8ea1b56955a1077c5ea040b6640694e7577a
 SHA512:
-  metadata.gz: 9d5bc377eafb70ef85d1e112c13bb693723c29df345ecf63c52526263fc051a49fabdf256f85d7f20c5751b85d96ee5e9cc5e39c960c369772b4e41ec875dcaa
-  data.tar.gz: c7f3ff170223b8448d10d44e9903b64bf4c0f3ab885569455fd8c7c7a5d16f76ff34f329722e531d4126575fba8bb785bbb292bff2d7447cf468fa6b47356f94
+  metadata.gz: 47b47a9e6f98e6a61933d7f8f53d2477b2e921206894b2907171f04c2d94da05ebdbb25b501824240997d07c935cc0d2ea1269c6082e7488800c6c7d141f9c0e
+  data.tar.gz: a642eb6fa5e9b61b3cbcf7fff91506e7f44c6b5b5e7a7f16c4cc5ce7ed57d8d19191583fad4bd2bc174c8e9f010546c34d8c83a1b46444de3685805a4b6471dc

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 ## [Unreleased]
 
+## [0.8.0] - 2023-09-14
+
+- Add (back) bearer token authentication (62e141d)
+- Follow redirects (90a8c55)
+- Parse error responses with Content-Type: application/problem+json (0b697d9)
+
 ## [0.7.1] - 2023-09-02
 
 - Fix bug in X::Authenticator#split_uri (ebc9d5f)

data/README.md

@@ -1,6 +1,8 @@
-# X
+# A [Ruby](https://www.ruby-lang.org) interface to the [X API](https://developer.x.com)
 
-#### A Ruby interface to the X API.
+## Follow
+
+For updates and announcements, follow [this gem](https://x.com/gem) and [its creator](https://x.com/sferik) on X.
 
 ## Installation
 
@@ -14,9 +16,11 @@ Or, if Bundler is not being used to manage dependencies:
 
 ## Usage
 
-First, obtain X credentails from https://developer.x.com.
+First, obtain X credentails from <https://developer.x.com>.
 
 ```ruby
+require "x"
+
 x_credentials = {
   api_key:             "INSERT YOUR X API KEY HERE",
   api_key_secret:      "INSERT YOUR X API KEY SECRET HERE",

data/Rakefile

@@ -4,7 +4,7 @@ require "rake/testtask"
 Rake::TestTask.new(:test) do |t|
   t.libs << "test"
   t.libs << "lib"
-  t.test_files = FileList["test/**/test_*.rb"]
+  t.test_files = FileList["test/**/*_test.rb"]
 end
 
 require "standard/rake"

data/lib/x/bearer_token_authenticator.rb

@@ -0,0 +1,14 @@
+module X
+  # Handles bearer token authentication
+  class BearerTokenAuthenticator
+    attr_accessor :bearer_token
+
+    def initialize(bearer_token)
+      @bearer_token = bearer_token
+    end
+
+    def header(_request)
+      "Bearer #{bearer_token}"
+    end
+  end
+end

data/lib/x/client.rb

@@ -1,7 +1,8 @@
 require "forwardable"
-require_relative "authenticator"
-require_relative "client_defaults"
+require_relative "bearer_token_authenticator"
+require_relative "oauth_authenticator"
 require_relative "connection"
+require_relative "redirect_handler"
 require_relative "request_builder"
 require_relative "response_handler"
 
@@ -9,25 +10,36 @@ module X
   # Main public interface
   class Client
     extend Forwardable
-    include ClientDefaults
 
-    def_delegators :@authenticator, :api_key, :api_key_secret, :access_token, :access_token_secret
-    def_delegators :@authenticator, :api_key=, :api_key_secret=, :access_token=, :access_token_secret=
-    def_delegators :@connection, :base_url, :open_timeout, :read_timeout, :write_timeout, :debug_output
-    def_delegators :@connection, :base_url=, :open_timeout=, :read_timeout=, :write_timeout=, :debug_output=
+    def_delegators :@authenticator, :bearer_token, :api_key, :api_key_secret, :access_token, :access_token_secret
+    def_delegators :@authenticator, :bearer_token=, :api_key=, :api_key_secret=, :access_token=, :access_token_secret=
+    def_delegators :@connection, :base_uri, :open_timeout, :read_timeout, :write_timeout, :debug_output
+    def_delegators :@connection, :base_uri=, :open_timeout=, :read_timeout=, :write_timeout=, :debug_output=
     def_delegators :@request_builder, :content_type, :user_agent
     def_delegators :@request_builder, :content_type=, :user_agent=
     def_delegators :@response_handler, :array_class, :object_class
     def_delegators :@response_handler, :array_class=, :object_class=
 
-    def initialize(api_key:, api_key_secret:, access_token:, access_token_secret:,
-      base_url: DEFAULT_BASE_URL, content_type: DEFAULT_CONTENT_TYPE, user_agent: DEFAULT_USER_AGENT,
-      open_timeout: DEFAULT_OPEN_TIMEOUT, read_timeout: DEFAULT_READ_TIMEOUT, write_timeout: DEFAULT_WRITE_TIMEOUT,
-      debug_output: nil, array_class: DEFAULT_ARRAY_CLASS, object_class: DEFAULT_OBJECT_CLASS)
-      @authenticator = Authenticator.new(api_key, api_key_secret, access_token, access_token_secret)
-      @connection = Connection.new(base_url, open_timeout, read_timeout, write_timeout, debug_output: debug_output)
-      @request_builder = RequestBuilder.new(content_type, user_agent)
-      @response_handler = ResponseHandler.new(array_class, object_class)
+    def initialize(bearer_token: nil,
+      api_key: nil, api_key_secret: nil, access_token: nil, access_token_secret: nil,
+      base_url: Connection::DEFAULT_BASE_URL,
+      open_timeout: Connection::DEFAULT_OPEN_TIMEOUT,
+      read_timeout: Connection::DEFAULT_READ_TIMEOUT,
+      write_timeout: Connection::DEFAULT_WRITE_TIMEOUT,
+      content_type: RequestBuilder::DEFAULT_CONTENT_TYPE,
+      user_agent: RequestBuilder::DEFAULT_USER_AGENT,
+      debug_output: nil,
+      array_class: ResponseHandler::DEFAULT_ARRAY_CLASS,
+      object_class: ResponseHandler::DEFAULT_OBJECT_CLASS,
+      max_redirects: RedirectHandler::DEFAULT_MAX_REDIRECTS)
+
+      initialize_authenticator(bearer_token, api_key, api_key_secret, access_token, access_token_secret)
+      @connection = Connection.new(base_url: base_url, open_timeout: open_timeout, read_timeout: read_timeout,
+        write_timeout: write_timeout, debug_output: debug_output)
+      @request_builder = RequestBuilder.new(content_type: content_type, user_agent: user_agent)
+      @redirect_handler = RedirectHandler.new(@authenticator, @connection, @request_builder,
+        max_redirects: max_redirects)
+      @response_handler = ResponseHandler.new(array_class: array_class, object_class: object_class)
     end
 
     def get(endpoint)
@@ -48,10 +60,24 @@ module X
 
     private
 
+    def initialize_authenticator(bearer_token, api_key, api_key_secret, access_token, access_token_secret)
+      @authenticator = if bearer_token
+        BearerTokenAuthenticator.new(bearer_token)
+      elsif api_key && api_key_secret && access_token && access_token_secret
+        OauthAuthenticator.new(api_key, api_key_secret, access_token, access_token_secret)
+      else
+        raise ArgumentError,
+          "Client must be initialized with either a bearer_token or " \
+          "an api_key, api_key_secret, access_token, and access_token_secret"
+      end
+    end
+
     def send_request(http_method, endpoint, body = nil)
-      request = @request_builder.build(@authenticator, http_method, base_url, endpoint, body: body)
+      uri = URI.join(base_uri.to_s, endpoint)
+      request = @request_builder.build(@authenticator, http_method, uri, body: body)
       response = @connection.send_request(request)
-      @response_handler.handle(response)
+      final_response = @redirect_handler.handle_redirects(response, request, base_uri)
+      @response_handler.handle(final_response)
     end
   end
 end

data/lib/x/connection.rb

@@ -1,25 +1,34 @@
 require "forwardable"
 require "net/http"
 require "uri"
-require_relative "errors/errors"
 require_relative "errors/network_error"
 
 module X
   # Sends HTTP requests
   class Connection
     extend Forwardable
-    include Errors
 
-    attr_reader :base_url
+    DEFAULT_BASE_URL = "https://api.twitter.com/2/".freeze
+    DEFAULT_OPEN_TIMEOUT = 60 # seconds
+    DEFAULT_READ_TIMEOUT = 60 # seconds
+    DEFAULT_WRITE_TIMEOUT = 60 # seconds
+    NETWORK_ERRORS = [
+      Errno::ECONNREFUSED,
+      Net::OpenTimeout,
+      Net::ReadTimeout
+    ].freeze
+
+    attr_reader :base_uri
 
     def_delegators :@http_client, :open_timeout, :read_timeout, :write_timeout
     def_delegators :@http_client, :open_timeout=, :read_timeout=, :write_timeout=
     def_delegator :@http_client, :set_debug_output, :debug_output=
 
-    def initialize(url, open_timeout, read_timeout, write_timeout, debug_output: nil)
-      self.base_url = url
-      @http_client = Net::HTTP.new(base_url.host, base_url.port) if base_url.host
-      @http_client.use_ssl = base_url.scheme == "https"
+    def initialize(base_url: DEFAULT_BASE_URL, open_timeout: DEFAULT_OPEN_TIMEOUT,
+      read_timeout: DEFAULT_READ_TIMEOUT, write_timeout: DEFAULT_WRITE_TIMEOUT, debug_output: nil)
+      self.base_uri = base_url
+      @http_client = Net::HTTP.new(base_uri.host, base_uri.port) if base_uri.host
+      @http_client.use_ssl = base_uri.scheme == "https"
       @http_client.open_timeout = open_timeout
       @http_client.read_timeout = read_timeout
       @http_client.write_timeout = write_timeout
@@ -32,11 +41,11 @@ module X
       raise NetworkError, "Network error: #{e.message}"
     end
 
-    def base_url=(new_base_url)
-      uri = URI(new_base_url)
-      raise ArgumentError, "Invalid base URL" unless uri.is_a?(URI::HTTPS) || uri.is_a?(URI::HTTP)
+    def base_uri=(base_url)
+      base_uri = URI(base_url)
+      raise ArgumentError, "Invalid base URL" unless base_uri.is_a?(URI::HTTPS) || base_uri.is_a?(URI::HTTP)
 
-      @base_url = uri
+      @base_uri = base_uri
     end
 
     def debug_output

data/lib/x/errors/error.rb

@@ -1,24 +1,16 @@
 require "json"
 require "net/http"
-require_relative "../client_defaults"
 
 module X
   # Base error class
   class Error < ::StandardError
-    include ClientDefaults
+    JSON_CONTENT_TYPE_REGEXP = %r{application/(problem\+|)json}
+
     attr_reader :object
 
-    def initialize(msg, response:, array_class: DEFAULT_ARRAY_CLASS, object_class: DEFAULT_OBJECT_CLASS)
-      if json_response?(response)
-        @object = JSON.parse(response.body, array_class: array_class, object_class: object_class)
-      end
+    def initialize(msg, response:)
+      @object = JSON.parse(response.body || "{}") if JSON_CONTENT_TYPE_REGEXP.match?(response["content-type"])
       super(msg)
     end
-
-    private
-
-    def json_response?(response)
-      response.is_a?(Net::HTTPResponse) && response.body && response["content-type"] == DEFAULT_CONTENT_TYPE
-    end
   end
 end

data/lib/x/errors/too_many_redirects_error.rb

@@ -0,0 +1,5 @@
+require_relative "client_error"
+
+module X
+  class TooManyRedirectsError < ClientError; end
+end

data/lib/x/errors/too_many_requests_error.rb

@@ -1,12 +1,9 @@
 require_relative "client_error"
-require_relative "../client_defaults"
 
 module X
   # Rate limit error
   class TooManyRequestsError < ClientError
-    include ClientDefaults
-
-    def initialize(msg, response:, array_class: DEFAULT_ARRAY_CLASS, object_class: DEFAULT_OBJECT_CLASS)
+    def initialize(msg, response:)
       @response = response
       super
     end

data/lib/x/oauth_authenticator.rb

@@ -0,0 +1,95 @@
+require "base64"
+require "cgi"
+require "json"
+require "openssl"
+require "securerandom"
+require "uri"
+
+module X
+  # Handles OAuth authentication
+  class OauthAuthenticator
+    OAUTH_VERSION = "1.0".freeze
+    OAUTH_SIGNATURE_METHOD = "HMAC-SHA1".freeze
+    OAUTH_SIGNATURE_ALGORITHM = "sha1".freeze
+
+    attr_accessor :api_key, :api_key_secret, :access_token, :access_token_secret
+
+    def initialize(api_key, api_key_secret, access_token, access_token_secret)
+      @api_key = api_key
+      @api_key_secret = api_key_secret
+      @access_token = access_token
+      @access_token_secret = access_token_secret
+    end
+
+    def header(request)
+      method, url, query_params = parse_request(request)
+      build_oauth_header(method, url, query_params)
+    end
+
+    private
+
+    def parse_request(request)
+      uri = request.uri
+      query_params = parse_query_params(uri.query.to_s)
+      [request.method, uri_without_query(uri), query_params]
+    end
+
+    def parse_query_params(query_string)
+      URI.decode_www_form(query_string).to_h
+    end
+
+    def uri_without_query(uri)
+      uri.to_s.chomp("?#{uri.query}")
+    end
+
+    def build_oauth_header(method, url, query_params)
+      oauth_params = default_oauth_params
+      all_params = query_params.merge(oauth_params)
+      oauth_params["oauth_signature"] = generate_signature(method, url, all_params)
+      format_oauth_header(oauth_params)
+    end
+
+    def default_oauth_params
+      {
+        "oauth_consumer_key" => api_key,
+        "oauth_nonce" => SecureRandom.hex,
+        "oauth_signature_method" => OAUTH_SIGNATURE_METHOD,
+        "oauth_timestamp" => Time.now.utc.to_i.to_s,
+        "oauth_token" => access_token,
+        "oauth_version" => OAUTH_VERSION
+      }
+    end
+
+    def generate_signature(method, url, params)
+      base_string = signature_base_string(method, url, params)
+      hmac_signature(base_string)
+    end
+
+    def hmac_signature(base_string)
+      digest = OpenSSL::Digest.new(OAUTH_SIGNATURE_ALGORITHM)
+      hmac = OpenSSL::HMAC.digest(digest, signing_key, base_string)
+      Base64.strict_encode64(hmac)
+    end
+
+    def signature_base_string(method, url, params)
+      "#{method}&#{encode(url)}&#{encode(encode_params(params))}"
+    end
+
+    def encode_params(params)
+      params.sort.map { |k, v| "#{k}=#{encode(v.to_s)}" }.join("&")
+    end
+
+    def signing_key
+      "#{encode(api_key_secret)}&#{encode(access_token_secret)}"
+    end
+
+    def format_oauth_header(params)
+      "OAuth #{params.sort.map { |k, v| "#{k}=\"#{encode(v.to_s)}\"" }.join(", ")}"
+    end
+
+    def encode(value)
+      # TODO: Replace CGI.escape with CGI.escapeURIComponent when support for Ruby 3.1 is dropped
+      CGI.escape(value.to_s).gsub("+", "%20")
+    end
+  end
+end

data/lib/x/redirect_handler.rb

@@ -0,0 +1,56 @@
+require "net/http"
+require "uri"
+require_relative "connection"
+require_relative "errors/too_many_redirects_error"
+
+module X
+  # Handles HTTP redirects
+  class RedirectHandler
+    DEFAULT_MAX_REDIRECTS = 10
+
+    attr_reader :authenticator, :connection, :request_builder, :max_redirects
+
+    def initialize(authenticator, connection, request_builder, max_redirects: DEFAULT_MAX_REDIRECTS)
+      @authenticator = authenticator
+      @connection = connection
+      @request_builder = request_builder
+      @max_redirects = max_redirects
+    end
+
+    def handle_redirects(response, original_request, original_base_url, redirect_count = 0)
+      if response.is_a?(Net::HTTPRedirection)
+        raise TooManyRedirectsError.new("Too many redirects", response: response) if redirect_count >= max_redirects
+
+        new_uri = build_new_uri(response, original_base_url)
+        new_request = build_request(original_request, new_uri)
+        new_response = send_new_request(new_uri, new_request)
+
+        handle_redirects(new_response, new_request, original_base_url, redirect_count + 1)
+      else
+        response
+      end
+    end
+
+    private
+
+    def build_new_uri(response, original_base_url)
+      location = response["location"].to_s
+      new_uri = URI.parse(location)
+      new_uri = URI.join(original_base_url.to_s, location) if new_uri.relative?
+      new_uri
+    end
+
+    def build_request(original_request, new_uri)
+      http_method = original_request.method.downcase.to_sym
+      body = original_request.body if original_request.body
+      request_builder.build(authenticator, http_method, new_uri, body: body)
+    end
+
+    def send_new_request(new_uri, new_request)
+      @connection = Connection.new(base_url: new_uri, open_timeout: connection.open_timeout,
+        read_timeout: connection.read_timeout, write_timeout: connection.write_timeout,
+        debug_output: connection.debug_output)
+      connection.send_request(new_request)
+    end
+  end
+end

data/lib/x/request_builder.rb

@@ -1,5 +1,6 @@
 require "net/http"
 require "uri"
+require_relative "version"
 
 module X
   # Creates HTTP requests
@@ -10,16 +11,20 @@ module X
       put: Net::HTTP::Put,
       delete: Net::HTTP::Delete
     }.freeze
+    DEFAULT_CONTENT_TYPE = "application/json; charset=utf-8".freeze
+    DEFAULT_USER_AGENT = "X-Client/#{VERSION} Ruby/#{RUBY_VERSION}".freeze
+    AUTHORIZATION_HEADER = "Authorization".freeze
+    CONTENT_TYPE_HEADER = "Content-Type".freeze
+    USER_AGENT_HEADER = "User-Agent".freeze
 
     attr_accessor :content_type, :user_agent
 
-    def initialize(content_type, user_agent)
+    def initialize(content_type: DEFAULT_CONTENT_TYPE, user_agent: DEFAULT_USER_AGENT)
       @content_type = content_type
       @user_agent = user_agent
     end
 
-    def build(authenticator, http_method, base_url, endpoint, body: nil)
-      url = URI.join(base_url.to_s, endpoint)
+    def build(authenticator, http_method, url, body: nil)
       request = create_request(http_method, url, body)
       add_authorization(request, authenticator)
       add_content_type(request)
@@ -40,15 +45,15 @@ module X
     end
 
     def add_authorization(request, authenticator)
-      authenticator.sign!(request)
+      request.add_field(AUTHORIZATION_HEADER, authenticator.header(request))
     end
 
     def add_content_type(request)
-      request.add_field("Content-Type", content_type) if content_type
+      request.add_field(CONTENT_TYPE_HEADER, content_type) if content_type
     end
 
     def add_user_agent(request)
-      request.add_field("User-Agent", user_agent) if user_agent
+      request.add_field(USER_AGENT_HEADER, user_agent) if user_agent
     end
   end
 end

data/lib/x/response_handler.rb

@@ -1,16 +1,32 @@
 require "json"
 require "net/http"
-require_relative "errors/errors"
+require_relative "errors/bad_request_error"
+require_relative "errors/authentication_error"
+require_relative "errors/forbidden_error"
+require_relative "errors/not_found_error"
+require_relative "errors/too_many_requests_error"
+require_relative "errors/server_error"
+require_relative "errors/service_unavailable_error"
 
 module X
   # Process HTTP responses
   class ResponseHandler
-    include ClientDefaults
-    include Errors
+    DEFAULT_ARRAY_CLASS = Array
+    DEFAULT_OBJECT_CLASS = Hash
+    ERROR_CLASSES = {
+      400 => BadRequestError,
+      401 => AuthenticationError,
+      403 => ForbiddenError,
+      404 => NotFoundError,
+      429 => TooManyRequestsError,
+      500 => ServerError,
+      503 => ServiceUnavailableError
+    }.freeze
+    JSON_CONTENT_TYPE_REGEXP = %r{application/(problem\+|)json}
 
     attr_accessor :array_class, :object_class
 
-    def initialize(array_class, object_class)
+    def initialize(array_class: DEFAULT_ARRAY_CLASS, object_class: DEFAULT_OBJECT_CLASS)
       @array_class = array_class
       @object_class = object_class
     end
@@ -22,13 +38,13 @@ module X
 
       error_class = ERROR_CLASSES[response.code.to_i] || Error
       error_message = "#{response.code} #{response.message}"
-      raise error_class.new(error_message, response: response, array_class: array_class, object_class: object_class)
+      raise error_class.new(error_message, response: response)
     end
 
     private
 
     def successful_json_response?(response)
-      response.is_a?(Net::HTTPSuccess) && response.body && response["content-type"] == DEFAULT_CONTENT_TYPE
+      response.is_a?(Net::HTTPSuccess) && response.body && JSON_CONTENT_TYPE_REGEXP.match?(response["content-type"])
     end
   end
 end

data/lib/x/version.rb

@@ -1,5 +1,5 @@
 require "rubygems/version"
 
 module X
-  VERSION = Gem::Version.create("0.7.1")
+  VERSION = Gem::Version.create("0.8.0")
 end

data/sig/x.rbs

@@ -1,44 +1,44 @@
 module X
   VERSION: Gem::Version
 
-  class Authenticator
+  class BearerTokenAuthenticator
+    attr_accessor bearer_token: String
+    def initialize: (String bearer_token) -> void
+    def header: (Net::HTTPRequest _request) -> String
+  end
+
+  class OauthAuthenticator
     OAUTH_VERSION: String
     OAUTH_SIGNATURE_METHOD: String
+    OAUTH_SIGNATURE_ALGORITHM: String
 
     attr_accessor api_key: String
     attr_accessor api_key_secret: String
     attr_accessor access_token: String
     attr_accessor access_token_secret: String
     def initialize: (String api_key, String api_key_secret, String access_token, String access_token_secret) -> void
-    def sign!: (Net::HTTPRequest request) -> void
+    def header: (Net::HTTPRequest request) -> String
 
     private
-    def split_uri: (URI::Generic uri) -> [String, Hash[String, String]]
-    def oauth_header: (String method, String uri, Hash[String, String] query_params) -> String
+    def parse_request: (Net::HTTPRequest request) -> [String, String, Hash[String, String]]
+    def parse_query_params: (String query_string) -> Hash[String, String]
+    def uri_without_query: (URI::Generic uri) -> String
+    def build_oauth_header: (String method, String url, Hash[String, String] query_params) -> String
     def default_oauth_params: -> Hash[String, String]
-    def generate_signature: (String method, String uri, Hash[String, String] params) -> String
-    def signature_base_string: (String method, String uri, Hash[String, String] params) -> String
+    def generate_signature: (String method, String url, Hash[String, String] params) -> String
+    def hmac_signature: (String base_string) -> String
+    def signature_base_string: (String method, String url, Hash[String, String] params) -> String
     def encode_params: (Hash[String, String] params) -> String
     def signing_key: -> String
-    def formatted_oauth_header: (Hash[String, String] params) -> String
-  end
-
-  module ClientDefaults
-    DEFAULT_BASE_URL: String
-    DEFAULT_CONTENT_TYPE: String
-    DEFAULT_OPEN_TIMEOUT: Integer
-    DEFAULT_READ_TIMEOUT: Integer
-    DEFAULT_WRITE_TIMEOUT: Integer
-    DEFAULT_USER_AGENT: String
-    DEFAULT_ARRAY_CLASS: Class
-    DEFAULT_OBJECT_CLASS: Class
+    def format_oauth_header: (Hash[String, String] params) -> String
+    def encode: (String value) -> String
   end
 
   class Error < StandardError
-    include ClientDefaults
+    JSON_CONTENT_TYPE_REGEXP: Regexp
 
-    attr_reader object: untyped
-    def initialize: (String msg, response: Net::HTTPResponse, ?array_class: Class, ?object_class: Class) -> void
+    attr_reader object: Hash[String, untyped]
+    def initialize: (String msg, response: Net::HTTPResponse) -> void
 
     private
     def json_response?: (Net::HTTPResponse response) -> bool
@@ -59,11 +59,13 @@ module X
   class NotFoundError < ClientError
   end
 
+  class TooManyRedirectsError < ClientError
+  end
+
   class TooManyRequestsError < ClientError
-    include ClientDefaults
     @response: Net::HTTPResponse
 
-    def initialize: (String msg, response: Net::HTTPResponse, ?array_class: Class, ?object_class: Class) -> void
+    def initialize: (String msg, response: Net::HTTPResponse) -> void
     def limit: -> Integer
     def remaining: -> Integer
     def reset_at: -> Time
@@ -76,49 +78,75 @@ module X
   class ServiceUnavailableError < ServerError
   end
 
-  module Errors
-    ERROR_CLASSES: Hash[Integer, singleton(AuthenticationError) | singleton(BadRequestError) | singleton(ForbiddenError) | singleton(NotFoundError) | singleton(ServerError) | singleton(ServiceUnavailableError) | singleton(TooManyRequestsError)]
-    NETWORK_ERRORS: Array[(singleton(::Errno::ECONNREFUSED) | singleton(::Net::OpenTimeout) | singleton(::Net::ReadTimeout))]
-  end
-
   class NetworkError < Error
   end
 
   class Connection
     extend Forwardable
-    include Errors
+
+    DEFAULT_BASE_URL: String
+    DEFAULT_OPEN_TIMEOUT: Integer
+    DEFAULT_READ_TIMEOUT: Integer
+    DEFAULT_WRITE_TIMEOUT: Integer
+    NETWORK_ERRORS: Array[(singleton(::Errno::ECONNREFUSED) | singleton(::Net::OpenTimeout) | singleton(::Net::ReadTimeout))]
     @http_client: Net::HTTP
 
-    attr_reader base_url: URI::Generic
-    def initialize: (URI::Generic | String url, Float | Integer open_timeout, Float | Integer read_timeout, Float | Integer write_timeout, ?debug_output: IO?) -> void
+    attr_reader base_uri: URI::Generic
+    attr_reader open_timeout: Float | Integer 
+    attr_reader read_timeout: Float | Integer 
+    attr_reader write_timeout: Float | Integer 
+    def initialize: (?base_url: URI::Generic | String, ?open_timeout: Float | Integer, ?read_timeout: Float | Integer, ?write_timeout: Float | Integer, ?debug_output: IO?) -> void
     def send_request: (Net::HTTPRequest request) -> Net::HTTPResponse
-    def base_url=: (URI::Generic | String new_base_url) -> URI::Generic
+    def base_uri=: (URI::Generic | String base_url) -> URI::Generic
     def debug_output: -> IO?
   end
 
   class RequestBuilder
     HTTP_METHODS: Hash[::Symbol, (singleton(::Net::HTTP::Get) | singleton(::Net::HTTP::Post) | singleton(::Net::HTTP::Put) | singleton(::Net::HTTP::Delete))]
+    DEFAULT_CONTENT_TYPE: String
+    DEFAULT_USER_AGENT: String
+    AUTHORIZATION_HEADER: String
+    CONTENT_TYPE_HEADER: String
+    USER_AGENT_HEADER: String
 
     attr_accessor content_type: String
     attr_accessor user_agent: String
-    def initialize: (String content_type, String user_agent) -> void
-    def build: (Authenticator authenticator, :delete | :get | :post | :put http_method, URI::Generic base_url, String endpoint, ?body: nil) -> (Net::HTTPRequest)
+    def initialize: (?content_type: String, ?user_agent: String) -> void
+    def build: (BearerTokenAuthenticator | OauthAuthenticator authenticator, Symbol http_method, URI::Generic url, ?body: String?) -> (Net::HTTPRequest)
 
     private
-    def create_request: (:delete | :get | :post | :put http_method, URI::Generic url, nil body) -> (Net::HTTPRequest)
-    def add_authorization: (Net::HTTPRequest request, Authenticator authenticator) -> void
+    def create_request: (Symbol http_method, URI::Generic url, String? body) -> (Net::HTTPRequest)
+    def add_authorization: (Net::HTTPRequest request, BearerTokenAuthenticator | OauthAuthenticator authenticator) -> void
     def add_content_type: (Net::HTTPRequest request) -> void
     def add_user_agent: (Net::HTTPRequest request) -> void
   end
 
+  class RedirectHandler
+    DEFAULT_MAX_REDIRECTS: Integer
+
+    attr_reader authenticator: BearerTokenAuthenticator | OauthAuthenticator
+    attr_reader connection: Connection
+    attr_reader request_builder: RequestBuilder
+    attr_reader max_redirects: Integer
+    def initialize: (BearerTokenAuthenticator | OauthAuthenticator authenticator, Connection connection, RequestBuilder request_builder, ?max_redirects: Integer) -> void
+    def handle_redirects: (Net::HTTPResponse response, Net::HTTPRequest original_request, URI::Generic | String original_base_url, ?Integer redirect_count) -> Net::HTTPResponse
+
+    private
+    def build_new_uri: (Net::HTTPResponse response, URI::Generic | String original_base_url) -> URI::Generic
+    def build_request: (Net::HTTPRequest original_request, URI::Generic new_uri) -> Net::HTTPRequest
+    def send_new_request: (URI::Generic new_uri, Net::HTTPRequest new_request) -> Net::HTTPResponse
+  end
+
   class ResponseHandler
-    include Errors
-    include ClientDefaults
+    DEFAULT_ARRAY_CLASS: Class
+    DEFAULT_OBJECT_CLASS: Class
+    ERROR_CLASSES: Hash[Integer, singleton(AuthenticationError) | singleton(BadRequestError) | singleton(ForbiddenError) | singleton(NotFoundError) | singleton(ServerError) | singleton(ServiceUnavailableError) | singleton(TooManyRequestsError)]
+    JSON_CONTENT_TYPE_REGEXP: Regexp
 
     attr_accessor array_class: Class
     attr_accessor object_class: Class
-    def initialize: (Class array_class, Class object_class) -> void
-    def handle: (Net::HTTPResponse response) -> untyped
+    def initialize: (?array_class: Class, ?object_class: Class) -> void
+    def handle: (Net::HTTPResponse response) -> Hash[String, untyped]
 
     private
     def successful_json_response?: (Net::HTTPResponse response) -> bool
@@ -126,20 +154,21 @@ module X
 
   class Client
     extend Forwardable
-    include ClientDefaults
-    @authenticator: Authenticator
+    @authenticator: BearerTokenAuthenticator | OauthAuthenticator
     @connection: Connection
     @request_builder: RequestBuilder
+    @redirect_handler: RedirectHandler
     @response_handler: ResponseHandler
 
-    attr_reader base_url: URI::Generic
-    def initialize: (api_key: String, api_key_secret: String, access_token: String, access_token_secret: String, ?base_url: URI::Generic | String, ?content_type: String, ?user_agent: String, ?open_timeout: Float | Integer, ?read_timeout: Float | Integer, ?write_timeout: Float | Integer, ?debug_output: IO?, ?array_class: Class, ?object_class: Class) -> void
-    def get: (String endpoint) -> untyped
-    def post: (String endpoint, ?nil body) -> untyped
-    def put: (String endpoint, ?nil body) -> untyped
-    def delete: (String endpoint) -> untyped
+    attr_reader base_uri: URI::Generic
+    def initialize: (?bearer_token: String?, ?api_key: String?, ?api_key_secret: String?, ?access_token: String?, ?access_token_secret: String?, ?base_url: URI::Generic | String, ?content_type: String, ?user_agent: String, ?open_timeout: Float | Integer, ?read_timeout: Float | Integer, ?write_timeout: Float | Integer, ?debug_output: IO?, ?array_class: Class, ?object_class: Class, ?max_redirects: Integer) -> void
+    def get: (String endpoint) -> Hash[String, untyped]
+    def post: (String endpoint, ?nil body) -> Hash[String, untyped]
+    def put: (String endpoint, ?nil body) -> Hash[String, untyped]
+    def delete: (String endpoint) -> Hash[String, untyped]
 
     private
-    def send_request: (:delete | :get | :post | :put http_method, String endpoint, ?nil body) -> untyped
+    def initialize_authenticator: (String? bearer_token, String? api_key, String? api_key_secret, String? access_token, String? access_token_secret) -> (BearerTokenAuthenticator | OauthAuthenticator)
+    def send_request: (Symbol http_method, String endpoint, ?nil body) -> Hash[String, untyped]
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: x
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.8.0
 platform: ruby
 authors:
 - Erik Berlin
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-09-02 00:00:00.000000000 Z
+date: 2023-09-14 00:00:00.000000000 Z
 dependencies: []
 description:
 email:
@@ -25,21 +25,22 @@ files:
 - Rakefile
 - Steepfile
 - lib/x.rb
-- lib/x/authenticator.rb
+- lib/x/bearer_token_authenticator.rb
 - lib/x/client.rb
-- lib/x/client_defaults.rb
 - lib/x/connection.rb
 - lib/x/errors/authentication_error.rb
 - lib/x/errors/bad_request_error.rb
 - lib/x/errors/client_error.rb
 - lib/x/errors/error.rb
-- lib/x/errors/errors.rb
 - lib/x/errors/forbidden_error.rb
 - lib/x/errors/network_error.rb
 - lib/x/errors/not_found_error.rb
 - lib/x/errors/server_error.rb
 - lib/x/errors/service_unavailable_error.rb
+- lib/x/errors/too_many_redirects_error.rb
 - lib/x/errors/too_many_requests_error.rb
+- lib/x/oauth_authenticator.rb
+- lib/x/redirect_handler.rb
 - lib/x/request_builder.rb
 - lib/x/response_handler.rb
 - lib/x/version.rb

data/lib/x/authenticator.rb

@@ -1,82 +0,0 @@
-require "base64"
-require "cgi"
-require "json"
-require "openssl"
-require "securerandom"
-require "uri"
-
-module X
-  # Handles OAuth authentication
-  class Authenticator
-    attr_accessor :api_key, :api_key_secret, :access_token, :access_token_secret
-
-    OAUTH_VERSION = "1.0".freeze
-    OAUTH_SIGNATURE_METHOD = "HMAC-SHA1".freeze
-
-    def initialize(api_key, api_key_secret, access_token, access_token_secret)
-      @api_key = api_key
-      @api_key_secret = api_key_secret
-      @access_token = access_token
-      @access_token_secret = access_token_secret
-    end
-
-    def sign!(request)
-      method = request.method
-      uri, query_params = split_uri(request.uri)
-      request.add_field("Authorization", oauth_header(method, uri, query_params))
-    end
-
-    private
-
-    def split_uri(uri)
-      query_string = uri.query.to_s
-      uri_base = uri.to_s.chomp("?#{query_string}")
-      query_params = URI.decode_www_form(query_string).to_h
-      [uri_base, query_params]
-    end
-
-    def oauth_header(method, uri, query_params)
-      oauth_params = default_oauth_params
-      all_params = query_params.merge(oauth_params)
-      oauth_params["oauth_signature"] = generate_signature(method, uri, all_params)
-      formatted_oauth_header(oauth_params)
-    end
-
-    def default_oauth_params
-      {
-        "oauth_consumer_key" => @api_key,
-        "oauth_nonce" => SecureRandom.hex,
-        "oauth_signature_method" => OAUTH_SIGNATURE_METHOD,
-        "oauth_timestamp" => Time.now.utc.to_i.to_s,
-        "oauth_token" => @access_token,
-        "oauth_version" => OAUTH_VERSION
-      }
-    end
-
-    def generate_signature(method, uri, params)
-      Base64.encode64(OpenSSL::HMAC.digest(
-        OpenSSL::Digest.new("sha1"),
-        signing_key,
-        signature_base_string(method, uri, params)
-      )).chomp
-    end
-
-    def signature_base_string(method, uri, params)
-      encoded_params = encode_params(params)
-      "#{method}&#{CGI.escape(uri)}&#{CGI.escape(encoded_params)}"
-    end
-
-    def encode_params(params)
-      # TODO: Replace CGI.escape with CGI.escapeURIComponent when support for Ruby 3.1 is dropped
-      params.sort.map { |k, v| "#{k}=#{CGI.escape(v.to_s)}" }.join("&").gsub("+", "%20")
-    end
-
-    def signing_key
-      "#{CGI.escape(@api_key_secret)}&#{CGI.escape(@access_token_secret)}"
-    end
-
-    def formatted_oauth_header(params)
-      "OAuth #{params.sort.map { |k, v| "#{k}=\"#{CGI.escape(v.to_s)}\"" }.join(", ")}"
-    end
-  end
-end

data/lib/x/client_defaults.rb

@@ -1,14 +0,0 @@
-require_relative "version"
-
-module X
-  module ClientDefaults
-    DEFAULT_BASE_URL = "https://api.twitter.com/2/".freeze
-    DEFAULT_CONTENT_TYPE = "application/json; charset=utf-8".freeze
-    DEFAULT_ARRAY_CLASS = Array
-    DEFAULT_OBJECT_CLASS = Hash
-    DEFAULT_OPEN_TIMEOUT = 60 # seconds
-    DEFAULT_READ_TIMEOUT = 60 # seconds
-    DEFAULT_WRITE_TIMEOUT = 60 # seconds
-    DEFAULT_USER_AGENT = "X-Client/#{VERSION} Ruby/#{RUBY_VERSION}".freeze
-  end
-end

data/lib/x/errors/errors.rb

@@ -1,28 +0,0 @@
-require "net/http"
-require_relative "bad_request_error"
-require_relative "authentication_error"
-require_relative "forbidden_error"
-require_relative "not_found_error"
-require_relative "too_many_requests_error"
-require_relative "server_error"
-require_relative "service_unavailable_error"
-
-module X
-  module Errors
-    ERROR_CLASSES = {
-      400 => BadRequestError,
-      401 => AuthenticationError,
-      403 => ForbiddenError,
-      404 => NotFoundError,
-      429 => TooManyRequestsError,
-      500 => ServerError,
-      503 => ServiceUnavailableError
-    }.freeze
-
-    NETWORK_ERRORS = [
-      Errno::ECONNREFUSED,
-      Net::OpenTimeout,
-      Net::ReadTimeout
-    ].freeze
-  end
-end