uber-sdk 0.1.1

data/lib/uber/api_request.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+module Uber
+  class ApiRequest
+    attr_accessor :client, :request_method, :path, :options
+    alias_method :verb, :request_method
+
+    # @param client [Uber::Client]
+    # @param request_method [String, Symbol]
+    # @param path [String]
+    # @param options [Hash]
+    # @return [Uber::ApiRequest]
+    def initialize(client, request_method, path, options = {})
+      @client = client
+      @request_method = request_method.to_sym
+      @path = path
+      @options = options
+    end
+
+    # @return [Hash]
+    def perform
+      @client.send(@request_method, @path, @options).body
+    end
+
+    # @param klass [Class]
+    # @param request [Uber::ApiRequest]
+    # @return [Object]
+    def perform_with_object(klass)
+      klass.new(perform)
+    end
+
+    # @param klass [Class]
+    # @return [Array]
+    def perform_with_objects(klass)
+      perform.values.flatten.map do |element|
+        klass.new(element)
+      end
+    end
+  end
+end

data/lib/uber/arguments.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+module Uber
+  class Arguments < Array
+    attr_reader :options
+
+    # Initializes a new Arguments object
+    #
+    # @return [Uber::Arguments]
+    def initialize(args)
+      @options = args.last.is_a?(::Hash) ? args.pop : {}
+      super(args.flatten)
+    end
+  end
+end

data/lib/uber/base.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+module Uber
+  class Base
+    attr_reader :attrs
+    alias_method :to_h, :attrs
+
+    # Initializes a new object
+    #
+    # @param attrs [Hash]
+    # @return [Uber::Base]
+    def initialize(attrs = {})
+      return if attrs.nil? || attrs.empty?
+      attrs.each do |key, value|
+        if respond_to?(:"#{key}=")
+          send(:"#{key}=", value)
+        end
+      end
+    end
+
+    # Fetches an attribute of an object using hash notation
+    #
+    # @param method [String, Symbol] Message to send to the object
+    def [](method)
+      send(method.to_sym)
+    rescue NoMethodError
+      nil
+    end
+  end
+end

data/lib/uber/client.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+require "uber/version"
+require "uber/error"
+require "base64"
+require "faraday"
+require "faraday/request/multipart"
+require "uber/parse_json"
+
+module Uber
+  class Client
+    include Uber::API
+
+    attr_accessor :server_token, :client_id, :client_secret
+    attr_accessor :bearer_token
+    attr_accessor :sandbox
+
+    attr_writer :connection_options, :middleware
+    ENDPOINT = "https://api.uber.com"
+    SANDBOX_ENDPOINT = "https://sandbox-api.uber.com"
+
+    def initialize(options = {})
+      options.each do |key, value|
+        send(:"#{key}=", value)
+      end
+      yield(self) if block_given?
+      validate_credential_type!
+    end
+
+    def bearer_token=(token)
+      @bearer_token = Token.new(
+        access_token: token,
+        token_type: Token::BEARER_TYPE
+      )
+    end
+
+    def connection_options
+      @connection_options ||= {
+        builder: middleware,
+        headers: {
+          accept: "application/json",
+          user_agent: user_agent,
+        },
+        request: {
+          open_timeout: 10,
+          timeout: 30,
+        }
+      }
+    end
+
+    # @return [Boolean]
+    def user_token?
+      !!(client_id && client_secret)
+    end
+
+    # @return [String]
+    def user_agent
+      @user_agent ||= "Uber Ruby Gem #{Uber::Version}"
+    end
+
+    def middleware
+      @middleware ||= Faraday::RackBuilder.new do |faraday|
+        # Encodes as "application/x-www-form-urlencoded" if not already encoded
+        faraday.request :url_encoded
+        # Parse JSON response bodies
+        faraday.response :parse_json
+        # Use instrumentation if available
+        if defined?(FaradayMiddleware::Instrumentation)
+          faraday.use :instrumentation
+        end
+        # Set default HTTP adapter
+        faraday.adapter Faraday.default_adapter
+      end
+    end
+
+    # Perform an HTTP GET request
+    def get(path, params = {})
+      headers = request_headers(:get, path, params)
+      request(:get, path, params, headers)
+    end
+
+    # Perform an HTTP POST request
+    def post(path, params = {})
+      respond = params.values.any? { |value| value.respond_to?(:to_io) }
+      response = if respond
+                   request_headers(:post, path, params, {})
+                 else
+                   request_headers(:post, path, params)
+                 end
+      headers = response
+      request(:post, path, params.to_json, headers)
+    end
+
+    # Perform an HTTP PUT request
+    def put(path, params = {})
+      respond = params.values.any? { |value| value.respond_to?(:to_io) }
+      response = if respond
+                   request_headers(:post, path, params, {})
+                 else
+                   request_headers(:put, path, params)
+                 end
+      headers = response
+      request(:put, path, params.to_json, headers)
+    end
+
+    # Perform an HTTP DELETE request
+    def delete(path, params = {})
+      headers = request_headers(:delete, path, params)
+      request(:delete, path, params, headers)
+    end
+
+    # @return [Boolean]
+    def bearer_token?
+      !!bearer_token
+    end
+
+    # @return [Hash]
+    def credentials
+      {
+        server_token:  server_token,
+        client_id:     client_id,
+        client_secret: client_secret
+      }
+    end
+
+    # @return [Boolean]
+    def credentials?
+      credentials.values.all?
+    end
+
+    private
+
+    # Ensures that all credentials set during configuration are
+    # of a valid type. Valid types are String and Symbol.
+    #
+    # @raise [Uber::Error::ConfigurationError] Error is raised when
+    #   supplied uber credentials are not a String or Symbol.
+    def validate_credential_type!
+      credentials.each do |credential, value|
+        next if value.nil?
+
+        unless value.is_a?(String) || value.is_a?(Symbol) # rubocop:disable Style/Next, Metrics/LineLength
+          msg = "Invalid #{credential} specified: #{value.inspect}
+          must be a string or symbol."
+          fail(Uber::Error::ConfigurationError.new(msg))
+        end
+      end
+    end
+
+    # Returns a Faraday::Connection object
+    #
+    # @return [Faraday::Connection]
+    def connection
+      @connection ||= Faraday.new(
+        sandbox ? SANDBOX_ENDPOINT : ENDPOINT,
+        connection_options
+      )
+    end
+
+    def request(method, path, params = {}, headers = {})
+      connection.send(method.to_sym, path, params) do |request|
+        request.headers.update(headers)
+      end.env
+    rescue Faraday::Error::TimeoutError, Timeout::Error => error
+      raise(Uber::Error::RequestTimeout.new(error))
+    rescue Faraday::Error::ClientError, JSON::ParserError => error
+      fail(Uber::Error.new(error))
+    end
+
+    def request_headers(_method, _path, params = {}, _signature_params = params)
+      headers = {}
+      headers[:accept]        = "*/*"
+      headers[:content_type]  = "application/json; charset=UTF-8"
+      headers[:authorization] = if bearer_token?
+                                  bearer_auth_header
+                                else
+                                  server_auth_header
+                                end
+      headers
+    end
+
+    def bearer_auth_header
+      token = if bearer_token.is_a?(Uber::Token) && bearer_token.bearer?
+                bearer_token.access_token
+              else
+                bearer_token
+              end
+      "Bearer #{token}"
+    end
+
+    def server_auth_header
+      "Token #{@server_token}"
+    end
+  end
+end

data/lib/uber/error.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+require "uber/rate_limit"
+
+module Uber
+  # Custom error class for rescuing from all Uber errors
+  class Error < StandardError
+    attr_reader :code, :rate_limit
+
+    module Code
+      AUTHENTICATION_PROBLEM = 32
+      MALFORMED_REQUEST            = 400
+      UNAUTHORIZED_REQUEST         = 401
+      REQUEST_FORBIDDEN            = 403
+      RESOURCE_NOT_FOUND           = 404
+      UNACCEPTABLE_CONTENT_TYPE    = 406
+      INVALID_REQUEST              = 422
+      RATE_LIMIT_EXCEEDED          = 429
+      INTERVAL_ERROR               = 500
+    end
+
+    Codes = Code
+
+    class << self
+      # Create a new error from an HTTP response
+      #
+      # @param response [Faraday::Response]
+      # @return [Uber::Error]
+      def from_response(response)
+        message, code = parse_error(response.body)
+        new(message, response.response_headers, code)
+      end
+
+      # @return [Hash]
+      def errors
+        @errors ||= {
+          400 => Uber::Error::BadRequest,
+          401 => Uber::Error::Unauthorized,
+          403 => Uber::Error::Forbidden,
+          404 => Uber::Error::NotFound,
+          406 => Uber::Error::NotAcceptable,
+          422 => Uber::Error::UnprocessableEntity,
+          429 => Uber::Error::RateLimited,
+          500 => Uber::Error::InternalServerError
+        }
+      end
+
+      private
+
+      def parse_error(body)
+        if body.nil?
+          ["", nil]
+        elsif body[:error]
+          [body[:error], nil]
+        elsif body[:errors]
+          extract_message_from_errors(body)
+        end
+      end
+
+      def extract_message_from_errors(body)
+        first = Array(body[:errors]).first
+        if first.is_a?(Hash)
+          [first[:message].chomp, first[:code]]
+        else
+          [first.chomp, nil]
+        end
+      end
+    end
+
+    # Initializes a new Error object
+    #
+    # @param exception [Exception, String]
+    # @param rate_limit [Hash]
+    # @param code [Integer]
+    # @return [Uber::Error]
+    def initialize(message = "", rate_limit = {}, code = nil)
+      super(message)
+      @rate_limit = Uber::RateLimit.new(rate_limit)
+      @code = code
+    end
+
+    class ClientError < self; end
+
+    class ConfigurationError < ::ArgumentError; end
+
+    # Raised when Uber returns the HTTP status code 400
+    class BadRequest < ClientError; end
+
+    # Raised when Uber returns the HTTP status code 401
+    class Unauthorized < ClientError; end
+
+    # Raised when Uber returns the HTTP status code 403
+    class Forbidden < ClientError; end
+
+    # Raised when Uber returns the HTTP status code 404
+    class NotFound < ClientError; end
+
+    # Raised when Uber returns the HTTP status code 406
+    class NotAcceptable < ClientError; end
+
+    # Raised when Uber returns the HTTP status code 422
+    class UnprocessableEntity < ClientError; end
+
+    # Raised when Uber returns the HTTP status code 429
+    class RateLimited < ClientError; end
+
+    # Raised when Uber returns a 5xx HTTP status code
+    class ServerError < self; end
+
+    # Raised when Uber returns the HTTP status code 500
+    class InternalServerError < ServerError; end
+  end
+end

data/lib/uber/models/activity.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+module Uber
+  class Activity < Base
+    attr_accessor :offset, :limit, :count, :histories
+
+    def history=(values)
+      @histories = values.map { |value| History.new(value) }
+    end
+  end
+
+  class History < Base
+    attr_accessor :request_time,
+                  :product_id,
+                  :status,
+                  :distance,
+                  :start_time,
+                  :end_time,
+                  :start_city,
+                  :request_id
+
+    alias_method :uuid, :request_id
+
+    def request_time=(value)
+      @request_time = ::Time.at(value)
+    end
+
+    def start_time=(value)
+      @start_time = ::Time.at(value)
+    end
+
+    def end_time=(value)
+      @end_time = ::Time.at(value)
+    end
+
+    def start_city=(value)
+      @start_city = City.new(value)
+    end
+  end
+
+  class Location < Base
+    attr_accessor :address, :latitude, :longitude
+  end
+
+  class City < Base
+    attr_accessor :display_name, :latitude, :longitude
+  end
+end

data/lib/uber/models/estimate.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+module Uber
+  class Estimate < Base
+    attr_accessor :pickup_estimate, :price, :trip, :errors, :code, :message
+
+    def price=(value)
+      @price = value.nil? ? nil : Price.new(value)
+    end
+
+    def trip=(value)
+      @trip = value.nil? ? nil : Trip.new(value)
+    end
+
+    def errors=(values)
+      @errors = values.map { |v| RequestError.new(v) }
+    end
+
+    def errors?
+      multi_errors = @errors && @errors.size >= 1
+      single_error = @code && !@code.empty? && @message && !@message.empty?
+      multi_errors || single_error
+    end
+
+    def humanized_estimate
+      unless pickup_estimate.nil?
+        if pickup_estimate.to_i == 1
+          "#{pickup_estimate} minute"
+        else
+          "#{pickup_estimate} minutes"
+        end
+      end
+    end
+  end
+
+  class RequestError < Base
+    attr_accessor :status, :code, :title
+  end
+
+  class Price < Base
+    attr_accessor :surge_confirmation_href,
+                  :surge_confirmation_id,
+                  :high_estimate,
+                  :low_estimate,
+                  :minimum,
+                  :surge_multiplier,
+                  :display,
+                  :currency_code
+  end
+
+  class Trip < Base
+    attr_accessor :distance_unit, :duration_estimate, :distance_estimate
+  end
+end