twelvedata_ruby 0.2.2 → 0.4.0

data/lib/twelvedata_ruby/error.rb

@@ -1,90 +1,138 @@
 # frozen_string_literal: true
 
 module TwelvedataRuby
+  # Base error class for all TwelvedataRuby errors
   class Error < StandardError
-    DEFAULT_MSGS = {
-      "EndpointError" => "Endpoint is not valid. %{invalid}",
-      "EndpointNameError" => "`%{invalid}` is not a correct endpoint. Valid values are: `%{valid_names}`",
-      "EndpointParametersKeysError" => "Invalid parameters found: `%{invalid}`. Valid parameters for `%{name}` "\
-        "endpoint are: `%{parameters}`. Please see: `Twelvedata::Endpoint#parameters` for more details",
-      "EndpointRequiredParametersError" => "Missing values for required parameters: `%{invalid}`. "\
-        "`%{name}` endpoint required parameters are: `%{required}`.",
-      "ResponseError" => "Encountered an error from the response"
+    # Default error messages for different error types
+    DEFAULT_MESSAGES = {
+      "EndpointError" => "Endpoint is not valid: %{invalid}",
+      "EndpointNameError" => "`%{invalid}` is not a valid endpoint. Valid endpoints: %{valid_names}",
+      "EndpointParametersKeysError" => "Invalid parameters: %{invalid}. Valid parameters for `%{name}`: %{parameters}",
+      "EndpointRequiredParametersError" => "Missing required parameters: %{invalid}.\
+                                            Required for `%{name}`: %{required}",
+      "ResponseError" => "Response error occurred",
+      "ConfigurationError" => "Configuration error: %{message}",
+      "NetworkError" => "Network error: %{message}",
     }.freeze
 
-    attr_reader :attrs
+    attr_reader :attributes, :original_error
 
-    def initialize(args={})
-      @attrs = args[:attrs] || {}
-      super((args[:message] || DEFAULT_MSGS[Utils.demodulize(self.class)]) % @attrs)
+    # Initialize error with message and attributes
+    #
+    # @param message [String, nil] Custom error message
+    # @param attributes [Hash] Error attributes for interpolation
+    # @param original_error [Exception, nil] Original exception that caused this error
+    def initialize(message: nil, attributes: {}, original_error: nil)
+      @attributes = attributes
+      @original_error = original_error
+
+      error_message = message || format_default_message
+      super(error_message)
+    end
+
+    private
+
+    def format_default_message
+      template = DEFAULT_MESSAGES[Utils.demodulize(self.class.name)]
+      return "An error occurred" unless template
+
+      format(template, **attributes)
+    rescue KeyError => e
+      "Error message template missing key: #{e.key}"
     end
   end
 
+  # Configuration-related errors
+  class ConfigurationError < Error; end
+
+  # Network-related errors
+  class NetworkError < Error; end
+
+  # Base class for endpoint-related errors
   class EndpointError < Error
-    def initialize(**args)
-      endpoint = args[:endpoint]
-      super(
-        attrs: {
-          name: endpoint.name,
-          invalid: args[:invalid],
-          valid_names: endpoint.class.names.join(", "),
-          parameters: endpoint&.parameters_keys&.send(:join, ", "),
-          required: endpoint&.required_parameters&.send(:join, ", ")
-        }
-      )
+    def initialize(endpoint:, invalid:, **options)
+      attributes = {
+        name: endpoint.name,
+        invalid: invalid,
+        valid_names: endpoint.class.names.join(", "),
+        parameters: endpoint&.parameters_keys&.join(", "),
+        required: endpoint&.required_parameters&.join(", "),
+      }
+
+      super(attributes: attributes, **options)
     end
   end
 
+  # Error for invalid endpoint names
   class EndpointNameError < EndpointError; end
 
+  # Error for invalid endpoint parameters
   class EndpointParametersKeysError < EndpointError; end
 
+  # Error for missing required parameters
   class EndpointRequiredParametersError < EndpointError; end
 
+  # Base class for API response errors
   class ResponseError < Error
-    API_ERROR_CODES_MAP = {
+    # Mapping of API error codes to specific error classes
+    API_ERROR_CODES = {
       400 => "BadRequestResponseError",
       401 => "UnauthorizedResponseError",
       403 => "ForbiddenResponseError",
       404 => "NotFoundResponseError",
       414 => "ParameterTooLongResponseError",
       429 => "TooManyRequestsResponseError",
-      500 => "InternalServerResponseError"
+      500 => "InternalServerResponseError",
     }.freeze
-    HTTP_ERROR_CODES_MAP = {
+
+    # Mapping of HTTP error codes to specific error classes
+    HTTP_ERROR_CODES = {
       404 => "PageNotFoundResponseError",
     }.freeze
 
-    def self.error_code_klass(code, error_type=:api)
-      error_type = :api unless %i[api http].member?(error_type)
-
-      TwelvedataRuby::ResponseError.const_get("#{error_type.upcase}_ERROR_CODES_MAP")[code]
+    class << self
+      # Find appropriate error class for given code and type
+      #
+      # @param code [Integer] Error code
+      # @param error_type [Symbol] Type of error (:api or :http)
+      # @return [String, nil] Error class name
+      def error_class_for_code(code, error_type = :api)
+        case error_type
+        when :api
+          API_ERROR_CODES[code]
+        when :http
+          HTTP_ERROR_CODES[code]
+        end
+      end
     end
 
-    attr_reader :json, :code, :request
-
-    def initialize(json:, request:, attrs: nil, message: nil, code: nil)
-      @json = json.is_a?(Hash) ? json : {}
-      @code = code || @json[:code]
-      @attrs = attrs || {}
+    attr_reader :json_data, :status_code, :request
+
+    # Initialize response error
+    #
+    # @param json_data [Hash] JSON response data
+    # @param request [Request] Original request object
+    # @param status_code [Integer] HTTP/API status code
+    # @param message [String, nil] Custom error message
+    def initialize(json_data: {}, request: nil, status_code: nil, message: nil, **options)
+      @json_data = json_data.is_a?(Hash) ? json_data : {}
+      @status_code = status_code || @json_data[:code]
       @request = request
-      super(attrs: @attrs, message: "#{@json[:message] || message}")
+
+      error_message = message || @json_data[:message] || "Response error occurred"
+      super(message: error_message, **options)
     end
   end
 
+  # Specific API error classes
   class BadRequestResponseError < ResponseError; end
-
   class UnauthorizedResponseError < ResponseError; end
-
   class ForbiddenResponseError < ResponseError; end
-
   class NotFoundResponseError < ResponseError; end
-
-  class PageNotFoundResponseError < ResponseError; end
-
   class ParameterTooLongResponseError < ResponseError; end
-
   class TooManyRequestsResponseError < ResponseError; end
+  class InternalServerResponseError < ResponseError; end
 
-  class InternalServerResponseErro < ResponseError; end
+  # HTTP-specific error classes
+  class PageNotFoundResponseError < ResponseError; end
 end

data/lib/twelvedata_ruby/request.rb

@@ -1,54 +1,127 @@
 # frozen_string_literal: true
 
 require "forwardable"
+
+# Represents an API request to Twelve Data
 module TwelvedataRuby
   class Request
-    extend Forwardable
+  extend Forwardable
 
-    DEFAULT_HTTP_VERB = :get
+  # Default HTTP method for API requests
+  DEFAULT_HTTP_VERB = :get
 
-    attr_reader :endpoint
+  def_delegators :endpoint, :name, :valid?, :query_params, :errors
 
-    def initialize(name, **query_params)
-      self.endpoint = Endpoint.new(name, **query_params)
-    end
-    def_delegators :endpoint, :name, :valid?, :query_params, :errors
+  attr_reader :endpoint
 
-    def fetch
-      Client.instance.fetch(self)
-    end
+  # Initialize a new request
+  #
+  # @param name [Symbol, String] Endpoint name
+  # @param query_params [Hash] Query parameters for the request
+  def initialize(name, **query_params)
+    @endpoint = Endpoint.new(name, **query_params)
+  end
 
-    def http_verb
-      return_nil_unless_valid { endpoint.definition[:http_verb] || DEFAULT_HTTP_VERB }
-    end
+  # Send the request using the client
+  #
+  # @return [Response, Hash, ResponseError] Response or error information
+  def fetch
+    Client.instance.fetch(self)
+  end
 
-    def params
-      {params: endpoint.query_params}
-    end
+  # Get the HTTP verb for this request
+  #
+  # @return [Symbol, nil] HTTP verb or nil if invalid
+  def http_verb
+    return nil unless valid?
 
-    def relative_url
-      return_nil_unless_valid { name.to_s }
-    end
+    endpoint.definition[:http_verb] || DEFAULT_HTTP_VERB
+  end
 
-    def full_url
-      return_nil_unless_valid { "#{Client.origin[:origin]}/#{relative_url}" }
-    end
+  # Get request parameters formatted for HTTP client
+  #
+  # @return [Hash, nil] Parameters hash or nil if invalid
+  def params
+    return nil unless valid?
 
-    def to_h
-      return_nil_unless_valid { {http_verb: http_verb, relative_url: relative_url}.merge(params: params) }
-    end
+    { params: endpoint.query_params }
+  end
 
-    def to_a
-      return_nil_unless_valid { [http_verb, relative_url, params] }
-    end
-    alias build to_a
+  # Get the relative URL path for this request
+  #
+  # @return [String, nil] URL path or nil if invalid
+  def relative_url
+    return nil unless valid?
+
+    name.to_s
+  end
 
-    private
+  # Get the complete URL for this request
+  #
+  # @return [String, nil] Full URL or nil if invalid
+  def full_url
+    return nil unless valid?
 
-    attr_writer :endpoint
+    "#{Client::BASE_URL}/#{relative_url}"
+  end
+
+  # Convert request to hash representation
+  #
+  # @return [Hash, nil] Request as hash or nil if invalid
+  def to_h
+    return nil unless valid?
+
+    {
+      http_verb: http_verb,
+      url: full_url,
+      params: query_params,
+    }
+  end
 
-    def return_nil_unless_valid(&block)
-      Utils.return_nil_unless_true(valid?) { block.call }
+  # Convert request to array format for HTTPX
+  #
+  # @return [Array, nil] Request as array or nil if invalid
+  def to_a
+    return nil unless valid?
+
+    [http_verb.to_s.upcase, full_url, params]
+  end
+  alias build to_a
+
+  # String representation of the request
+  #
+  # @return [String] Human-readable request description
+  def to_s
+    if valid?
+      "#{http_verb.to_s.upcase} #{full_url} with params: #{query_params}"
+    else
+      "Invalid request for endpoint: #{name}"
     end
   end
+
+  # Detailed inspection of the request
+  #
+  # @return [String] Detailed request information
+  def inspect
+    "#<#{self.class.name}:#{object_id} endpoint=#{name} valid=#{valid?} params=#{query_params.keys}>"
+  end
+
+  # Check equality with another request
+  #
+  # @param other [Request] Request to compare with
+  # @return [Boolean] True if requests are equivalent
+  def ==(other)
+    return false unless other.is_a?(self.class)
+
+    name == other.name && query_params == other.query_params
+  end
+  alias eql? ==
+
+  # Generate hash code for request
+  #
+  # @return [Integer] Hash code
+  def hash
+    [name, query_params].hash
+  end
+  end
 end