x 0.7.1 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2dafb18f25e26e173b7496a0c304578e9466bcfe72b964a4af5139200d584f63
-  data.tar.gz: 87d50d5fdda739560a269435ac8572ed3ebc05b5e7245e6234c3d88c5d3e9483
+  metadata.gz: 81a5b12497937f06eb22779e6c78ef9dc18d5e9c5b049c96b4da461b058c6998
+  data.tar.gz: 96f4e02f93df2e39589095f12d5a1e790f17159f932cc1ab72330e301815bda4
 SHA512:
-  metadata.gz: 9d5bc377eafb70ef85d1e112c13bb693723c29df345ecf63c52526263fc051a49fabdf256f85d7f20c5751b85d96ee5e9cc5e39c960c369772b4e41ec875dcaa
-  data.tar.gz: c7f3ff170223b8448d10d44e9903b64bf4c0f3ab885569455fd8c7c7a5d16f76ff34f329722e531d4126575fba8bb785bbb292bff2d7447cf468fa6b47356f94
+  metadata.gz: f8540864206f44e6863653ec538d076d4f1c696dab4fff2b8eeb33b587603301d2d62faedb163c59cc9366439b28a29acff4068876b4013a05bf88090c61042f
+  data.tar.gz: ef425363ab320f922e9f05f28f4d21a8090b763ef0d2468dfcd0ff7b9d0c456efa7f0a21b034fc750e5d927aafd5c4ae1b9407696d242512a44c7114e4efda4a

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 ## [Unreleased]
 
+## [0.8.1] - 2023-09-20
+
+- Fix bug where setting Connection#base_uri= doesn't update the HTTP client (d5a89db)
+
+## [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",
@@ -70,6 +74,20 @@ The tests for the previous version of this library executed in about 2 seconds.
 
 This code is not littered with comments that are intended to generate documentation. Rather, this code is intended to be simple enough to serve as its own documentation. If you want to understand how something works, don’t read the documentation—it might be wrong—read the code. The code is always right.
 
+## Sponsorship
+
+The X gem is free to use, but with X API pricing tiers, it actually costs money to develop and maintain. By contributing to the project, you help us:
+
+1. Maintain the library: Keeping it up-to-date and secure.
+2. Add new features: Enhancements that make your life easier.
+3. Provide support: Faster responses to issues and feature requests.
+
+⭐️ Bonus: Sponsors will get priority support and influence over the project roadmap. We will also list your name or your company's logo on our GitHub page.
+
+Building and maintaining an open-source project like this takes a considerable amount of time and effort. Your sponsorship can help sustain this project. Even a small monthly donation makes a huge difference!
+
+[Click here to sponsor this project.](https://github.com/sponsors/sferik)
+
 ## Development
 
 1. Checkout and repo:

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,29 +1,40 @@
 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_HOST = "https://api.twitter.com".freeze
+    DEFAULT_PORT = 443
+    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, :http_client
 
     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"
-      @http_client.open_timeout = open_timeout
-      @http_client.read_timeout = read_timeout
-      @http_client.write_timeout = write_timeout
-      @http_client.set_debug_output(debug_output) if debug_output
+    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
+      apply_http_client_settings(
+        open_timeout: open_timeout,
+        read_timeout: read_timeout,
+        write_timeout: write_timeout,
+        debug_output: debug_output
+      )
     end
 
     def send_request(request)
@@ -32,15 +43,53 @@ 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
+      update_http_client_settings
     end
 
     def debug_output
       @http_client.instance_variable_get(:@debug_output)
     end
+
+    private
+
+    def apply_http_client_settings(open_timeout:, read_timeout:, write_timeout:, debug_output:)
+      @http_client.open_timeout = open_timeout
+      @http_client.read_timeout = read_timeout
+      @http_client.write_timeout = write_timeout
+      @http_client.set_debug_output(debug_output) if debug_output
+    end
+
+    def current_http_client_settings
+      {
+        open_timeout: @http_client.open_timeout,
+        read_timeout: @http_client.read_timeout,
+        write_timeout: @http_client.write_timeout,
+        debug_output: debug_output
+      }
+    end
+
+    def update_http_client_settings
+      conditionally_apply_http_client_settings do
+        host = @base_uri.host || DEFAULT_HOST
+        port = @base_uri.port || DEFAULT_PORT
+        @http_client = Net::HTTP.new(host, port)
+        @http_client.use_ssl = @base_uri.scheme == "https"
+      end
+    end
+
+    def conditionally_apply_http_client_settings
+      if @http_client
+        settings = current_http_client_settings
+        yield
+        apply_http_client_settings(**settings)
+      else
+        yield
+      end
+    end
   end
 end

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.1")
 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,82 @@ 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
+    DEFAULT_BASE_URL: String
+    DEFAULT_HOST: String
+    DEFAULT_PORT: Integer
+    DEFAULT_OPEN_TIMEOUT: Integer
+    DEFAULT_READ_TIMEOUT: Integer
+    DEFAULT_WRITE_TIMEOUT: Integer
+    NETWORK_ERRORS: Array[(singleton(::Errno::ECONNREFUSED) | singleton(::Net::OpenTimeout) | singleton(::Net::ReadTimeout))]
     extend Forwardable
-    include Errors
     @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) -> void
     def debug_output: -> IO?
+
+    private
+    def apply_http_client_settings: (open_timeout: Float | Integer, read_timeout: Float | Integer, write_timeout: Float | Integer, debug_output: IO?) -> untyped
+    def current_http_client_settings: -> {open_timeout: Float | Integer, read_timeout: Float | Integer, write_timeout: Float | Integer, debug_output: IO?}
+    def update_http_client_settings: -> untyped
+    def conditionally_apply_http_client_settings: { -> untyped } -> untyped
   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 +161,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.1
 platform: ruby
 authors:
 - Erik Berlin
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-09-02 00:00:00.000000000 Z
+date: 2023-09-20 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
@@ -68,7 +69,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.18
+rubygems_version: 3.4.19
 signing_key:
 specification_version: 4
 summary: A Ruby interface to the X API.

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