smartsheet 1.0.0.beta.0

data/lib/smartsheet/api/endpoint_spec.rb

@@ -0,0 +1,35 @@
+require_relative 'url_builder'
+
+module Smartsheet
+  module API
+    class EndpointSpec
+      attr_reader :method, :url_segments, :spec
+
+      def initialize(method, url, **spec)
+        @method = method
+        @url_segments = url
+        @spec = spec
+      end
+
+      def requires_auth?
+        !spec.key?(:no_auth)
+      end
+
+      def requires_body?
+        spec.key? :body_type
+      end
+
+      def sending_file?
+        requires_body? && spec[:body_type] == :file
+      end
+
+      def sending_json?
+        requires_body? && spec[:body_type] == :json
+      end
+
+      def headers
+        spec.key?(:headers) ? spec[:headers] : {}
+      end
+    end
+  end
+end

data/lib/smartsheet/api/faraday_adapter/faraday_net_client.rb

@@ -0,0 +1,42 @@
+require 'faraday'
+require 'smartsheet/api/request'
+require 'smartsheet/api/faraday_adapter/middleware/faraday_error_translator'
+require 'smartsheet/api/faraday_adapter/middleware/response_parser'
+
+module Smartsheet
+  module API
+    class FaradayNetClient
+      def initialize
+        create_connection
+      end
+
+      # Expected output:
+      # - returned Success Response
+      # - returned Error Response
+      # - thrown Request Error
+      def make_request(request)
+        response = conn.send(request.method) do |req|
+          req.url(request.url)
+          req.headers = request.headers
+          req.params = request.params
+          req.body = request.body
+        end
+
+        response.body
+      end
+
+      private
+
+      def create_connection
+        @conn = Faraday.new do |conn|
+          conn.use Middleware::FaradayErrorTranslator
+          conn.use Middleware::ResponseParser
+
+          conn.adapter Faraday.default_adapter
+        end
+      end
+
+      attr_reader :conn
+    end
+  end
+end

data/lib/smartsheet/api/faraday_adapter/faraday_response.rb

@@ -0,0 +1,60 @@
+module Smartsheet
+  module API
+    class FaradayResponse
+      def self.from_response_env(faraday_response)
+        if faraday_response[:body].kind_of?(Hash) && faraday_response[:body].key?(:errorCode)
+          FaradayErrorResponse.new(faraday_response[:body], faraday_response)
+        else
+          FaradaySuccessResponse.new(faraday_response[:body], faraday_response)
+        end
+      end
+
+      attr_reader :status_code, :reason_phrase, :headers
+
+      def initialize(faraday_response)
+        @status_code = faraday_response[:status]
+        @reason_phrase = faraday_response[:reason_phrase]
+        @headers = faraday_response[:response_headers]
+      end
+    end
+
+    class FaradayErrorResponse < FaradayResponse
+      RETRYABLE_ERRORS = 4001..4004
+
+      attr_reader :error_code, :message, :ref_id, :detail
+
+      def initialize(result, faraday_response)
+        super(faraday_response)
+        @error_code = result[:errorCode]
+        @message = result[:message]
+        @ref_id = result[:refId]
+        @detail = result[:detail]
+      end
+
+      def should_retry?
+        RETRYABLE_ERRORS.include? error_code
+      end
+
+      def success?
+        false
+      end
+    end
+
+    class FaradaySuccessResponse < FaradayResponse
+      attr_reader :result
+
+      def initialize(result, faraday_response)
+        super(faraday_response)
+        @result = result
+      end
+
+      def should_retry?
+        false
+      end
+
+      def success?
+        true
+      end
+    end
+  end
+end

data/lib/smartsheet/api/faraday_adapter/middleware/faraday_error_translator.rb

@@ -0,0 +1,20 @@
+require 'faraday'
+require 'smartsheet/error'
+
+module Smartsheet
+  module API
+    module Middleware
+      class FaradayErrorTranslator < Faraday::Middleware
+        def initialize(app)
+          super(app)
+        end
+
+        def call(env)
+          @app.call(env)
+        rescue Faraday::Error => e
+          raise Smartsheet::RequestError, e
+        end
+      end
+    end
+  end
+end

data/lib/smartsheet/api/faraday_adapter/middleware/response_parser.rb

@@ -0,0 +1,25 @@
+require 'faraday'
+require 'json'
+require 'smartsheet/api/faraday_adapter/faraday_response'
+
+module Smartsheet
+  module API
+    module Middleware
+      class ResponseParser < Faraday::Middleware
+        def initialize(app)
+          super(app)
+        end
+
+        def call(env)
+          @app.call(env).on_complete do |response_env|
+            if response_env[:response_headers]['content-type'] =~ /\bjson\b/
+              response_env[:body] = JSON.parse(response_env[:body], symbolize_names: true)
+            end
+
+            response_env[:body] = FaradayResponse.from_response_env response_env
+          end
+        end
+      end
+    end
+  end
+end

data/lib/smartsheet/api/file_spec.rb

@@ -0,0 +1,28 @@
+require 'cgi'
+require 'faraday'
+
+module Smartsheet
+  module API
+    class PathFileSpec
+      attr_reader :upload_io, :filename, :content_type, :file_length
+
+      def initialize(path, filename, content_type)
+        @file_length = File.size(path)
+        @filename = filename.nil? ? File.basename(path) : filename
+        @upload_io = Faraday::UploadIO.new(path, content_type, CGI::escape(@filename))
+        @content_type = content_type
+      end
+    end
+
+    class ObjectFileSpec
+      attr_reader :upload_io, :filename, :content_type, :file_length
+
+      def initialize(file, filename, file_length, content_type)
+        @file_length = file_length
+        @filename = filename
+        @upload_io = Faraday::UploadIO.new(file, content_type, CGI::escape(filename))
+        @content_type = content_type
+      end
+    end
+  end
+end

data/lib/smartsheet/api/header_builder.rb

@@ -0,0 +1,85 @@
+require 'cgi'
+require 'smartsheet/version'
+require 'smartsheet/constants'
+
+module Smartsheet
+  module API
+    # Constructs headers for accessing the Smartsheet API
+    class HeaderBuilder
+      include Smartsheet::Constants
+      def initialize(token, endpoint_spec, request_spec, assume_user: nil)
+        @token = token
+        @endpoint_spec = endpoint_spec
+        @request_spec = request_spec
+        @assume_user = assume_user
+      end
+
+      def build
+        base_headers
+            .merge(endpoint_headers)
+            .merge(content_type)
+            .merge(content_disposition)
+            .merge(content_length)
+            .merge(request_headers)
+            .merge(assume_user)
+      end
+
+      private
+
+      attr_accessor :endpoint_spec, :request_spec
+      attr_reader :token
+
+      def base_headers
+        base = {
+            Accept: JSON_TYPE,
+            'User-Agent': "#{USER_AGENT}/#{Smartsheet::VERSION}"
+        }
+        base[:Authorization] = "Bearer #{token}" if endpoint_spec.requires_auth?
+
+        base
+      end
+
+      def assume_user
+        if @assume_user.nil?
+          {}
+        else
+          {'Assume-User': CGI::escape(@assume_user)}
+        end
+      end
+
+      def endpoint_headers
+        endpoint_spec.headers
+      end
+
+      def content_type
+        if endpoint_spec.sending_json? && request_spec.body
+          {'Content-Type': JSON_TYPE}
+        elsif endpoint_spec.sending_file?
+          {'Content-Type': request_spec.content_type}
+        else
+          {}
+        end
+      end
+
+      def content_disposition
+        if endpoint_spec.sending_file?
+          {'Content-Disposition': "attachment; filename=\"#{CGI::escape(request_spec.filename)}\""}
+        else
+          {}
+        end
+      end
+
+      def content_length
+        if endpoint_spec.sending_file?
+          {'Content-Length': request_spec.file_length.to_s}
+        else
+          {}
+        end
+      end
+
+      def request_headers
+        request_spec.header_overrides
+      end
+    end
+  end
+end

data/lib/smartsheet/api/request.rb

@@ -0,0 +1,29 @@
+require 'smartsheet/api/url_builder'
+require 'smartsheet/api/header_builder'
+require 'smartsheet/api/body_builder'
+
+module Smartsheet
+  module API
+    class Request
+      attr_reader :method, :url, :headers, :params, :body
+
+      def initialize(token, endpoint_spec, request_spec, base_url, assume_user: nil)
+        @method = endpoint_spec.method
+        @url = Smartsheet::API::UrlBuilder.new(endpoint_spec, request_spec, base_url).build
+        @headers = Smartsheet::API::HeaderBuilder.new(token, endpoint_spec, request_spec, assume_user: assume_user).build
+        @params = request_spec.params
+        @body = Smartsheet::API::BodyBuilder.new(endpoint_spec, request_spec).build
+      end
+
+      def ==(other)
+        other.class == self.class && other.equality_state == equality_state
+      end
+
+      protected
+
+      def equality_state
+        [method, url, headers, params, body]
+      end
+    end
+  end
+end

data/lib/smartsheet/api/request_client.rb

@@ -0,0 +1,26 @@
+require 'smartsheet/error'
+
+module Smartsheet
+  module API
+    class RequestClient
+      def initialize(token, client, base_url, assume_user: nil, logger: MuteRequestLogger.new)
+        @token = token
+        @client = client
+        @assume_user = assume_user
+        @logger = logger
+        @base_url = base_url
+      end
+
+      def make_request(endpoint_spec, request_spec)
+        request = Request.new(token, endpoint_spec, request_spec, base_url, assume_user: assume_user)
+
+        logger.log_request(request)
+        client.make_request(request)
+      end
+
+      private
+
+      attr_reader :token, :client, :assume_user, :logger, :base_url
+    end
+  end
+end

data/lib/smartsheet/api/request_logger.rb

@@ -0,0 +1,148 @@
+require 'logger'
+
+module Smartsheet
+  module API
+    class Censor
+      EXPOSED_CHARS = 4
+
+      def initialize(*blacklist)
+        @blacklist = Set.new(blacklist)
+      end
+
+      def censor_hash(h)
+        h.collect do |(k, v)|
+          new_v = blacklist.include?(k.to_s) ? censor(v) : v
+          [k, new_v]
+        end.to_h
+      end
+
+      def censor(str)
+        total_length = str.length
+        censored_length = [total_length - EXPOSED_CHARS, 0].max
+        ('*' * censored_length) + str[censored_length...total_length]
+      end
+
+      private
+
+      attr_reader :blacklist
+    end
+
+    class RequestLogger
+      QUERY_PARAM_CENSOR = Censor.new 'code', 'client_id', 'hash', 'refresh_token'
+      HEADER_CENSOR = Censor.new 'authorization'
+      PAYLOAD_CENSOR = Censor.new 'access_token', 'refresh_token'
+
+      TRUNCATED_BODY_LENGTH = 1024
+
+      def initialize(logger, log_full_body:)
+        @logger = logger
+        @log_full_body = log_full_body
+      end
+
+      def log_request(request)
+        log_request_basics(Logger::INFO, request)
+        log_headers('Request', request)
+        log_body('Request', request.body)
+      end
+
+      def log_retry_attempt(request, response, attempt_num)
+        logger.warn { "Request attempt #{attempt_num} failed" }
+        log_request_basics(Logger::WARN, request)
+        log_api_error(Logger::WARN, response)
+      end
+
+      def log_retry_failure(num_tries)
+        try_word = num_tries == 1 ? 'try' : 'tries'
+        logger.error { "Request failed after #{num_tries} #{try_word}" }
+      end
+
+      def log_successful_response(response)
+        log_status(Logger::INFO, response)
+        log_headers('Response', response)
+        log_body('Response', response.result)
+      end
+
+      def log_error_response(request, error)
+        log_request_basics(Logger::ERROR, request)
+        log_api_error(Logger::ERROR, error)
+      end
+
+      private
+
+      attr_reader :logger, :log_full_body
+
+      def log_request_basics(level, request)
+        logger.log(level) { "Request: #{request.method} #{build_logging_url(request)}" }
+      end
+
+      def build_logging_url(request)
+        query_params = QUERY_PARAM_CENSOR.censor_hash(request.params)
+        query_param_str =
+          if query_params.empty?
+            ''
+          else
+            '?' + query_params.collect { |(k, v)| "#{k}=#{v}" }.join('&') # TODO: URI Encoding
+          end
+        request.url + query_param_str
+      end
+
+      def log_api_error(level, response)
+        log_status(level, response)
+        logger.log(level) do
+          "#{response.error_code}: #{response.message} - Ref ID: #{response.ref_id}"
+        end
+        log_headers('Response', response)
+      end
+
+      def log_status(level, response)
+        logger.log(level) { "Response: #{response.status_code} #{response.reason_phrase}" }
+      end
+
+      def log_headers(context, req_or_resp)
+        logger.debug { "#{context} Headers: #{HEADER_CENSOR.censor_hash(req_or_resp.headers)}" }
+      end
+
+      def log_body(context, body)
+        return unless body
+
+        body_str =
+            if body.is_a? String
+              body
+            elsif body.is_a? Hash
+              PAYLOAD_CENSOR.censor_hash(body).to_s
+            else
+              '<Binary body>'
+            end
+
+        body_str = truncate_body(body_str) unless log_full_body
+
+        logger.debug "#{context} Body: #{body_str}"
+      end
+
+      def truncate_body(body_str)
+        if body_str.length > TRUNCATED_BODY_LENGTH
+          body_str[0...TRUNCATED_BODY_LENGTH] + '...'
+        else
+          body_str
+        end
+      end
+    end
+
+    class MuteRequestLogger
+      def log_request(request)
+      end
+
+      def log_retry_attempt(request, response, attempt_num)
+      end
+
+      def log_retry_failure(num_retries)
+      end
+
+      def log_successful_response(response)
+      end
+
+      def log_error_response(request, error)
+      end
+    end
+  end
+end