x 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 480eb23ebeb098bcc5c2d4924279d2d4608f8cf2a8e5eb7897edf45cc0311bc4
-  data.tar.gz: c97f4694a91b3d3ad9f60d55001d48080329254d28db75aff74d646264fe38f2
+  metadata.gz: c40d2b65cf1479d65e6f434d6d9c98cb32ad7aa62b739fd1207b491b7e276e4d
+  data.tar.gz: 6dee4de59342deb6bbc8a5897f7a96e18ae6b7a856083ae84e1ee26580ce7482
 SHA512:
-  metadata.gz: 86adf1889c2e820353c4455a08c443480682d4827addd074a7e1fe3e60937e70b638118d31802c8cc57d457865c917d2f1a83d739448659519f42c9cbede74ed
-  data.tar.gz: 714dcea3deff757a2d15548ed1fdbb17749ca5b901e9463a5b3a223120b05974ab792d1c3230406dc07984358a6d9e7c4d781402aa025fa5e257d967ee5ecbcf
+  metadata.gz: d64f01c2f011e53621214597fd1a9ac80e777ce22db2eb5d48c6b2f760743efa2fa3aa6848e6549b3fc25290c80456873262ddf92dbffaff2d134040cb87555f
+  data.tar.gz: 8fc7d2aca33c67534ac775cc97f6afce95ef035716c5799e3571fb7b3a0218fd5b4646b41d8c66f61e3bba1d58f22b6c56c67ca273199b99dd7c55829827215a

data/.rubocop.yml

@@ -15,8 +15,8 @@ Style/StringLiteralsInInterpolation:
   Enabled: true
   EnforcedStyle: double_quotes
 
-Layout/LineLength:
-  Max: 120
-
 Style/FrozenStringLiteralComment:
   Enabled: false
+
+Metrics/ParameterLists:
+  CountKeywordArgs: false

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 ## [Unreleased]
 
+## [0.2.0] - 2023-08-02
+
+- Allow configuration of base URL (4bc0531)
+- Improve error handling (14dc0cd)
+
 ## [0.1.0] - 2023-08-02
 
 - Initial release

data/Gemfile

@@ -9,4 +9,5 @@ gem "rubocop", ">= 1.21"
 gem "rubocop-minitest", ">= 0.31"
 gem "rubocop-performance", ">= 1.18"
 gem "rubocop-rake", ">= 0.6"
+gem "simplecov", ">= 0.22"
 gem "webmock", ">= 3.18.1"

data/README.md

@@ -15,17 +15,20 @@ If bundler is not being used to manage dependencies, install the gem by executin
 ## Usage
 
 ```ruby
-api_key = "YOUR_X_API_KEY"
-api_key_secret = "YOUR_X_API_KEY_SECRET"
-access_token = "YOUR_X_ACCESS_TOKEN"
-access_token_secret = "YOUR_X_ACCESS_TOKEN_SECRET"
+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: api_key, api_key_secret: api_key_secret, access_token: access_token, access_token_secret: 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 StandardError => e
+rescue X::Error => e
   puts "Error: #{e.message}"
 end
 ```

data/lib/x/client.rb

@@ -1,94 +1,193 @@
-require "oauth"
 require "json"
 require "net/http"
+require "oauth"
 
 module X
-  # Main client that handles HTTP authentication and requests
+  # HTTP client that handles authentication and requests
   class Client
-    BASE_URL = "https://api.twitter.com/2/".freeze
-    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)
-      @use_bearer_token = !bearer_token.nil?
-
-      if @use_bearer_token
-        @bearer_token = bearer_token
-      else
-        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
+    DEFAULT_BASE_URL = "https://api.twitter.com/2/".freeze
+    DEFAULT_USER_AGENT = "X-Client/#{VERSION} Ruby/#{RUBY_VERSION}".freeze
+
+    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)
     end
 
     def get(endpoint)
-      response = send_request(:get, endpoint)
-      handle_response(response)
+      handle_response { @http_request.get(endpoint) }
     end
 
     def post(endpoint, body = nil)
-      response = send_request(:post, endpoint, body)
-      handle_response(response)
+      handle_response { @http_request.post(endpoint, body) }
     end
 
     def put(endpoint, body = nil)
-      response = send_request(:put, endpoint, body)
-      handle_response(response)
+      handle_response { @http_request.put(endpoint, body) }
     end
 
     def delete(endpoint)
-      response = send_request(:delete, endpoint)
-      handle_response(response)
+      handle_response { @http_request.delete(endpoint) }
     end
 
     private
 
-    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
+    def handle_response
+      response = yield
+      ErrorHandler.new(response).handle
+    end
 
-      request = create_request(http_method, url, body)
-      add_authorization(request)
+    # 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
 
-      http.request(request)
-    end
+      def get(endpoint)
+        send_request(:get, endpoint)
+      end
 
-    def create_request(http_method, url, body)
-      http_method_class = HTTP_METHODS[http_method]
+      def post(endpoint, body = nil)
+        send_request(:post, endpoint, body)
+      end
 
-      raise ArgumentError, "Unsupported HTTP method: #{http_method}" unless http_method_class
+      def put(endpoint, body = nil)
+        send_request(:put, endpoint, body)
+      end
 
-      request = http_method_class.new(url)
-      request.body = body if body && http_method != :get
-      request
-    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 add_authorization(request)
-      if @use_bearer_token
-        request["Authorization"] = "Bearer #{@bearer_token}"
-      else
-        @consumer.sign!(request, @access_token)
+      def 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
+
+      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
     end
 
-    def handle_response(response)
-      case response
-      when Net::HTTPSuccess
-        JSON.parse(response.body)
-      when Net::HTTPUnauthorized
+    # 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."
-      when Net::HTTPServerError
-        raise X::ServerError, "An internal server error occurred."
-      else
-        raise X::Error, "Unexpected response: #{response.code} #{response.message}"
+      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 handle_server_error_response
+        raise X::ServerError, "Internal server error: #{@response.code} #{@response.message}"
+      end
+
+      def handle_service_unavailable_response
+        raise X::ServiceUnavailableError, "Service unavailable: #{@response.code} #{@response.message}"
+      end
+
+      def handle_unexpected_response
+        raise X::Error, "Unexpected response: #{@response.code}"
       end
     end
   end

data/lib/x/errors.rb

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

data/lib/x/version.rb

@@ -1,3 +1,3 @@
 module X
-  VERSION = "0.1.0".freeze
+  VERSION = "0.2.0".freeze
 end

data/lib/x.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: x
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Erik Berlin
@@ -39,7 +39,7 @@ files:
 - Rakefile
 - lib/x.rb
 - lib/x/client.rb
-- lib/x/error.rb
+- lib/x/errors.rb
 - lib/x/version.rb
 - sig/x.rbs
 homepage: https://github.com/sferik/x-ruby

data/lib/x/error.rb

@@ -1,5 +0,0 @@
-module X
-  class Error < StandardError; end
-  class AuthenticationError < Error; end
-  class ServerError < Error; end
-end