hungrytable 0.0.8 → 1.0.0

data/lib/hungrytable/config.rb

@@ -1,26 +1,48 @@
+# frozen_string_literal: true
+
 module Hungrytable
+  # Configuration module for Hungrytable
   module Config
-    extend self
+    class << self
+      attr_writer :partner_id, :oauth_key, :oauth_secret, :base_url
 
-    def partner_id
-      ENV['OT_PARTNER_ID'] || config_error('OT_PARTNER_ID')
-    end
+      def partner_id
+        @partner_id ||= ENV.fetch('OT_PARTNER_ID') do
+          raise ConfigurationError, 'OT_PARTNER_ID must be set via ENV or Config.partner_id='
+        end
+      end
 
-    def oauth_key
-      ENV['OT_OAUTH_KEY'] || config_error('OT_OAUTH_KEY')
-    end
+      def oauth_key
+        @oauth_key ||= ENV.fetch('OT_OAUTH_KEY') do
+          raise ConfigurationError, 'OT_OAUTH_KEY must be set via ENV or Config.oauth_key='
+        end
+      end
 
-    def oauth_secret
-      ENV['OT_OAUTH_SECRET'] || config_error('OT_OAUTH_SECRET')
-    end
+      def oauth_secret
+        @oauth_secret ||= ENV.fetch('OT_OAUTH_SECRET') do
+          raise ConfigurationError, 'OT_OAUTH_SECRET must be set via ENV or Config.oauth_secret='
+        end
+      end
 
-    def base_url
-      'https://secure.opentable.com/api/otapi_v2.ashx'
-    end
+      def base_url
+        @base_url ||= 'https://secure.opentable.com/api/otapi_v3.ashx'
+      end
+
+      # Reset configuration to defaults (useful for testing)
+      def reset!
+        @partner_id = nil
+        @oauth_key = nil
+        @oauth_secret = nil
+        @base_url = nil
+      end
 
-    private
-    def config_error var
-      raise HungrytableError, "ENV variable #{var} must be set."
+      # Check if all required configuration is present
+      def valid?
+        partner_id && oauth_key && oauth_secret
+        true
+      rescue ConfigurationError
+        false
+      end
     end
   end
 end

data/lib/hungrytable/enhanced_errors.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Hungrytable
+  # Enhanced error classes with diagnostic information
+  module EnhancedErrors
+    # Enhance UnauthorizedError with diagnostic info
+    class EnhancedUnauthorizedError < UnauthorizedError
+      attr_reader :diagnostics
+
+      def initialize(message = nil)
+        @diagnostics = build_diagnostics
+        super(build_message(message))
+      end
+
+      private
+
+      def build_message(original_message)
+        msg = original_message || 'Authentication failed. Check your OAuth credentials.'
+        msg += "\n\nDiagnostics:\n"
+        msg += "  Partner ID: #{mask_credential(Config.partner_id)}\n"
+        msg += "  OAuth Key: #{mask_credential(Config.oauth_key)}\n"
+        msg += "  Endpoint: #{Config.base_url}\n"
+        msg += "\nPossible causes:\n"
+        msg += "  1. Invalid or expired OAuth credentials\n"
+        msg += "  2. Partner ID does not match OAuth key/secret\n"
+        msg += "  3. Credentials not authorized for this API version\n"
+        msg += "  4. API endpoint has been deprecated\n"
+        msg += "\nRecommended actions:\n"
+        msg += "  1. Verify credentials: OT_PARTNER_ID, OT_OAUTH_KEY, OT_OAUTH_SECRET\n"
+        msg += "  2. Contact OpenTable: partnersupport@opentable.com\n"
+        msg += "  3. Run diagnostic: bin/verify_api\n"
+        msg
+      end
+
+      def build_diagnostics
+        {
+          partner_id: mask_credential(Config.partner_id),
+          oauth_key: mask_credential(Config.oauth_key),
+          endpoint: Config.base_url,
+          timestamp: Time.now.utc.iso8601,
+          circuit_breaker_state: CircuitBreaker.state
+        }
+      end
+
+      def mask_credential(credential)
+        return 'NOT SET' unless credential
+        return '***' if credential.length <= 8
+
+        "#{credential[0..3]}...#{credential[-4..]}"
+      end
+    end
+
+    # Enhance ServerError with diagnostic info
+    class EnhancedServerError < ServerError
+      attr_reader :diagnostics
+
+      def initialize(message = nil, status_code = nil)
+        @status_code = status_code
+        @diagnostics = build_diagnostics
+        super(build_message(message))
+      end
+
+      private
+
+      def build_message(original_message)
+        msg = original_message || "OpenTable server error (#{@status_code})"
+        msg += "\n\nDiagnostics:\n"
+        msg += "  Endpoint: #{Config.base_url}\n"
+        msg += "  Status Code: #{@status_code}\n"
+        msg += "  Circuit Breaker: #{CircuitBreaker.state}\n"
+        msg += "\nPossible causes:\n"
+        msg += "  1. OpenTable API is experiencing issues\n"
+        msg += "  2. Endpoint has been deprecated or moved\n"
+        msg += "  3. Rate limiting or quota exceeded\n"
+        msg += "\nRecommended actions:\n"
+        msg += "  1. Check OpenTable status page\n"
+        msg += "  2. Wait and retry (circuit breaker will help)\n"
+        msg += "  3. Contact OpenTable support if issue persists\n"
+        msg += "  4. Run diagnostic: bin/verify_api\n"
+        msg
+      end
+
+      def build_diagnostics
+        {
+          endpoint: Config.base_url,
+          status_code: @status_code,
+          timestamp: Time.now.utc.iso8601,
+          circuit_breaker_state: CircuitBreaker.state
+        }
+      end
+    end
+
+    # Enhance HTTPError with retry suggestions
+    class EnhancedHTTPError < HTTPError
+      attr_reader :diagnostics, :retryable
+
+      def initialize(message, retryable: false)
+        @retryable = retryable
+        @diagnostics = build_diagnostics
+        super(build_message(message))
+      end
+
+      private
+
+      def build_message(original_message)
+        msg = original_message
+        msg += "\n\nRetryable: #{@retryable ? 'Yes' : 'No'}\n"
+        msg += "Circuit Breaker State: #{CircuitBreaker.state}\n"
+
+        if @retryable
+          msg += "\nThis error may be transient. Consider retrying.\n"
+        end
+
+        msg
+      end
+
+      def build_diagnostics
+        {
+          endpoint: Config.base_url,
+          timestamp: Time.now.utc.iso8601,
+          circuit_breaker_state: CircuitBreaker.state,
+          retryable: @retryable
+        }
+      end
+    end
+  end
+end

data/lib/hungrytable/errors.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Hungrytable
+  # Base error class for all Hungrytable errors
+  class Error < StandardError; end
+
+  # Configuration errors
+  class ConfigurationError < Error; end
+
+  # API errors
+  class APIError < Error
+    attr_reader :error_code, :error_message
+
+    def initialize(error_code, error_message)
+      @error_code = error_code
+      @error_message = error_message
+      super("OpenTable API Error #{error_code}: #{error_message}")
+    end
+  end
+
+  # HTTP errors
+  class HTTPError < Error; end
+  class NotFoundError < HTTPError; end
+  class UnauthorizedError < HTTPError; end
+  class ServerError < HTTPError; end
+
+  # Validation errors
+  class ValidationError < Error; end
+  class MissingRequiredFieldError < ValidationError; end
+
+  # OpenTable specific errors mapped from error codes
+  class ReservationError < APIError; end
+  class SlotlockError < APIError; end
+  class RestaurantNotFoundError < APIError; end
+  class NoAvailabilityError < APIError; end
+end

data/lib/hungrytable/get_request.rb

@@ -1,15 +1,26 @@
+# frozen_string_literal: true
+
 module Hungrytable
+  # HTTP GET request handler
   class GetRequest < Request
+    # Default timeout for HTTP requests (in seconds)
+    DEFAULT_TIMEOUT = 30
+
     private
-    def auth_header
-      Hungrytable::RequestHeader.new(:get, @uri, {}, {})
-    end
 
     def make_request
-      Curl::Easy.perform(@uri) do |curl|
-        curl.headers['Authorization'] = auth_header
-      end
+      response = HTTP
+                 .timeout(DEFAULT_TIMEOUT)
+                 .headers('Authorization' => auth_header)
+                 .get(uri)
+
+      handle_http_errors(response)
+    rescue HTTP::Error => e
+      raise HTTPError, "HTTP request failed: #{e.message}"
     end
 
+    def auth_header
+      RequestHeader.new(:get, uri, {}, {}).to_s
+    end
   end
 end

data/lib/hungrytable/post_request.rb

@@ -1,15 +1,26 @@
+# frozen_string_literal: true
+
 module Hungrytable
+  # HTTP POST request handler
   class PostRequest < Request
+    # Default timeout for HTTP requests (in seconds)
+    DEFAULT_TIMEOUT = 30
+
     private
-    def auth_header
-      Hungrytable::RequestHeader.new(:post, @uri, {}, {})
-    end
 
     def make_request
-      Curl::Easy.http_post(@uri, @params.to_query) do |curl|
-        curl.headers['Authorization'] = auth_header
-      end
+      response = HTTP
+                 .timeout(DEFAULT_TIMEOUT)
+                 .headers('Authorization' => auth_header)
+                 .post(uri, form: params)
+
+      handle_http_errors(response)
+    rescue HTTP::Error => e
+      raise HTTPError, "HTTP request failed: #{e.message}"
     end
 
+    def auth_header
+      RequestHeader.new(:post, uri, params, {}).to_s
+    end
   end
 end

data/lib/hungrytable/request.rb

@@ -1,17 +1,54 @@
+# frozen_string_literal: true
+
 module Hungrytable
+  # Base class for API requests
   class Request
-    def initialize uri, params={}
-      @uri    = Hungrytable::Config.base_url << uri
+    attr_reader :uri, :params
+
+    def initialize(uri, params = {})
+      @uri = "#{Hungrytable::Config.base_url}#{uri}" # Fixed: don't mutate base_url
       @params = params
     end
 
+    # Parse the JSON response
+    # @return [Hash] parsed JSON response
+    # @raise [Hungrytable::HTTPError] if the response is invalid
     def parsed_response
-      JSON.parse(response)
+      JSON.parse(response_body)
+    rescue JSON::ParserError => e
+      raise HTTPError, "Failed to parse response: #{e.message}"
     end
 
     private
-    def response
-      @response ||= make_request.body_str
+
+    # Get the response body from the HTTP request
+    # @return [String] response body
+    def response_body
+      @response_body ||= make_request
+    end
+
+    # Make the HTTP request (to be implemented by subclasses)
+    # @return [String] response body
+    def make_request
+      raise NotImplementedError, 'Subclasses must implement make_request'
+    end
+
+    # Handle HTTP errors
+    # @param response [HTTP::Response] the HTTP response object
+    # @raise [Hungrytable::HTTPError] if the response indicates an error
+    def handle_http_errors(response)
+      case response.status.code
+      when 200..299
+        response.body.to_s
+      when 401
+        raise UnauthorizedError, 'Authentication failed. Check your OAuth credentials.'
+      when 404
+        raise NotFoundError, "Resource not found: #{uri}"
+      when 500..599
+        raise ServerError, "OpenTable server error (#{response.status.code})"
+      else
+        raise HTTPError, "HTTP error #{response.status.code}: #{response.body}"
+      end
     end
   end
 end

data/lib/hungrytable/request_extensions.rb

@@ -1,19 +1,32 @@
+# frozen_string_literal: true
+
 module Hungrytable
+  # Shared functionality for classes that make API requests
+  # Follows DRY principle - don't repeat yourself
   module RequestExtensions
     extend ActiveSupport::Concern
 
     private
+
+    # Get the request object (lazy-loaded)
+    # @return [Request] the request object
     def request
       @request ||= @requester.new(request_uri, params)
     end
 
+    # Ensure all required options are present
+    # @raise [MissingRequiredFieldError] if any required field is missing
     def ensure_required_opts
-      required_opts.each do |key|
-        raise ArgumentError, "options must include a value for #{key}" unless opts.has_key?(key)
-      end
+      return unless respond_to?(:required_opts, true)
+
+      missing = required_opts.reject { |key| opts.key?(key) }
+      return if missing.empty?
+
+      raise MissingRequiredFieldError, "Missing required fields: #{missing.join(', ')}"
     end
 
-    # Will be overwritten in objects that send post requests
+    # Default params (can be overridden in classes that send POST requests)
+    # @return [Hash] request parameters
     def params
       {}
     end

data/lib/hungrytable/request_header.rb

@@ -1,27 +1,28 @@
+# frozen_string_literal: true
+
 # Modified from simple_oauth (https://github.com/laserlemon/simple_oauth)
 module Hungrytable
   class RequestHeader
-
-    ATTRIBUTE_KEYS = %w(consumer_key nonce signature_method timestamp token version).map(&:to_sym)
+    ATTRIBUTE_KEYS = %w[consumer_key nonce signature_method timestamp token version].map(&:to_sym)
 
     def self.default_options
       {
-        :nonce => OpenSSL::Random.random_bytes(16).unpack('H*')[0],
-        :signature_method => 'HMAC-SHA1',
-        :timestamp => Time.now.to_i.to_s,
-        :version => '1.0',
-        :consumer_key => Hungrytable::Config.oauth_key,
-        :consumer_secret => Hungrytable::Config.oauth_secret,
-        :token => ''
+        nonce: OpenSSL::Random.random_bytes(16).unpack1('H*'),
+        signature_method: 'HMAC-SHA1',
+        timestamp: Time.now.to_i.to_s,
+        version: '1.0',
+        consumer_key: Hungrytable::Config.oauth_key,
+        consumer_secret: Hungrytable::Config.oauth_secret,
+        token: ''
       }
     end
 
     def self.encode(value)
-      URI.encode(value.to_s, /[^a-z0-9\-\.\_\~]/i)
+      CGI.escape(value.to_s).gsub('+', '%20').gsub('%7E', '~')
     end
 
     def self.decode(value)
-      URI.decode(value.to_s)
+      CGI.unescape(value.to_s)
     end
 
     attr_reader :method, :params, :options
@@ -33,7 +34,7 @@ module Hungrytable
       @uri.normalize!
       @uri.fragment = nil
       @params = params
-      @options =  self.class.default_options.merge(oauth) 
+      @options = self.class.default_options.merge(oauth)
     end
 
     def url
@@ -43,7 +44,7 @@ module Hungrytable
     end
 
     def to_s
-      %Q(OAuth realm="http://www.opentable.com/", #{normalized_attributes})
+      %(OAuth realm="http://www.opentable.com/", #{normalized_attributes})
     end
 
     def valid?(secrets = {})
@@ -55,38 +56,38 @@ module Hungrytable
     end
 
     def signed_attributes
-      attributes.merge(:oauth_signature => signature)
+      attributes.merge(oauth_signature: signature)
     end
 
     private
 
     def normalized_attributes
-      signed_attributes.sort_by{|k,v| k.to_s }.map{|k,v| %(#{k}="#{self.class.encode(v)}") }.join(', ')
+      signed_attributes.sort_by { |k, _v| k.to_s }.map { |k, v| %(#{k}="#{self.class.encode(v)}") }.join(', ')
     end
 
     def attributes
-      ATTRIBUTE_KEYS.inject({}){|a,k| options.key?(k) ? a.merge(:"oauth_#{k}" => options[k]) : a }
+      ATTRIBUTE_KEYS.inject({}) { |a, k| options.key?(k) ? a.merge("oauth_#{k}": options[k]) : a }
     end
 
     def signature
-      send(options[:signature_method].downcase.tr('-', '_') + '_signature')
+      send("#{options[:signature_method].downcase.tr('-', '_')}_signature")
     end
 
     def hmac_sha1_signature
-      Base64.encode64(OpenSSL::HMAC.digest(OpenSSL::Digest::SHA1.new, secret, signature_base)).chomp.gsub(/\n/, '')
+      Base64.encode64(OpenSSL::HMAC.digest(OpenSSL::Digest.new('SHA1'), secret, signature_base)).chomp.gsub("\n", '')
     end
 
     def secret
-      options.values_at(:consumer_secret, :token_secret).map{|v| self.class.encode(v) }.join('&')
+      options.values_at(:consumer_secret, :token_secret).map { |v| self.class.encode(v) }.join('&')
     end
-    alias_method :plaintext_signature, :secret
+    alias plaintext_signature secret
 
     def signature_base
-      [method, url, normalized_params].map{|v| self.class.encode(v) }.join('&')
+      [method, url, normalized_params].map { |v| self.class.encode(v) }.join('&')
     end
 
     def normalized_params
-      signature_params.map{|p| p.map{|v| self.class.encode(v) } }.sort.map{|p| p.join('=') }.join('&')
+      signature_params.map { |p| p.map { |v| self.class.encode(v) } }.sort.map { |p| p.join('=') }.join('&')
     end
 
     def signature_params
@@ -94,16 +95,15 @@ module Hungrytable
     end
 
     def url_params
-      CGI.parse(@uri.query || '').inject([]){|p,(k,vs)| p + vs.sort.map{|v| [k, v] } }
+      CGI.parse(@uri.query || '').inject([]) { |p, (k, vs)| p + vs.sort.map { |v| [k, v] } }
     end
 
     def rsa_sha1_signature
-      Base64.encode64(private_key.sign(OpenSSL::Digest::SHA1.new, signature_base)).chomp.gsub(/\n/, '')
+      Base64.encode64(private_key.sign(OpenSSL::Digest.new('SHA1'), signature_base)).chomp.gsub("\n", '')
     end
 
     def private_key
       OpenSSL::PKey::RSA.new(options[:consumer_secret])
     end
-
   end
 end

data/lib/hungrytable/reservation_cancel.rb

@@ -1,30 +1,44 @@
+# frozen_string_literal: true
+
 module Hungrytable
+  # Cancels an existing restaurant reservation
   class ReservationCancel
     include RequestExtensions
 
     attr_reader :opts
 
-    def initialize opts={}
+    def initialize(opts = {})
       @opts = opts
       ensure_required_opts
       @requester = opts[:requester] || GetRequest
     end
 
+    # Check if the cancellation was successful
+    # @return [Boolean] true if no errors
     def successful?
-      details["ns:ErrorID"] == "0"
+      details['ns:ErrorID'].to_s == '0'
+    end
+
+    # Get error messages if cancellation failed
+    # @return [String, nil] error message or nil
+    def error_message
+      details['ns:ErrorMessage']
     end
 
     private
+
     def request_uri
-      "/reservation/?pid=#{Config.partner_id}&rid=#{opts[:restaurant_id]}&conf=#{opts[:confirmation_number]}&email=#{CGI.escape(opts[:email_address])}"
+      "/reservation/?pid=#{Config.partner_id}&rid=#{opts[:restaurant_id]}&" \
+        "conf=#{CGI.escape(opts[:confirmation_number].to_s)}&email=#{CGI.escape(opts[:email_address])}"
     end
 
+    # @return [Hash] cancellation results from API response
     def details
-      request.parsed_response["Results"]
+      @details ||= request.parsed_response['Results'] || {}
     end
 
     def required_opts
-      %w(email_address confirmation_number restaurant_id).map(&:to_sym)
+      %i[email_address confirmation_number restaurant_id]
     end
   end
 end

data/lib/hungrytable/reservation_make.rb

@@ -1,28 +1,43 @@
+# frozen_string_literal: true
+
 module Hungrytable
+  # Makes a new restaurant reservation
   class ReservationMake
     include RequestExtensions
 
     attr_reader :restaurant_slotlock, :opts
 
-    def initialize restaurant_slotlock, opts={}
+    def initialize(restaurant_slotlock, opts = {})
       @opts = opts
       ensure_required_opts
-      @requester           = opts[:requester] || PostRequest
+      @requester = opts[:requester] || PostRequest
       @restaurant_slotlock = restaurant_slotlock
     end
 
+    # Check if the reservation was successful
+    # @return [Boolean] true if no errors
     def successful?
-      details["ns:ErrorID"] == "0"
+      details['ns:ErrorID'].to_s == '0'
     end
 
+    # Get the confirmation number for the reservation
+    # @return [String, nil] confirmation number or nil if unsuccessful
     def confirmation_number
       return nil unless successful?
-      details["ns:ConfirmationNumber"]
+
+      details['ns:ConfirmationNumber']
+    end
+
+    # Get error messages if reservation failed
+    # @return [String, nil] error message or nil
+    def error_message
+      details['ns:ErrorMessage']
     end
 
     private
+
     def required_opts
-      %w(email_address firstname lastname phone).map(&:to_sym)
+      %i[email_address firstname lastname phone]
     end
 
     def default_options
@@ -30,22 +45,28 @@ module Hungrytable
         'OTannouncementOption' => '0',
         'RestaurantEmailOption' => '0',
         'firsttimediner' => '0',
-        'specialinstructions' => 'Have a great time',
+        'specialinstructions' => opts[:specialinstructions] || '',
         'slotlockid' => restaurant_slotlock.slotlock_id
       }.merge(restaurant_slotlock.params)
     end
 
     def params
-      default_options.merge(opts)
+      # Filter out internal options (like :requester) before converting to API parameters
+      internal_opts = %i[requester]
+      api_opts = opts.except(*internal_opts)
+
+      # Convert symbol keys to strings for API
+      user_opts = api_opts.transform_keys(&:to_s)
+      default_options.merge(user_opts)
     end
 
     def request_uri
       "/reservation/?pid=#{Config.partner_id}&st=0"
     end
 
+    # @return [Hash] reservation results from API response
     def details
-      request.parsed_response["MakeResults"]
+      @details ||= request.parsed_response['MakeResults'] || {}
     end
-
   end
 end