x 0.19.0 → 1.0.0

data/lib/x/redirect_handler.rb

@@ -1,109 +0,0 @@
-require "net/http"
-require "uri"
-require_relative "authenticator"
-require_relative "connection"
-require_relative "errors/too_many_redirects"
-require_relative "request_builder"
-
-module X
-  # Handles HTTP redirects for API requests
-  # @api public
-  class RedirectHandler
-    # Default maximum number of redirects to follow
-    DEFAULT_MAX_REDIRECTS = 10
-
-    # The maximum number of redirects to follow
-    # @api public
-    # @return [Integer] the maximum number of redirects to follow
-    # @example Get or set the maximum redirects
-    #   handler.max_redirects = 5
-    attr_accessor :max_redirects
-
-    # The connection for making requests
-    # @api public
-    # @return [Connection] the connection for making requests
-    # @example Get the connection
-    #   handler.connection
-    attr_reader :connection
-
-    # The request builder for creating requests
-    # @api public
-    # @return [RequestBuilder] the request builder for creating requests
-    # @example Get the request builder
-    #   handler.request_builder
-    attr_reader :request_builder
-
-    # Initialize a new RedirectHandler
-    #
-    # @api public
-    # @param connection [Connection] the connection for making requests
-    # @param request_builder [RequestBuilder] the request builder for creating requests
-    # @param max_redirects [Integer] the maximum number of redirects to follow
-    # @return [RedirectHandler] a new instance
-    # @example Create a redirect handler
-    #   handler = X::RedirectHandler.new(connection: conn, request_builder: builder)
-    def initialize(connection: Connection.new, request_builder: RequestBuilder.new,
-      max_redirects: DEFAULT_MAX_REDIRECTS)
-      @connection = connection
-      @request_builder = request_builder
-      @max_redirects = max_redirects
-    end
-
-    # Handle redirects for an HTTP response
-    #
-    # @api public
-    # @param response [Net::HTTPResponse] the HTTP response to handle
-    # @param request [Net::HTTPRequest] the original HTTP request
-    # @param base_url [String] the base URL for the request
-    # @param authenticator [Authenticator] the authenticator for requests
-    # @param redirect_count [Integer] the current redirect count
-    # @return [Net::HTTPResponse] the final HTTP response after following redirects
-    # @raise [TooManyRedirects] if the maximum number of redirects is exceeded
-    # @example Handle a response
-    #   response = handler.handle(response: resp, request: req, base_url: url)
-    def handle(response:, request:, base_url:, authenticator: Authenticator.new, redirect_count: 0)
-      if response.is_a?(Net::HTTPRedirection)
-        raise TooManyRedirects, "Too many redirects" if redirect_count > max_redirects
-
-        new_uri = build_new_uri(response, base_url)
-
-        new_request = build_request(request, new_uri, Integer(response.code), authenticator)
-        new_response = connection.perform(request: new_request)
-
-        handle(response: new_response, request: new_request, base_url:, redirect_count: redirect_count + 1)
-      else
-        response
-      end
-    end
-
-    private
-
-    # Build a new URI from the redirect response
-    # @api private
-    # @param response [Net::HTTPResponse] the redirect response
-    # @param base_url [String] the base URL
-    # @return [URI] the new URI
-    def build_new_uri(response, base_url)
-      location = response.fetch("location")
-      # If location is relative, it will join with the original base URL, otherwise it will overwrite it
-      URI.join(base_url, location)
-    end
-
-    # Build a new request for the redirect
-    # @api private
-    # @param request [Net::HTTPRequest] the original request
-    # @param uri [URI] the new URI
-    # @param response_code [Integer] the HTTP response code
-    # @param authenticator [Authenticator] the authenticator
-    # @return [Net::HTTPRequest] the new request
-    def build_request(request, uri, response_code, authenticator)
-      http_method = :get
-      if [307, 308].include?(response_code)
-        http_method = request.method.downcase.to_sym
-        body = request.body
-      end
-
-      request_builder.build(http_method:, uri:, body:, authenticator:)
-    end
-  end
-end

data/lib/x/request_builder.rb

@@ -1,93 +0,0 @@
-require "net/http"
-require "uri"
-require_relative "authenticator"
-require_relative "version"
-
-module X
-  # Builds HTTP requests for the X API
-  # @api public
-  class RequestBuilder
-    # Default headers for API requests
-    DEFAULT_HEADERS = {
-      "Content-Type" => "application/json; charset=utf-8",
-      "User-Agent" => "X-Client/#{VERSION} #{RUBY_ENGINE}/#{RUBY_VERSION} (#{RUBY_PLATFORM})"
-    }.freeze
-    # Mapping of HTTP method symbols to Net::HTTP classes
-    HTTP_METHODS = {
-      get: Net::HTTP::Get,
-      post: Net::HTTP::Post,
-      put: Net::HTTP::Put,
-      delete: Net::HTTP::Delete
-    }.freeze
-
-    # Build an HTTP request
-    #
-    # @api public
-    # @param http_method [Symbol] the HTTP method (:get, :post, :put, :delete)
-    # @param uri [URI] the request URI
-    # @param body [String, nil] the request body
-    # @param headers [Hash] additional headers for the request
-    # @param authenticator [Authenticator] the authenticator for the request
-    # @return [Net::HTTPRequest] the built HTTP request
-    # @raise [ArgumentError] if the HTTP method is not supported
-    # @example Build a GET request
-    #   builder.build(http_method: :get, uri: URI("https://api.x.com/2/users/me"))
-    def build(http_method:, uri:, body: nil, headers: {}, authenticator: Authenticator.new)
-      request = create_request(http_method:, uri:, body:)
-      add_headers(request:, headers:)
-      add_authentication(request:, authenticator:)
-      request
-    end
-
-    private
-
-    # Create an HTTP request
-    # @api private
-    # @param http_method [Symbol] the HTTP method
-    # @param uri [URI] the request URI
-    # @param body [String, nil] the request body
-    # @return [Net::HTTPRequest] the created request
-    def create_request(http_method:, uri:, body:)
-      http_method_class = HTTP_METHODS[http_method]
-
-      raise ArgumentError, "Unsupported HTTP method: #{http_method}" unless http_method_class
-
-      escaped_uri = escape_query_params(uri)
-      request = http_method_class.new(escaped_uri)
-      request.body = body
-      request
-    end
-
-    # Add authentication to a request
-    # @api private
-    # @param request [Net::HTTPRequest] the request
-    # @param authenticator [Authenticator] the authenticator
-    # @return [void]
-    def add_authentication(request:, authenticator:)
-      authenticator.header(request).each do |key, value|
-        request[key] = value
-      end
-    end
-
-    # Add headers to a request
-    # @api private
-    # @param request [Net::HTTPRequest] the request
-    # @param headers [Hash] additional headers
-    # @return [void]
-    def add_headers(request:, headers:)
-      DEFAULT_HEADERS.merge(headers).each do |key, value|
-        request[key] = value
-      end
-    end
-
-    # Escape query parameters in a URI
-    # @api private
-    # @param uri [URI] the URI
-    # @return [URI] the URI with escaped query parameters
-    def escape_query_params(uri)
-      URI(uri).tap do |u|
-        u.query = URI.encode_www_form(URI.decode_www_form(u.query)).gsub("%2C", ",") if u.query
-      end
-    end
-  end
-end

data/lib/x/response_parser.rb

@@ -1,81 +0,0 @@
-require "json"
-require "net/http"
-require_relative "errors/bad_gateway"
-require_relative "errors/bad_request"
-require_relative "errors/connection_exception"
-require_relative "errors/http_error"
-require_relative "errors/forbidden"
-require_relative "errors/gateway_timeout"
-require_relative "errors/gone"
-require_relative "errors/internal_server_error"
-require_relative "errors/not_acceptable"
-require_relative "errors/not_found"
-require_relative "errors/payload_too_large"
-require_relative "errors/service_unavailable"
-require_relative "errors/too_many_requests"
-require_relative "errors/unauthorized"
-require_relative "errors/unprocessable_entity"
-
-module X
-  # Parses HTTP responses from the X API
-  # @api public
-  class ResponseParser
-    # Mapping of HTTP status codes to error classes
-    ERROR_MAP = {
-      400 => BadRequest,
-      401 => Unauthorized,
-      403 => Forbidden,
-      404 => NotFound,
-      406 => NotAcceptable,
-      409 => ConnectionException,
-      410 => Gone,
-      413 => PayloadTooLarge,
-      422 => UnprocessableEntity,
-      429 => TooManyRequests,
-      500 => InternalServerError,
-      502 => BadGateway,
-      503 => ServiceUnavailable,
-      504 => GatewayTimeout
-    }.freeze
-
-    # Parse an HTTP response
-    #
-    # @api public
-    # @param response [Net::HTTPResponse] the HTTP response to parse
-    # @param array_class [Class, nil] the class for parsing JSON arrays
-    # @param object_class [Class, nil] the class for parsing JSON objects
-    # @return [Hash, Array, nil] the parsed response body
-    # @raise [HTTPError] if the response is not successful
-    # @example Parse a response
-    #   parser.parse(response: response)
-    def parse(response:, array_class: nil, object_class: nil)
-      raise error(response) unless response.is_a?(Net::HTTPSuccess)
-
-      return if response.instance_of?(Net::HTTPNoContent)
-
-      begin
-        JSON.parse(response.body, array_class:, object_class:)
-      rescue JSON::ParserError
-        nil
-      end
-    end
-
-    private
-
-    # Create an error from a response
-    # @api private
-    # @param response [Net::HTTPResponse] the HTTP response
-    # @return [HTTPError] the error
-    def error(response)
-      error_class(response).new(response:)
-    end
-
-    # Get the error class for a response
-    # @api private
-    # @param response [Net::HTTPResponse] the HTTP response
-    # @return [Class] the error class
-    def error_class(response)
-      ERROR_MAP[Integer(response.code)] || HTTPError
-    end
-  end
-end

data/lib/x/stream_parser.rb

@@ -1,75 +0,0 @@
-require "json"
-require "net/http"
-require_relative "response_parser"
-
-module X
-  # Handles streaming responses from the X API
-  # @api public
-  class StreamParser
-    # Line delimiter for streaming responses
-    LINE_DELIMITER = "\r\n".freeze
-
-    # Process a streaming response and yield parsed JSON objects
-    #
-    # @api public
-    # @param response [Net::HTTPResponse] the HTTP response to stream
-    # @param response_parser [ResponseParser] the response parser for error handling
-    # @param array_class [Class, nil] the class for parsing JSON arrays
-    # @param object_class [Class, nil] the class for parsing JSON objects
-    # @yield [Hash, Array] each parsed JSON object from the stream
-    # @return [void]
-    # @raise [HTTPError] if the response is not successful
-    # @example Process a streaming response
-    #   handler.process(response: response, response_parser: parser) { |json| puts json }
-    def process(response:, response_parser:, array_class: nil, object_class: nil, &block)
-      response_parser.parse(response:) unless response.is_a?(Net::HTTPSuccess)
-
-      buffer = +""
-      response.read_body do |chunk|
-        buffer << chunk
-        process_buffer(buffer:, array_class:, object_class:, &block)
-      end
-      process_remaining(buffer:, array_class:, object_class:, &block)
-    end
-
-    private
-
-    # Process complete lines from the buffer
-    # @api private
-    # @param buffer [String] the accumulated data buffer
-    # @param array_class [Class, nil] the class for parsing JSON arrays
-    # @param object_class [Class, nil] the class for parsing JSON objects
-    # @yield [Hash, Array] each parsed JSON object
-    # @return [void]
-    def process_buffer(buffer:, array_class:, object_class:, &)
-      while (line_end = buffer.index(LINE_DELIMITER))
-        line = buffer.slice!(0, line_end) # : String
-        buffer.delete_prefix!(LINE_DELIMITER)
-        yield_json(line:, array_class:, object_class:, &) unless line.empty?
-      end
-    end
-
-    # Process any remaining data after the stream ends
-    # @api private
-    # @param buffer [String] the remaining data buffer
-    # @param array_class [Class, nil] the class for parsing JSON arrays
-    # @param object_class [Class, nil] the class for parsing JSON objects
-    # @yield [Hash, Array] the parsed JSON object
-    # @return [void]
-    def process_remaining(buffer:, array_class:, object_class:, &)
-      buffer.strip!
-      yield_json(line: buffer, array_class:, object_class:, &) unless buffer.empty?
-    end
-
-    # Parse a line as JSON and yield the result
-    # @api private
-    # @param line [String] the JSON line to parse
-    # @param array_class [Class, nil] the class for parsing JSON arrays
-    # @param object_class [Class, nil] the class for parsing JSON objects
-    # @yield [Hash, Array] the parsed JSON object
-    # @return [void]
-    def yield_json(line:, array_class:, object_class:)
-      yield JSON.parse(line, array_class:, object_class:)
-    end
-  end
-end