x 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c40d2b65cf1479d65e6f434d6d9c98cb32ad7aa62b739fd1207b491b7e276e4d
-  data.tar.gz: 6dee4de59342deb6bbc8a5897f7a96e18ae6b7a856083ae84e1ee26580ce7482
+  metadata.gz: 2e5f85bad7fca01ea015e9a7acb13c6652ad6d06f651acacba1609f5299045ab
+  data.tar.gz: e10427f17c76a569c5bea2c6f50cc71d812ea9987db1c288db2e319d976760c8
 SHA512:
-  metadata.gz: d64f01c2f011e53621214597fd1a9ac80e777ce22db2eb5d48c6b2f760743efa2fa3aa6848e6549b3fc25290c80456873262ddf92dbffaff2d134040cb87555f
-  data.tar.gz: 8fc7d2aca33c67534ac775cc97f6afce95ef035716c5799e3571fb7b3a0218fd5b4646b41d8c66f61e3bba1d58f22b6c56c67ca273199b99dd7c55829827215a
+  metadata.gz: f5ab83ea7ee748d3e17c43bc5f7ce55a59685e7d4e10039c5e7cc28f0bca7b31c689e868f763c5f84b7ffcc9ea92f850b578cc14fede2c29cd24e73cad4c4548
+  data.tar.gz: 01cf440dbad6c968d4cf8b83b4ac496d03309904c9d2c2b1aa01a0bd8d2894a5bfec1990ec7a01de488098b69917e82216cd1d53828c3d594ab49a7a6436e6b2

data/.rubocop.yml

@@ -1,4 +1,6 @@
 require:
+ - standard
+ - standard-performance
  - rubocop-minitest
  - rubocop-performance
  - rubocop-rake
@@ -7,6 +9,39 @@ AllCops:
   NewCops: enable
   TargetRubyVersion: 3.0
 
+Layout/ArgumentAlignment:
+  Enabled: true
+  EnforcedStyle: with_fixed_indentation
+
+Layout/ArrayAlignment:
+  Enabled: true
+  EnforcedStyle: with_fixed_indentation
+
+Layout/EndAlignment:
+  Enabled: true
+  EnforcedStyleAlignWith: variable
+
+Layout/HashAlignment:
+  Enabled: true
+  EnforcedHashRocketStyle: key
+  EnforcedColonStyle: key
+  EnforcedLastArgumentHashStyle: always_inspect
+
+Layout/ParameterAlignment:
+  Enabled: true
+  EnforcedStyle: with_fixed_indentation
+  IndentationWidth: ~
+
+Layout/SpaceInsideHashLiteralBraces:
+  Enabled: false
+
+Metrics/ParameterLists:
+  CountKeywordArgs: false
+
+Style/Alias:
+  Enabled: true
+  EnforcedStyle: prefer_alias_method
+
 Style/StringLiterals:
   Enabled: true
   EnforcedStyle: double_quotes
@@ -17,6 +52,3 @@ Style/StringLiteralsInInterpolation:
 
 Style/FrozenStringLiteralComment:
   Enabled: false
-
-Metrics/ParameterLists:
-  CountKeywordArgs: false

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 ## [Unreleased]
 
+## [0.4.0] - 2023-08-06
+
+- Refactor Client into Authenticator, RequestBuilder, Connection, ResponseHandler (6bee1e9)
+- Add configurable open timeout (1000f9d)
+- Allow configuration of content type (f33a732)
+
+## [0.3.0] - 2023-08-04
+
+- Add accessors to X::Client (e61fa73)
+- Add configurable read timeout (41502b9)
+- Handle network-related errors (9ed1fb4)
+- Include response body in errors (a203e6a)
+
 ## [0.2.0] - 2023-08-02
 
 - Allow configuration of base URL (4bc0531)

data/Gemfile

@@ -3,6 +3,7 @@ source "https://rubygems.org"
 # Specify your gem's dependencies in x.gemspec
 gemspec
 
+gem "hashie", ">= 5"
 gem "minitest", ">= 5.19"
 gem "rake", ">= 13.0.6"
 gem "rubocop", ">= 1.21"
@@ -10,4 +11,5 @@ gem "rubocop-minitest", ">= 0.31"
 gem "rubocop-performance", ">= 1.18"
 gem "rubocop-rake", ">= 0.6"
 gem "simplecov", ">= 0.22"
+gem "standard", ">= 1.30.1"
 gem "webmock", ">= 3.18.1"

data/README.md

@@ -1,6 +1,6 @@
 # X
 
-A Ruby interface to the X 2.0 API.
+A Ruby interface to the X API.
 
 ## Installation
 
@@ -15,24 +15,57 @@ If bundler is not being used to manage dependencies, install the gem by executin
 ## Usage
 
 ```ruby
-x_api_key             = "YOUR_X_API_KEY"
-x_api_key_secret      = "YOUR_X_API_KEY_SECRET"
-x_access_token        = "YOUR_X_ACCESS_TOKEN"
-x_access_token_secret = "YOUR_X_ACCESS_TOKEN_SECRET"
-
-x_client = X::Client.new(api_key:             x_api_key,
-                         api_key_secret:      x_api_key_secret,
-                         access_token:        x_access_token,
-                         access_token_secret: x_access_token_secret)
-
-begin
-  response = x_client.get("users/me")
-  puts JSON.pretty_generate(response)
-rescue X::Error => e
-  puts "Error: #{e.message}"
-end
+x_oauth_credentials = {
+  api_key:             "INSERT YOUR X API KEY HERE",
+  api_key_secret:      "INSERT YOUR X API KEY SECRET HERE",
+  access_token:        "INSERT YOUR X API ACCESS TOKEN HERE",
+  access_token_secret: "INSERT YOUR X API ACCESS TOKEN SECRET HERE",
+}
+
+# Initialize X API client with OAuth credentials
+x_client = X::Client.new(**x_oauth_credentials)
+
+# Request yourself
+x_client.get("users/me")
+# {"data"=>{"id"=>"7505382", "name"=>"Erik Berlin", "username"=>"sferik"}}
+
+# Post a tweet
+tweet = x_client.post("tweets", '{"text":"Hello, World! (from @gem)"}')
+# {"data"=>{"edit_history_tweet_ids"=>["1234567890123456789"], "id"=>"1234567890123456789", "text"=>"Hello, World! (from @gem)"}}
+
+# Delete a tweet
+x_client.delete("tweets/#{tweet["data"]["id"]}")
+# {"data"=>{"deleted"=>true}}
+
+# Initialize an API v1.1 client
+v1_client = X::Client.new(base_url: "https://api.twitter.com/1.1/", **x_oauth_credentials)
+
+# Request your account settings
+v1_client.get("account/settings.json")
+
+# Initialize an X Ads API client
+ads_client = X::Client.new(base_url: "https://ads-api.twitter.com/12/", **x_oauth_credentials)
+
+# Request your ad accounts
+ads_client.get("accounts")
 ```
 
+## History and Philosophy
+
+This library is a rewrite of the [Twitter Ruby library](https://github.com/sferik/twitter). Over 16 years, that library ballooned to over 3,000 lines of code (plus 7,500 lines of tests). At the time of writing, this library is about 200 lines of code (plus 200 test lines) and I’d like to keep it that way. That doesn’t mean new features won’t be added over time, but the benefits of potential new features must be weighed against the benefits of simplicity:
+
+* Less code is easier to maintain.
+* Less code means fewer bugs.
+* Less code runs faster.
+
+In the immortal words of [Ezra Zygmuntowicz](https://github.com/ezmobius) and his [Merb](https://github.com/merb) project (may they both rest in peace): “No code is faster than no code.” The fastest code is the code that is never executed because it doesn’t exist. That principle should apply not just to this library itself but to third-party dependencies. At present, this library has one dependency ([oauth](https://rubygems.org/gems/oauth)) and I’d like to keep it that way. If anything, it should have fewer.
+
+The tests for the previous version of this library ran in about 2 seconds. That sounds pretty fast until you see that tests for this library run in 2 hundredths of a second. This means you can automatically run the tests any time you write a file and receive immediate feedback. For such of workflows, 2 seconds feels painfully slow. At the same time, we aim to maintain 100% C0 code coverage.
+
+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—just read the code. The code is always right.
+
+This project conforms to [Standard Ruby](https://github.com/standardrb/standard). Patches that don’t maintain that standard will not be accepted.
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/Rakefile

@@ -7,8 +7,9 @@ Rake::TestTask.new(:test) do |t|
   t.test_files = FileList["test/**/test_*.rb"]
 end
 
+require "standard/rake"
 require "rubocop/rake_task"
 
 RuboCop::RakeTask.new
 
-task default: %i[test rubocop]
+task default: %i[test rubocop standard]

data/lib/x/authenticator.rb

@@ -0,0 +1,43 @@
+require "oauth"
+require "forwardable"
+
+module X
+  # Handles OAuth and bearer token authentication
+  class Authenticator
+    extend Forwardable
+
+    attr_accessor :bearer_token
+
+    def_delegator :@access_token, :secret, :access_token_secret
+    def_delegator :@access_token, :secret=, :access_token_secret=
+    def_delegator :@access_token, :token, :access_token
+    def_delegator :@access_token, :token=, :access_token=
+    def_delegator :@consumer, :key, :api_key
+    def_delegator :@consumer, :key=, :api_key=
+    def_delegator :@consumer, :secret, :api_key_secret
+    def_delegator :@consumer, :secret=, :api_key_secret=
+
+    def initialize(bearer_token:, api_key:, api_key_secret:, access_token:, access_token_secret:)
+      if bearer_token
+        @bearer_token = bearer_token
+      else
+        initialize_oauth(api_key, api_key_secret, access_token, access_token_secret)
+      end
+    end
+
+    def sign!(request)
+      @consumer.sign!(request, @access_token)
+    end
+
+    private
+
+    def initialize_oauth(api_key, api_key_secret, access_token, access_token_secret)
+      unless api_key && api_key_secret && access_token && access_token_secret
+        raise ArgumentError, "Missing OAuth credentials"
+      end
+
+      @consumer = OAuth::Consumer.new(api_key, api_key_secret, site: ClientDefaults::DEFAULT_BASE_URL)
+      @access_token = OAuth::Token.new(access_token, access_token_secret)
+    end
+  end
+end

data/lib/x/client.rb

@@ -1,194 +1,92 @@
-require "json"
-require "net/http"
-require "oauth"
+require "forwardable"
+require_relative "authenticator"
+require_relative "client_defaults"
+require_relative "connection"
+require_relative "request_builder"
+require_relative "response_handler"
 
 module X
-  # HTTP client that handles authentication and requests
+  # Main public interface
   class Client
-    DEFAULT_BASE_URL = "https://api.twitter.com/2/".freeze
-    DEFAULT_USER_AGENT = "X-Client/#{VERSION} Ruby/#{RUBY_VERSION}".freeze
+    extend Forwardable
+    include ClientDefaults
+
+    attr_reader :base_url
+    attr_accessor :content_type, :open_timeout, :read_timeout, :user_agent, :array_class, :object_class
+
+    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 initialize(bearer_token: nil, api_key: nil, api_key_secret: nil, access_token: nil, access_token_secret: nil,
-                   base_url: DEFAULT_BASE_URL, user_agent: DEFAULT_USER_AGENT)
-      @http_request = HttpRequest.new(bearer_token: bearer_token,
-                                      api_key: api_key,
-                                      api_key_secret: api_key_secret,
-                                      access_token: access_token,
-                                      access_token_secret: access_token_secret,
-                                      base_url: base_url,
-                                      user_agent: user_agent)
+      base_url: DEFAULT_BASE_URL, content_type: DEFAULT_CONTENT_TYPE,
+      open_timeout: DEFAULT_OPEN_TIMEOUT, read_timeout: DEFAULT_READ_TIMEOUT, user_agent: DEFAULT_USER_AGENT,
+      array_class: DEFAULT_ARRAY_CLASS, object_class: DEFAULT_OBJECT_CLASS)
+
+      @authenticator = Authenticator.new(bearer_token: bearer_token, api_key: api_key, api_key_secret: api_key_secret,
+        access_token: access_token, access_token_secret: access_token_secret)
+      self.base_url = base_url
+      @content_type = content_type
+      @open_timeout = open_timeout
+      @read_timeout = read_timeout
+      @user_agent = user_agent
+      @array_class = array_class
+      @object_class = object_class
     end
 
     def get(endpoint)
-      handle_response { @http_request.get(endpoint) }
+      send_request(:get, endpoint)
     end
 
     def post(endpoint, body = nil)
-      handle_response { @http_request.post(endpoint, body) }
+      send_request(:post, endpoint, body)
     end
 
     def put(endpoint, body = nil)
-      handle_response { @http_request.put(endpoint, body) }
+      send_request(:put, endpoint, body)
     end
 
     def delete(endpoint)
-      handle_response { @http_request.delete(endpoint) }
+      send_request(:delete, endpoint)
     end
 
-    private
+    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 handle_response
-      response = yield
-      ErrorHandler.new(response).handle
+      @base_url = uri
     end
 
-    # HTTP client requester
-    class HttpRequest
-      HTTP_METHODS = {
-        get: Net::HTTP::Get,
-        post: Net::HTTP::Post,
-        put: Net::HTTP::Put,
-        delete: Net::HTTP::Delete
-      }.freeze
-
-      def initialize(bearer_token: nil, api_key: nil, api_key_secret: nil, access_token: nil, access_token_secret: nil,
-                     base_url: nil, user_agent: nil)
-        @base_url = base_url
-        @use_bearer_token = !bearer_token.nil?
-        @user_agent = user_agent || Client::DEFAULT_USER_AGENT
-
-        if @use_bearer_token
-          @bearer_token = bearer_token
-        else
-          initialize_oauth(api_key, api_key_secret, access_token, access_token_secret)
-        end
-      end
-
-      def get(endpoint)
-        send_request(:get, endpoint)
-      end
-
-      def post(endpoint, body = nil)
-        send_request(:post, endpoint, body)
-      end
-
-      def put(endpoint, body = nil)
-        send_request(:put, endpoint, body)
-      end
-
-      def delete(endpoint)
-        send_request(:delete, endpoint)
-      end
-
-      private
-
-      def initialize_oauth(api_key, api_key_secret, access_token, access_token_secret)
-        unless api_key && api_key_secret && access_token && access_token_secret
-          raise ArgumentError, "Missing OAuth credentials."
-        end
-
-        @consumer = OAuth::Consumer.new(api_key, api_key_secret, site: @base_url)
-        @access_token = OAuth::Token.new(access_token, access_token_secret)
-      end
-
-      def send_request(http_method, endpoint, body = nil)
-        url = URI.parse(@base_url + endpoint)
-        http = Net::HTTP.new(url.host, url.port)
-        http.use_ssl = true
-
-        request = create_request(http_method, url, body)
-        add_authorization(request)
-        add_user_agent(request)
-
-        http.request(request)
-      end
-
-      def create_request(http_method, url, body)
-        http_method_class = HTTP_METHODS[http_method]
+    private
 
-        raise ArgumentError, "Unsupported HTTP method: #{http_method}" unless http_method_class
+    def send_request(http_method, endpoint, body = nil)
+      request = RequestBuilder.build(http_method, @base_url, endpoint, body)
+      add_headers(request)
 
-        request = http_method_class.new(url)
-        request.body = body if body && http_method != :get
-        request
-      end
+      response = Connection.send_request(@base_url, @open_timeout, @read_timeout, request)
 
-      def add_authorization(request)
-        if @use_bearer_token
-          request["Authorization"] = "Bearer #{@bearer_token}"
-        else
-          @consumer.sign!(request, @access_token)
-        end
-      end
-
-      def add_user_agent(request)
-        request["User-Agent"] = @user_agent if @user_agent
-      end
+      ResponseHandler.new(response, @array_class, @object_class).handle
     end
 
-    # HTTP client error handler
-    class ErrorHandler
-      HTTP_STATUS_HANDLERS = {
-        Net::HTTPOK => :handle_success_response,
-        Net::HTTPBadRequest => :handle_bad_request_response,
-        Net::HTTPForbidden => :handle_forbidden_response,
-        Net::HTTPUnauthorized => :handle_unauthorized_response,
-        Net::HTTPNotFound => :handle_not_found_response,
-        Net::HTTPTooManyRequests => :handle_too_many_requests_response,
-        Net::HTTPInternalServerError => :handle_server_error_response,
-        Net::HTTPServiceUnavailable => :handle_service_unavailable_response
-      }.freeze
-
-      def initialize(response)
-        @response = response
-      end
-
-      def handle
-        handler_method = HTTP_STATUS_HANDLERS[@response.class]
-        if handler_method
-          send(handler_method)
-        else
-          handle_unexpected_response
-        end
-      end
-
-      private
-
-      def handle_success_response
-        JSON.parse(@response.body)
-      end
-
-      def handle_bad_request_response
-        raise X::BadRequestError, "Bad request: #{@response.code} #{@response.message}"
-      end
-
-      def handle_forbidden_response
-        raise X::ForbiddenError, "Forbidden: #{@response.code} #{@response.message}"
-      end
-
-      def handle_unauthorized_response
-        raise X::AuthenticationError, "Authentication failed. Please check your credentials."
-      end
-
-      def handle_not_found_response
-        raise X::NotFoundError, "Not found: #{@response.code} #{@response.message}"
-      end
-
-      def handle_too_many_requests_response
-        raise X::TooManyRequestsError, "Too many requests: #{@response.code} #{@response.message}"
-      end
+    def add_headers(request)
+      add_authorization(request)
+      add_content_type(request)
+      add_user_agent(request)
+    end
 
-      def handle_server_error_response
-        raise X::ServerError, "Internal server error: #{@response.code} #{@response.message}"
+    def add_authorization(request)
+      if @authenticator.bearer_token
+        request["Authorization"] = "Bearer #{@bearer_token}"
+      else
+        @authenticator.sign!(request)
       end
+    end
 
-      def handle_service_unavailable_response
-        raise X::ServiceUnavailableError, "Service unavailable: #{@response.code} #{@response.message}"
-      end
+    def add_content_type(request)
+      request["Content-Type"] = @content_type if @content_type
+    end
 
-      def handle_unexpected_response
-        raise X::Error, "Unexpected response: #{@response.code}"
-      end
+    def add_user_agent(request)
+      request["User-Agent"] = @user_agent if @user_agent
     end
   end
 end

data/lib/x/client_defaults.rb

@@ -0,0 +1,13 @@
+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_USER_AGENT = "X-Client/#{Version} Ruby/#{RUBY_VERSION}".freeze
+  end
+end

data/lib/x/connection.rb

@@ -0,0 +1,21 @@
+require "net/http"
+require_relative "errors/network_error"
+require_relative "errors/errors"
+
+module X
+  # Sends HTTP requests
+  class Connection
+    include Errors
+
+    def self.send_request(base_url, open_timeout, read_timeout, request)
+      url = URI(base_url)
+      http = Net::HTTP.new(url.host, url.port)
+      http.use_ssl = url.scheme == "https"
+      http.open_timeout = open_timeout
+      http.read_timeout = read_timeout
+      http.request(request)
+    rescue *NETWORK_ERRORS => e
+      raise NetworkError, "Network error: #{e.message}"
+    end
+  end
+end

data/lib/x/errors/authentication_error.rb

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

data/lib/x/errors/bad_request_error.rb

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

data/lib/x/errors/client_error.rb

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

data/lib/x/errors/error.rb

@@ -0,0 +1,20 @@
+require "json"
+
+module X
+  # Base error class
+  class Error < ::StandardError
+    include ClientDefaults
+    attr_reader :object
+
+    def initialize(msg = nil, response = nil, object_class = DEFAULT_OBJECT_CLASS)
+      @object = JSON.parse(response.body, object_class: object_class) if json_response?(response)
+      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/errors.rb

@@ -0,0 +1,27 @@
+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

data/lib/x/errors/forbidden_error.rb

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

data/lib/x/errors/network_error.rb

@@ -0,0 +1,5 @@
+require_relative "error"
+
+module X
+  class NetworkError < Error; end
+end

data/lib/x/errors/not_found_error.rb

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

data/lib/x/errors/server_error.rb

@@ -0,0 +1,5 @@
+require_relative "error"
+
+module X
+  class ServerError < Error; end
+end

data/lib/x/errors/service_unavailable_error.rb

@@ -0,0 +1,5 @@
+require_relative "server_error"
+
+module X
+  class ServiceUnavailableError < ServerError; end
+end

data/lib/x/errors/too_many_requests_error.rb

@@ -0,0 +1,30 @@
+require "net/http"
+require_relative "client_error"
+
+module X
+  # Rate limit error
+  class TooManyRequestsError < ClientError
+    def initialize(msg, response = nil, object_class = ClientDefaults::DEFAULT_OBJECT_CLASS)
+      @response = response
+      super
+    end
+
+    def limit
+      @response&.fetch("x-rate-limit-limit", 0).to_i
+    end
+
+    def remaining
+      @response&.fetch("x-rate-limit-remaining", 0).to_i
+    end
+
+    def reset_at
+      Time.at(@response&.fetch("x-rate-limit-reset", 0).to_i).utc if @response
+    end
+
+    def reset_in
+      [(reset_at - Time.now).ceil, 0].max if reset_at
+    end
+
+    alias_method :retry_after, :reset_in
+  end
+end

data/lib/x/request_builder.rb

@@ -0,0 +1,29 @@
+require "net/http"
+require "uri"
+
+module X
+  # Creates HTTP requests
+  class RequestBuilder
+    HTTP_METHODS = {
+      get: Net::HTTP::Get,
+      post: Net::HTTP::Post,
+      put: Net::HTTP::Put,
+      delete: Net::HTTP::Delete
+    }.freeze
+
+    def self.build(http_method, base_url, endpoint, body = nil)
+      url = URI.join(base_url, endpoint)
+      create_request(http_method, url, body)
+    end
+
+    def self.create_request(http_method, url, body)
+      http_method_class = HTTP_METHODS[http_method]
+
+      raise ArgumentError, "Unsupported HTTP method: #{http_method}" unless http_method_class
+
+      request = http_method_class.new(url)
+      request.body = body if body && http_method != :get
+      request
+    end
+  end
+end

data/lib/x/response_handler.rb

@@ -0,0 +1,34 @@
+require "json"
+require_relative "errors/errors"
+
+module X
+  # Process HTTP responses
+  class ResponseHandler
+    include ClientDefaults
+    include Errors
+
+    def initialize(response, array_class, object_class)
+      @response = response
+      @array_class = array_class
+      @object_class = object_class
+    end
+
+    def handle
+      if successful_json_response?
+        return JSON.parse(@response.body, array_class: @array_class, object_class: @object_class)
+      end
+
+      error_class = ERROR_CLASSES[@response.code.to_i] || Error
+      error_message = "#{@response.code} #{@response.message}"
+      raise error_class, error_message if @response.body.nil? || @response.body.empty?
+
+      raise error_class.new(error_message, @response)
+    end
+
+    private
+
+    def successful_json_response?
+      @response.is_a?(Net::HTTPSuccess) && @response.body && @response["content-type"] == DEFAULT_CONTENT_TYPE
+    end
+  end
+end

data/lib/x/version.rb

@@ -1,3 +1,39 @@
 module X
-  VERSION = "0.2.0".freeze
+  # The version of this library
+  module Version
+    module_function
+
+    def major
+      0
+    end
+
+    def minor
+      4
+    end
+
+    def patch
+      0
+    end
+
+    def pre
+      nil
+    end
+
+    def to_h
+      {
+        major: major,
+        minor: minor,
+        patch: patch,
+        pre: pre
+      }
+    end
+
+    def to_a
+      [major, minor, patch, pre].compact
+    end
+
+    def to_s
+      to_a.join(".")
+    end
+  end
 end

data/lib/x.rb

@@ -1,3 +1 @@
-require_relative "x/version"
-require_relative "x/errors"
 require_relative "x/client"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: x
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Erik Berlin
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-08-02 00:00:00.000000000 Z
+date: 2023-08-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: oauth
@@ -38,8 +38,23 @@ files:
 - README.md
 - Rakefile
 - lib/x.rb
+- lib/x/authenticator.rb
 - lib/x/client.rb
-- lib/x/errors.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_requests_error.rb
+- lib/x/request_builder.rb
+- lib/x/response_handler.rb
 - lib/x/version.rb
 - sig/x.rbs
 homepage: https://github.com/sferik/x-ruby
@@ -66,8 +81,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.12
+rubygems_version: 3.4.18
 signing_key:
 specification_version: 4
-summary: A Ruby interface to the X 2.0 API.
+summary: A Ruby interface to the X API.
 test_files: []

data/lib/x/errors.rb

@@ -1,11 +0,0 @@
-module X
-  class Error < ::StandardError; end
-  class ClientError < Error; end
-  class AuthenticationError < ClientError; end
-  class BadRequestError < ClientError; end
-  class ForbiddenError < ClientError; end
-  class NotFoundError < ClientError; end
-  class TooManyRequestsError < ClientError; end
-  class ServerError < Error; end
-  class ServiceUnavailableError < ServerError; end
-end