restforce 4.2.1 → 6.0.0

data/lib/restforce/mash.rb

@@ -11,9 +11,10 @@ module Restforce
       # appropriate Restforce::Collection, Restforce::SObject and
       # Restforce::Mash objects.
       def build(val, client)
-        if val.is_a?(Array)
+        case val
+        when Array
           val.collect { |a_val| self.build(a_val, client) }
-        elsif val.is_a?(Hash)
+        when Hash
           self.klass(val).new(val, client)
         else
           val
@@ -28,7 +29,7 @@ module Restforce
           # of sobject records.
           Restforce::Collection
         elsif val.key? 'attributes'
-          case (val['attributes']['type'])
+          case val.dig('attributes', 'type')
           when "Attachment"
             Restforce::Attachment
           when "Document"
@@ -55,6 +56,9 @@ module Restforce
       self.class.new(self, @client, self.default)
     end
 
+    # The #convert_value method and its signature are part of Hashie::Mash's API, so we
+    # can't unilaterally decide to change `duping` to be a keyword argument
+    # rubocop:disable Style/OptionalBooleanParameter
     def convert_value(val, duping = false)
       case val
       when self.class
@@ -68,5 +72,6 @@ module Restforce
         val
       end
     end
+    # rubocop:enable Style/OptionalBooleanParameter
   end
 end

data/lib/restforce/middleware/authentication.rb

@@ -49,6 +49,7 @@ module Restforce
       @connection ||= Faraday.new(faraday_options) do |builder|
         builder.use Faraday::Request::UrlEncoded
         builder.use Restforce::Middleware::Mashify, nil, @options
+        builder.use Faraday::FollowRedirects::Middleware
         builder.response :json
 
         if Restforce.log?

data/lib/restforce/middleware/caching.rb

@@ -1,30 +1,155 @@
 # frozen_string_literal: true
 
+#
+# Taken from `lib/faraday_middleware/response/caching.rb` in the `faraday_middleware`
+# gem (<https://github.com/lostisland/faraday_middleware/blob/784b4f8/lib/faraday_middleware/response/caching.rb>).
+#
+# Includes some small modifications to allow the cache to be cleared in
+# `#without_caching` mode, replicating traditional Restforce behaviour.
+#
+# Copyright (c) 2011 Erik Michaels-Ober, Wynn Netherland, et al.
+# Licensed under the MIT License.
+#
+require 'faraday'
+require 'forwardable'
+require 'digest/sha1'
+
 module Restforce
-  class Middleware::Caching < FaradayMiddleware::Caching
-    def call(env)
-      expire(cache_key(env)) unless use_cache?
-      super
+  # Public: Caches GET responses and pulls subsequent ones from the cache.
+  class Middleware::Caching < Faraday::Middleware
+    attr_reader :cache
+
+    # Internal: List of status codes that can be cached:
+    # * 200 - 'OK'
+    # * 203 - 'Non-Authoritative Information'
+    # * 300 - 'Multiple Choices'
+    # * 301 - 'Moved Permanently'
+    # * 302 - 'Found'
+    # * 404 - 'Not Found'
+    # * 410 - 'Gone'
+    CACHEABLE_STATUS_CODES = [200, 203, 300, 301, 302, 404, 410].freeze
+
+    extend Forwardable
+    def_delegators :'Faraday::Utils', :parse_query, :build_query
+
+    # Public: initialize the middleware.
+    #
+    # cache   - An object that responds to read and write (default: nil).
+    # options - An options Hash (default: {}):
+    #           :ignore_params - String name or Array names of query
+    #                                    params that should be ignored when forming
+    #                                    the cache key (default: []).
+    #           :write_options - Hash of settings that should be passed as the
+    #                                    third options parameter to the cache's #write
+    #                                    method. If not specified, no options parameter
+    #                                    will be passed.
+    #           :full_key      - Boolean - use full URL as cache key:
+    #                                    (url.host + url.request_uri)
+    #           :status_codes  - Array of http status code to be cache
+    #                                    (default: CACHEABLE_STATUS_CODE)
+    #
+    # Yields if no cache is given. The block should return a cache object.
+    def initialize(app, cache = nil, options = {})
+      super(app)
+      if cache.is_a?(Hash) && block_given?
+        options = cache
+        cache = nil
+      end
+      @cache = cache || yield
+      @options = options
     end
 
-    def expire(key)
-      cache&.delete(key)
+    def call(env)
+      # Taken from `Restforce::Middleware::Caching` implementation
+      # before we switched away from the `faraday_middleware` gem.
+      # See https://github.com/restforce/restforce/blob/a08b9d6c5e277bd7111ffa7ed50465dd49c05fab/lib/restforce/middleware/caching.rb.
+      cache&.delete(cache_key(env)) unless use_cache?
+
+      if env[:method] == :get
+        if env[:parallel_manager]
+          # callback mode
+          cache_on_complete(env)
+        else
+          # synchronous mode
+          key = cache_key(env)
+          unless (response = cache.read(key)) && response
+            response = @app.call(env)
+            store_response_in_cache(key, response)
+          end
+          finalize_response(response, env)
+        end
+      else
+        @app.call(env)
+      end
     end
 
-    # We don't want to cache requests for different clients, so append the
-    # oauth token to the cache key.
     def cache_key(env)
-      super(env) + hashed_auth_header(env)
+      url = env[:url].dup
+      if url.query && params_to_ignore.any?
+        params = parse_query url.query
+        params.reject! { |k,| params_to_ignore.include? k }
+        url.query = params.any? ? build_query(params) : nil
+      end
+      url.normalize!
+      digest = full_key? ? url.host + url.request_uri : url.request_uri
+      Digest::SHA1.hexdigest(digest)
     end
 
-    def use_cache?
-      @options.fetch(:use_cache, true)
+    def params_to_ignore
+      @params_to_ignore ||= Array(@options[:ignore_params]).map(&:to_s)
+    end
+
+    def full_key?
+      @full_key ||= @options[:full_key]
     end
 
-    def hashed_auth_header(env)
-      Digest::SHA1.hexdigest(
-        env[:request_headers][Restforce::Middleware::Authorization::AUTH_HEADER]
-      )
+    def custom_status_codes
+      @custom_status_codes ||= begin
+        codes = CACHEABLE_STATUS_CODES & Array(@options[:status_codes]).map(&:to_i)
+        codes.any? ? codes : CACHEABLE_STATUS_CODES
+      end
+    end
+
+    def cache_on_complete(env)
+      key = cache_key(env)
+      if (cached_response = cache.read(key))
+        finalize_response(cached_response, env)
+      else
+        # response.status is nil at this point
+        # any checks need to be done inside on_complete block
+        @app.call(env).on_complete do |response_env|
+          store_response_in_cache(key, response_env.response)
+          response_env
+        end
+      end
+    end
+
+    def store_response_in_cache(key, response)
+      return unless custom_status_codes.include?(response.status)
+
+      if @options[:write_options]
+        cache.write(key, response, @options[:write_options])
+      else
+        cache.write(key, response)
+      end
+    end
+
+    def finalize_response(response, env)
+      response = response.dup if response.frozen?
+      env[:response] = response
+      unless env[:response_headers]
+        env.update response.env
+        # FIXME: omg hax
+        response.instance_variable_set('@env', env)
+      end
+      response
+    end
+
+    # Taken from `Restforce::Middleware::Caching` implementation
+    # before we switched away from the `faraday_middleware` gem.
+    # See https://github.com/restforce/restforce/blob/a08b9d6c5e277bd7111ffa7ed50465dd49c05fab/lib/restforce/middleware/caching.rb.
+    def use_cache?
+      @options[:use_cache]
     end
   end
 end

data/lib/restforce/middleware/json_request.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+#
+# Adapted from `lib/faraday/request/json.rb` in the `faraday`
+# gem (<https://github.com/lostisland/faraday/blob/5366029282968d59980a182258f8c2b0212721c8/lib/faraday/request/json.rb>).
+#
+# We use this because we want to support Faraday 1.x and Faraday 2.x.
+# Faraday 2.x has the JSON middlewares included, but Faraday 1.x doesn't,
+# forcing you to use the `faraday_middleware` gem. This approach allows us
+# to support both.
+#
+# Copyright (c) 2009-2022 Rick Olson, Zack Hobson
+# Licensed under the MIT License.
+#
+require 'json'
+
+module Restforce
+  # Request middleware that encodes the body as JSON.
+  #
+  # Processes only requests with matching Content-type or those without a type.
+  # If a request doesn't have a type but has a body, it sets the Content-type
+  # to JSON MIME-type.
+  #
+  # Doesn't try to encode bodies that already are in string form.
+  # rubocop:disable Style/ClassAndModuleChildren
+  class Middleware::JsonRequest < Faraday::Middleware
+    # rubocop:enable Style/ClassAndModuleChildren
+
+    # This is the only line that differs substantively from the version in
+    # Faraday. In Faraday, this refers to a Faraday constant.
+    CONTENT_TYPE = 'Content-Type'
+
+    MIME_TYPE = 'application/json'
+    MIME_TYPE_REGEX = %r{^application/(vnd\..+\+)?json$}.freeze
+
+    #
+    # Taken from `lib/faraday/middleware.rb` in the `faraday`
+    # gem (<https://github.com/lostisland/faraday/blob/08b7d4d/lib/faraday/middleware.rb>),
+    # with a tiny adaptation to refer to the `@app` instance
+    # variable rather than expecting an `attr_reader` to exist.
+    #
+    # In Faraday versions before v1.2.0, `#call`  is missing.
+    #
+    # Copyright (c) 2009-2022 Rick Olson, Zack Hobson
+    # Licensed under the MIT License.
+    #
+    def call(env)
+      on_request(env) if respond_to?(:on_request)
+      @app.call(env).on_complete do |environment|
+        on_complete(environment) if respond_to?(:on_complete)
+      end
+    end
+
+    def on_request(env)
+      match_content_type(env) do |data|
+        env[:body] = encode(data)
+      end
+    end
+
+    private
+
+    def encode(data)
+      ::JSON.generate(data)
+    end
+
+    def match_content_type(env)
+      return unless process_request?(env)
+
+      env[:request_headers][CONTENT_TYPE] ||= MIME_TYPE
+      yield env[:body] unless env[:body].respond_to?(:to_str)
+    end
+
+    def process_request?(env)
+      type = request_type(env)
+      body?(env) && (type.empty? || type.match?(MIME_TYPE_REGEX))
+    end
+
+    def body?(env)
+      (body = env[:body]) && !(body.respond_to?(:to_str) && body.empty?)
+    end
+
+    def request_type(env)
+      type = env[:request_headers][CONTENT_TYPE].to_s
+      type = type.split(';', 2).first if type.index(';')
+      type
+    end
+  end
+end
+
+Faraday::Request.register_middleware(json: Restforce::Middleware::JsonRequest)

data/lib/restforce/middleware/json_response.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+#
+# Adapted from `lib/faraday/response/json.rb` in the `faraday`
+# gem (<https://github.com/lostisland/faraday/blob/5366029/lib/faraday/response/json.rb>).
+#
+# Copyright (c) 2009-2022 Rick Olson, Zack Hobson
+# Licensed under the MIT License.
+#
+
+require 'json'
+
+module Restforce
+  # rubocop:disable Style/ClassAndModuleChildren
+  class Middleware::JsonResponse < Faraday::Middleware
+    # rubocop:enable Style/ClassAndModuleChildren
+
+    # This is the only line that differs substantively from the version in
+    # Faraday. In Faraday, this refers to a Faraday constant.
+    CONTENT_TYPE = 'Content-Type'
+
+    def initialize(app = nil, parser_options: nil, content_type: /\bjson$/,
+                   preserve_raw: false)
+      super(app)
+      @parser_options = parser_options
+      @content_types = Array(content_type)
+      @preserve_raw = preserve_raw
+    end
+
+    #
+    # Taken from `lib/faraday/middleware.rb` in the `faraday`
+    # gem (<https://github.com/lostisland/faraday/blob/08b7d4d/lib/faraday/middleware.rb>),
+    # with a tiny adaptation to refer to the `@app` instance
+    # variable rather than expecting an `attr_reader` to exist.
+    #
+    # In Faraday versions before v1.2.0, `#call`  is missing.
+    #
+    # Copyright (c) 2009-2022 Rick Olson, Zack Hobson
+    # Licensed under the MIT License.
+    #
+    def call(env)
+      on_request(env) if respond_to?(:on_request)
+      @app.call(env).on_complete do |environment|
+        on_complete(environment) if respond_to?(:on_complete)
+      end
+    end
+
+    def on_complete(env)
+      process_response(env) if parse_response?(env)
+    end
+
+    private
+
+    def process_response(env)
+      env[:raw_body] = env[:body] if @preserve_raw
+      env[:body] = parse(env[:body])
+    rescue StandardError, SyntaxError => e
+      raise Faraday::ParsingError.new(e, env[:response])
+    end
+
+    def parse(body)
+      ::JSON.parse(body, @parser_options || {}) unless body.strip.empty?
+    end
+
+    def parse_response?(env)
+      process_response_type?(env) &&
+        env[:body].respond_to?(:to_str)
+    end
+
+    def process_response_type?(env)
+      type = response_type(env)
+      @content_types.empty? || @content_types.any? do |pattern|
+        pattern.is_a?(Regexp) ? type.match?(pattern) : type == pattern
+      end
+    end
+
+    def response_type(env)
+      type = env[:response_headers][CONTENT_TYPE].to_s
+      type = type.split(';', 2).first if type.index(';')
+      type
+    end
+  end
+end
+
+Faraday::Response.register_middleware(json: Restforce::Middleware::JsonResponse)

data/lib/restforce/middleware/logger.rb

@@ -3,7 +3,7 @@
 require 'forwardable'
 
 module Restforce
-  class Middleware::Logger < Faraday::Response::Middleware
+  class Middleware::Logger < Faraday::Middleware
     extend Forwardable
 
     def initialize(app, logger, options)
@@ -11,7 +11,7 @@ module Restforce
       @options = options
       @logger = logger || begin
         require 'logger'
-        ::Logger.new(STDOUT)
+        ::Logger.new($stdout)
       end
     end
 
@@ -20,23 +20,28 @@ module Restforce
     def call(env)
       debug('request') do
         dump url: env[:url].to_s,
-          method: env[:method],
-          headers: env[:request_headers],
-          body: env[:body]
+             method: env[:method],
+             headers: env[:request_headers],
+             body: env[:body]
+      end
+
+      on_request(env) if respond_to?(:on_request)
+      @app.call(env).on_complete do |environment|
+        on_complete(environment) if respond_to?(:on_complete)
       end
-      super
     end
 
     def on_complete(env)
       debug('response') do
         dump status: env[:status].to_s,
-          headers: env[:response_headers],
-          body: env[:body]
+             headers: env[:response_headers],
+             body: env[:body]
       end
     end
 
     def dump(hash)
-      "\n" + hash.map { |k, v| "  #{k}: #{v.inspect}" }.join("\n")
+      dumped_pairs = hash.map { |k, v| "  #{k}: #{v.inspect}" }.join("\n")
+      "\n#{dumped_pairs}"
     end
   end
 end

data/lib/restforce/middleware/raise_error.rb

@@ -1,7 +1,16 @@
 # frozen_string_literal: true
 
 module Restforce
-  class Middleware::RaiseError < Faraday::Response::Middleware
+  class Middleware::RaiseError < Faraday::Middleware
+    # Required for Faraday versions pre-v1.2.0 which do not include
+    # an implementation of `#call` by default
+    def call(env)
+      on_request(env) if respond_to?(:on_request)
+      @app.call(env).on_complete do |environment|
+        on_complete(environment) if respond_to?(:on_complete)
+      end
+    end
+
     def on_complete(env)
       @env = env
       case env[:status]
@@ -11,9 +20,9 @@ module Restforce
           response_values
         )
       when 401
-        raise Restforce::UnauthorizedError, message
+        raise Restforce::UnauthorizedError.new(message, response_values)
       when 404
-        raise Restforce::NotFoundError, message
+        raise Restforce::NotFoundError.new(message, response_values)
       when 413
         raise Restforce::EntityTooLargeError.new(
           "413: Request Entity Too Large",
@@ -56,8 +65,7 @@ module Restforce
     def exception_class_for_error_code(error_code)
       return Restforce::ResponseError unless ERROR_CODE_MATCHER.match?(error_code)
 
-      constant_name = error_code.split('_').map(&:capitalize).join.to_sym
-      Restforce::ErrorCode.const_get(constant_name)
+      Restforce::ErrorCode.get_exception_class(error_code)
     end
   end
 end

data/lib/restforce/middleware.rb

@@ -16,6 +16,8 @@ module Restforce
     autoload :CustomHeaders,  'restforce/middleware/custom_headers'
 
     def initialize(app, client, options)
+      super(app)
+
       @app = app
       @client = client
       @options = options

data/lib/restforce/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Restforce
-  VERSION = '4.2.1'
+  VERSION = '6.0.0'
 end

data/lib/restforce.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require 'faraday'
-require 'faraday_middleware'
+require 'faraday/follow_redirects'
 require 'json'
 require 'jwt'
 
@@ -15,7 +15,8 @@ module Restforce
   autoload :Middleware,     'restforce/middleware'
   autoload :Attachment,     'restforce/attachment'
   autoload :Document,       'restforce/document'
-  autoload :UploadIO,       'restforce/upload_io'
+  autoload :FilePart,       'restforce/file_part'
+  autoload :UploadIO,       'restforce/file_part' # Deprecated
   autoload :SObject,        'restforce/sobject'
   autoload :Client,         'restforce/client'
   autoload :Mash,           'restforce/mash'
@@ -31,6 +32,7 @@ module Restforce
     autoload :Base,           'restforce/concerns/base'
     autoload :API,            'restforce/concerns/api'
     autoload :BatchAPI,       'restforce/concerns/batch_api'
+    autoload :CompositeAPI,   'restforce/concerns/composite_api'
   end
 
   module Data
@@ -44,9 +46,10 @@ module Restforce
   Error               = Class.new(StandardError)
   ServerError         = Class.new(Error)
   AuthenticationError = Class.new(Error)
-  UnauthorizedError   = Class.new(Error)
+  UnauthorizedError   = Class.new(Faraday::ClientError)
   APIVersionError     = Class.new(Error)
   BatchAPIError       = Class.new(Error)
+  CompositeAPIError   = Class.new(Error)
 
   # Inherit from Faraday::ResourceNotFound for backwards-compatibility
   # Consumers of this library that rescue and handle Faraday::ResourceNotFound
@@ -60,26 +63,24 @@ module Restforce
   MatchesMultipleError= Class.new(ResponseError)
   EntityTooLargeError = Class.new(ResponseError)
 
-  module ErrorCode
-    def self.const_missing(constant_name)
-      const_set constant_name, Class.new(ResponseError)
-    end
-  end
+  require 'restforce/error_code'
+  require 'restforce/middleware/json_request'
+  require 'restforce/middleware/json_response'
 
   class << self
     # Alias for Restforce::Data::Client.new
     #
     # Shamelessly pulled from https://github.com/pengwynn/octokit/blob/master/lib/octokit.rb
-    def new(*args, &block)
-      data(*args, &block)
+    def new(...)
+      data(...)
     end
 
-    def data(*args, &block)
-      Restforce::Data::Client.new(*args, &block)
+    def data(...)
+      Restforce::Data::Client.new(...)
     end
 
-    def tooling(*args, &block)
-      Restforce::Tooling::Client.new(*args, &block)
+    def tooling(...)
+      Restforce::Tooling::Client.new(...)
     end
 
     # Helper for decoding signed requests.

data/restforce.gemspec

@@ -3,39 +3,31 @@
 require File.expand_path('lib/restforce/version', __dir__)
 
 Gem::Specification.new do |gem|
-  gem.authors       = ["Eric J. Holmes", "Tim Rogers"]
-  gem.email         = ["eric@ejholmes.net", "tim@gocardless.com"]
-  gem.description   = 'A lightweight ruby client for the Salesforce REST API.'
-  gem.summary       = 'A lightweight ruby client for the Salesforce REST API.'
-  gem.homepage      = "http://restforce.org/"
+  gem.authors       = ["Tim Rogers", "Eric J. Holmes"]
+  gem.email         = ["me@timrogers.co.uk", "eric@ejholmes.net"]
+  gem.description   = 'A lightweight Ruby client for the Salesforce REST API'
+  gem.summary       = 'A lightweight Ruby client for the Salesforce REST API'
+  gem.homepage      = "https://restforce.github.io/"
   gem.license       = "MIT"
 
   gem.files         = `git ls-files`.split($OUTPUT_RECORD_SEPARATOR)
   gem.executables   = gem.files.grep(%r{^bin/}).map { |f| File.basename(f) }
-  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.name          = "restforce"
   gem.require_paths = ["lib"]
   gem.version       = Restforce::VERSION
 
   gem.metadata = {
     'source_code_uri' => 'https://github.com/restforce/restforce',
-    'changelog_uri'   => 'https://github.com/restforce/restforce/blob/master/CHANGELOG.md'
+    'changelog_uri'   => 'https://github.com/restforce/restforce/blob/master/CHANGELOG.md',
+'rubygems_mfa_required' => 'true'
   }
 
-  gem.required_ruby_version = '>= 2.4'
+  gem.required_ruby_version = '>= 2.7'
 
-  gem.add_dependency 'faraday', '<= 1.0', '>= 0.9.0'
-  gem.add_dependency 'faraday_middleware', ['>= 0.8.8', '<= 1.0']
-
-  gem.add_dependency 'json', '>= 1.7.5'
+  gem.add_dependency 'faraday', '< 2.5.0', '>= 1.1.0'
+  gem.add_dependency 'faraday-follow_redirects', '<= 0.3.0', '< 1.0.0'
+  gem.add_dependency 'faraday-multipart', '>= 1.0.0', '< 2.0.0'
+  gem.add_dependency 'faraday-net_http', '< 3.0.0'
+  gem.add_dependency 'hashie', '>= 1.2.0', '< 6.0'
   gem.add_dependency 'jwt', ['>= 1.5.6']
-
-  gem.add_dependency 'hashie', '>= 1.2.0', '< 5.0'
-
-  gem.add_development_dependency 'faye' unless RUBY_PLATFORM == 'java'
-  gem.add_development_dependency 'rspec', '~> 2.14.0'
-  gem.add_development_dependency 'rspec_junit_formatter', '~> 0.4.1'
-  gem.add_development_dependency 'rubocop', '~> 0.77.0'
-  gem.add_development_dependency 'simplecov', '~> 0.17.1'
-  gem.add_development_dependency 'webmock', '~> 3.7.6'
 end