activeresource 6.0.0 → 6.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f2a0c925e2619c4a4204eebdaea70776a57fec944e9eefeb98982ed8cf425bbc
-  data.tar.gz: b77c66a74c3fe0d32e16d0ce4eaaec1c772200bda9ea36b2bfba1a3cc4f58b5d
+  metadata.gz: 56d3dcccc623568664d512654a732adb1c7f4a254ab04e265ac1399d0e4c1967
+  data.tar.gz: d58a56b898820598bde4e7f285120623f91cd4abf16f5e9487b52922780b9dc1
 SHA512:
-  metadata.gz: 9116078833a262f5a4d184a9cd080f3a29bfc5c07481cf352dd87baa735ba0dfae6159a35ac37ea1ad2e121348a33d958151a048af8dbb6e85e3a387076de3b5
-  data.tar.gz: 02e8b7e3aa1fd89f70f67b2696d778bf0c4a5d89c4b6f779ec3ecffc6a099374c06515ec2bfcb4e7175a518f00543f16b1b691670378c2533fcf353ce82cb96f
+  metadata.gz: f3347abdf46c203bc277274a0f3f308e8582137a91471ae4ef2064acd7f869a1d12ce020e8031bee2ec710dfecd9933e4b5718ae3a3181116f08ccb5a5839305
+  data.tar.gz: c81b3391288de5f1031a6372354555d7cdad9f117e68193094b728e8e9851e35fbcea41a4b9b977b1338cad30095680935e9eb30c7ceee9e7d338ddf160ae660

data/README.md

@@ -112,7 +112,7 @@ end
 Active Resource is built on a standard JSON or XML format for requesting and submitting resources
 over HTTP. It mirrors the RESTful routing built into Action Controller but will also work with any
 other REST service that properly implements the protocol. REST uses HTTP, but unlike "typical" web
-applications, it makes use of all the verubys available in the HTTP specification:
+applications, it makes use of all the verbs available in the HTTP specification:
 
 * GET requests are used for finding and retrieving resources.
 * POST requests are used to create new resources.
@@ -296,6 +296,8 @@ The `payload` is a `Hash` with the following keys:
 
 * `method` as a `Symbol`
 * `request_uri` as a `String`
+* `headers` as a `Hash`
+* `body` as a `String` when available
 * `result` as an `Net::HTTPResponse`
 
 ## License

data/lib/active_resource/active_job_serializer.rb

@@ -18,9 +18,8 @@ module ActiveResource
       end
     end
 
-    private
-      def klass
-        ActiveResource::Base
-      end
+    def klass
+      ActiveResource::Base
+    end
   end
 end

data/lib/active_resource/associations/builder/association.rb

@@ -4,7 +4,7 @@ module ActiveResource::Associations::Builder
   class Association # :nodoc:
     # providing a Class-Variable, which will have a different store of subclasses
     class_attribute :valid_options
-    self.valid_options = [:class_name]
+    self.valid_options = [ :class_name ]
 
     # would identify subclasses of association
     class_attribute :macro

data/lib/active_resource/associations/builder/belongs_to.rb

@@ -2,7 +2,7 @@
 
 module ActiveResource::Associations::Builder
   class BelongsTo < Association
-    self.valid_options += [:foreign_key]
+    self.valid_options += [ :foreign_key ]
 
     self.macro = :belongs_to
 

data/lib/active_resource/base.rb

@@ -11,7 +11,6 @@ require "active_support/core_ext/object/blank"
 require "active_support/core_ext/object/to_query"
 require "active_support/core_ext/object/duplicable"
 require "set"
-require "uri"
 
 require "active_resource/connection"
 require "active_resource/formats"
@@ -213,6 +212,7 @@ module ActiveResource
   # * 301, 302, 303, 307 - ActiveResource::Redirection
   # * 400 - ActiveResource::BadRequest
   # * 401 - ActiveResource::UnauthorizedAccess
+  # * 402 - ActiveResource::PaymentRequired
   # * 403 - ActiveResource::ForbiddenAccess
   # * 404 - ActiveResource::ResourceNotFound
   # * 405 - ActiveResource::MethodNotAllowed
@@ -490,8 +490,8 @@ module ActiveResource
           self._site = nil
         else
           self._site = create_site_uri_from(site)
-          self._user = URI::DEFAULT_PARSER.unescape(_site.user) if _site.user
-          self._password = URI::DEFAULT_PARSER.unescape(_site.password) if _site.password
+          self._user = URI_PARSER.unescape(_site.user) if _site.user
+          self._password = URI_PARSER.unescape(_site.password) if _site.password
         end
       end
 
@@ -750,7 +750,7 @@ module ActiveResource
       # Default value is <tt>site.path</tt>.
       def prefix=(value = "/")
         # Replace :placeholders with '#{embedded options[:lookups]}'
-        prefix_call = value.gsub(/:\w+/) { |key| "\#{URI::DEFAULT_PARSER.escape options[#{key}].to_s}" }
+        prefix_call = value.gsub(/:\w+/) { |key| "\#{URI_PARSER.escape options[#{key}].to_s}" }
 
         # Clear prefix parameters in case they have been cached
         @prefix_parameters = nil
@@ -886,6 +886,31 @@ module ActiveResource
         "#{prefix(prefix_options)}#{collection_name}#{format_extension}#{query_string(query_options)}"
       end
 
+      # Gets the collection URL for the REST resources. If the +query_options+ parameter is omitted, Rails
+      # will split from the +prefix_options+.
+      #
+      # ==== Options
+      # * +prefix_options+ - A hash to add a prefix to the request for nested URLs (e.g., <tt>:account_id => 19</tt>
+      #   would yield a URL like <tt>/accounts/19/purchases.json</tt>).
+      # * +query_options+ - A hash to add items to the query string for the request.
+      #
+      # ==== Examples
+      #   Post.collection_url
+      #   # => https://example.com/posts.json
+      #
+      #   Comment.collection_url(:post_id => 5)
+      #   # => https://example.com/posts/5/comments.json
+      #
+      #   Comment.collection_url(:post_id => 5, :active => 1)
+      #   # => https://example.com/posts/5/comments.json?active=1
+      #
+      #   Comment.collection_url({:post_id => 5}, {:active => 1})
+      #   # => https://example.com/posts/5/comments.json?active=1
+      #
+      def collection_url(prefix_options = {}, query_options = nil)
+        URI.join(site, collection_path(prefix_options, query_options)).to_s
+      end
+
       alias_method :set_primary_key, :primary_key=  # :nodoc:
 
       # Builds a new, unsaved record using the default values from the remote server so
@@ -1037,12 +1062,13 @@ module ActiveResource
       # This is an alias for find(:all). You can pass in all the same
       # arguments to this method as you can to <tt>find(:all)</tt>
       def all(*args)
-        find(:all, *args)
+        WhereClause.new(self, *args)
       end
 
       def where(clauses = {})
+        clauses = sanitize_forbidden_attributes(clauses)
         raise ArgumentError, "expected a clauses Hash, got #{clauses.inspect}" unless clauses.is_a? Hash
-        find(:all, params: clauses)
+        all(params: clauses)
       end
 
 
@@ -1072,13 +1098,13 @@ module ActiveResource
       #
       #   Note.exists(1349) # => false
       def exists?(id, options = {})
-        if id
-          prefix_options, query_options = split_options(options[:params])
-          path = element_path(id, prefix_options, query_options)
-          response = connection.head(path, headers)
-          (200..206).include? response.code.to_i
-        end
-        # id && !find_single(id, options).nil?
+        return false unless id
+
+        prefix_options, query_options = split_options(options[:params])
+        path = element_path(id, prefix_options, query_options)
+        response = connection.head(path, headers)
+
+        (200..206).include?(response.code.to_i)
       rescue ActiveResource::ResourceNotFound, ActiveResource::ResourceGone
         false
       end
@@ -1443,6 +1469,8 @@ module ActiveResource
     #   my_branch.name # => "Wilson Road"
     def reload
       self.load(self.class.find(to_param, params: @prefix_options).attributes, false, true)
+    rescue => exception
+      rescue_with_handler(exception) || raise
     end
 
     # A method to manually load attributes from a \hash. Recursively loads collections of
@@ -1471,6 +1499,7 @@ module ActiveResource
         raise ArgumentError, "expected attributes to be able to convert to Hash, got #{attributes.inspect}"
       end
 
+      attributes = sanitize_forbidden_attributes(attributes)
       attributes = attributes.to_hash
       @prefix_options, attributes = split_options(attributes)
 
@@ -1627,7 +1656,7 @@ module ActiveResource
     private
       # Determine whether the response is allowed to have a body per HTTP 1.1 spec section 4.4.1
       def response_code_allows_body?(c)
-        !((100..199).include?(c) || [204, 304].include?(c))
+        !((100..199).include?(c) || [ 204, 304 ].include?(c))
       end
 
       # Tries to find a resource for a given collection name; if it fails, then the resource is created
@@ -1643,7 +1672,7 @@ module ActiveResource
         namespaces = module_names[0, module_names.size - 1].map do |module_name|
           receiver = receiver.const_get(module_name)
         end
-        const_args = [resource_name, false]
+        const_args = [ resource_name, false ]
         if namespace = namespaces.reverse.detect { |ns| ns.const_defined?(*const_args) }
           namespace.const_get(*const_args)
         else
@@ -1656,7 +1685,7 @@ module ActiveResource
         return reflections[name.to_sym].klass if reflections.key?(name.to_sym)
         resource_name = name.to_s.camelize
 
-        const_args = [resource_name, false]
+        const_args = [ resource_name, false ]
 
         if !const_valid?(*const_args)
           # resource_name is not a valid ruby module name and cannot be created normally
@@ -1718,14 +1747,16 @@ module ActiveResource
   end
 
   class Base
+    extend ActiveModel::ForbiddenAttributesProtection
     extend ActiveModel::Naming
     extend ActiveResource::Associations
 
-    include Callbacks, CustomMethods, Validations
+    include Callbacks, CustomMethods, Validations, Serialization
     include ActiveModel::Conversion
+    include ActiveModel::ForbiddenAttributesProtection
     include ActiveModel::Serializers::JSON
     include ActiveModel::Serializers::Xml
-    include ActiveResource::Reflection
+    include ActiveResource::Reflection, ActiveResource::Rescuable
   end
 
   ActiveSupport.run_load_hooks(:active_resource, Base)

data/lib/active_resource/coder.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module ActiveResource
+  # Integrates with Active Record's
+  # {serialize}[link:https://api.rubyonrails.org/classes/ActiveRecord/AttributeMethods/Serialization/ClassMethods.html#method-i-serialize]
+  # method as the <tt>:coder</tt> option.
+  #
+  # Encodes Active Resource instances into a value to be stored in the
+  # database. Decodes values read from the database into Active Resource
+  # instances.
+  #
+  #   class User < ActiveRecord::Base
+  #     serialize :person, coder: ActiveResource::Coder.new(Person)
+  #   end
+  #
+  #   class Person < ActiveResource::Base
+  #     schema do
+  #       attribute :name, :string
+  #     end
+  #   end
+  #
+  #   user = User.new
+  #   user.person = Person.new name: "Matz"
+  #   user.person.name # => "Matz"
+  #
+  # Values are loaded as persisted when decoded from data containing a
+  # primary key value, and new records when missing a primary key value:
+  #
+  #   user.person = Person.new
+  #   user.person.persisted? # => true
+  #
+  #   user.person = Person.find(1)
+  #   user.person.persisted? # => true
+  #
+  # By default, <tt>#dump</tt> serializes the instance to a string value by
+  # calling Base#encode:
+  #
+  #   user.person_before_type_cast # => "{\"name\":\"Matz\"}"
+  #
+  # To customize serialization, pass the method name or a block as the second
+  # argument:
+  #
+  #   person = Person.new name: "Matz"
+  #
+  #   coder = ActiveResource::Coder.new(Person, :serializable_hash)
+  #   coder.dump(person) # => { "name" => "Matz" }
+  #
+  #   coder = ActiveResource::Coder.new(Person) { |person| person.serializable_hash }
+  #   coder.dump(person) # => { "name" => "Matz" }
+  class Coder
+    attr_accessor :resource_class, :encoder
+
+    def initialize(resource_class, encoder_method = :encode, &block)
+      @resource_class = resource_class
+      @encoder = block || encoder_method
+    end
+
+    # Serializes a resource value to a value that will be stored in the database.
+    # Returns nil when passed nil
+    def dump(value)
+      return if value.nil?
+      raise ArgumentError.new("expected value to be #{resource_class}, but was #{value.class}") unless value.is_a?(resource_class)
+
+      value.yield_self(&encoder)
+    end
+
+    # Deserializes a value from the database to a resource instance.
+    # Returns nil when passed nil
+    def load(value)
+      return if value.nil?
+      value = resource_class.format.decode(value) if value.is_a?(String)
+      raise ArgumentError.new("expected value to be Hash, but was #{value.class}") unless value.is_a?(Hash)
+      resource_class.new(value, value[resource_class.primary_key])
+    end
+  end
+end

data/lib/active_resource/collection.rb

@@ -5,7 +5,7 @@ require "active_support/inflector"
 
 module ActiveResource # :nodoc:
   class Collection # :nodoc:
-    SELF_DEFINE_METHODS = [:to_a, :collect!, :map!, :all?]
+    SELF_DEFINE_METHODS = [ :to_a, :collect!, :map!, :all? ]
     include Enumerable
     delegate :to_yaml, :all?, *(Array.instance_methods(false) - SELF_DEFINE_METHODS), to: :to_a
 

data/lib/active_resource/connection.rb

@@ -5,7 +5,6 @@ require "active_support/core_ext/object/inclusion"
 require "net/https"
 require "date"
 require "time"
-require "uri"
 
 module ActiveResource
   # Class to handle connections to remote web services.
@@ -43,8 +42,8 @@ module ActiveResource
     def site=(site)
       @site = site.is_a?(URI) ? site : URI.parse(site)
       @ssl_options ||= {} if @site.is_a?(URI::HTTPS)
-      @user = URI::DEFAULT_PARSER.unescape(@site.user) if @site.user
-      @password = URI::DEFAULT_PARSER.unescape(@site.password) if @site.password
+      @user = URI_PARSER.unescape(@site.user) if @site.user
+      @password = URI_PARSER.unescape(@site.password) if @site.password
     end
 
     # Set the proxy for remote service.
@@ -117,9 +116,13 @@ module ActiveResource
     private
       # Makes a request to the remote service.
       def request(method, path, *arguments)
+        body, headers = arguments
+        headers, body = body, nil if headers.nil?
         result = ActiveSupport::Notifications.instrument("request.active_resource") do |payload|
           payload[:method]      = method
           payload[:request_uri] = "#{site.scheme}://#{site.host}:#{site.port}#{path}"
+          payload[:headers]     = headers
+          payload[:body]        = body
           payload[:result]      = http.send(method, path, *arguments)
         end
         handle_response(result)
@@ -127,6 +130,8 @@ module ActiveResource
         raise TimeoutError.new(e.message)
       rescue OpenSSL::SSL::SSLError => e
         raise SSLError.new(e.message)
+      rescue Errno::ECONNREFUSED => e
+        raise ConnectionRefusedError.new(e.message)
       end
 
       # Handles response and error codes from the remote service.
@@ -140,6 +145,8 @@ module ActiveResource
           raise(BadRequest.new(response))
         when 401
           raise(UnauthorizedAccess.new(response))
+        when 402
+          raise(PaymentRequired.new(response))
         when 403
           raise(ForbiddenAccess.new(response))
         when 404
@@ -173,8 +180,8 @@ module ActiveResource
 
       def new_http
         if @proxy
-          user = URI::DEFAULT_PARSER.unescape(@proxy.user) if @proxy.user
-          password = URI::DEFAULT_PARSER.unescape(@proxy.password) if @proxy.password
+          user = URI_PARSER.unescape(@proxy.user) if @proxy.user
+          password = URI_PARSER.unescape(@proxy.password) if @proxy.password
           Net::HTTP.new(@site.host, @site.port, @proxy.host, @proxy.port, user, password)
         else
           Net::HTTP.new(@site.host, @site.port)
@@ -211,7 +218,7 @@ module ActiveResource
 
       # Builds headers for request to remote service.
       def build_request_headers(headers, http_method, uri)
-        authorization_header(http_method, uri).update(default_header).update(http_format_header(http_method)).update(headers)
+        authorization_header(http_method, uri).update(default_header).update(http_format_header(http_method)).update(headers.to_hash)
       end
 
       def response_auth_header
@@ -233,7 +240,7 @@ module ActiveResource
           if auth_type == :digest
             { "Authorization" => digest_auth_header(http_method, uri) }
           else
-            { "Authorization" => "Basic " + ["#{@user}:#{@password}"].pack("m").delete("\r\n") }
+            { "Authorization" => "Basic " + [ "#{@user}:#{@password}" ].pack("m").delete("\r\n") }
           end
         elsif @bearer_token
           { "Authorization" => "Bearer #{@bearer_token}" }
@@ -252,7 +259,7 @@ module ActiveResource
         ha2 = Digest::MD5.hexdigest("#{http_method.to_s.upcase}:#{request_uri}")
 
         params["cnonce"] = client_nonce
-        request_digest = Digest::MD5.hexdigest([ha1, params["nonce"], "0", params["cnonce"], params["qop"], ha2].join(":"))
+        request_digest = Digest::MD5.hexdigest([ ha1, params["nonce"], "0", params["cnonce"], params["qop"], ha2 ].join(":"))
         "Digest #{auth_attributes_for(uri, request_digest, params)}"
       end
 
@@ -278,7 +285,7 @@ module ActiveResource
             %Q(nonce="#{params['nonce']}"),
             'nc="0"',
             %Q(cnonce="#{params['cnonce']}"),
-            %Q(response="#{request_digest}")]
+            %Q(response="#{request_digest}") ]
 
         auth_attrs << %Q(opaque="#{params['opaque']}") unless params["opaque"].blank?
         auth_attrs.join(", ")
@@ -291,7 +298,7 @@ module ActiveResource
       def legitimize_auth_type(auth_type)
         return :basic if auth_type.nil?
         auth_type = auth_type.to_sym
-        auth_type.in?([:basic, :digest, :bearer]) ? auth_type : :basic
+        auth_type.in?([ :basic, :digest, :bearer ]) ? auth_type : :basic
       end
   end
 end

data/lib/active_resource/custom_methods.rb

@@ -119,7 +119,7 @@ module ActiveResource
 
     private
       def custom_method_element_url(method_name, options = {})
-        "#{self.class.prefix(prefix_options)}#{self.class.collection_name}/#{id}/#{method_name}#{self.class.format_extension}#{self.class.__send__(:query_string, options)}"
+        "#{self.class.prefix(prefix_options)}#{self.class.collection_name}/#{URI.encode_www_form_component(id.to_s)}/#{method_name}#{self.class.format_extension}#{self.class.__send__(:query_string, options)}"
       end
 
       def custom_method_new_element_url(method_name, options = {})

data/lib/active_resource/exceptions.rb

@@ -35,6 +35,9 @@ module ActiveResource
     def to_s; @message ; end
   end
 
+  # Raised when a Errno::ECONNREFUSED occurs.
+  class ConnectionRefusedError < Errno::ECONNREFUSED; end
+
   # 3xx Redirection
   class Redirection < ConnectionError # :nodoc:
     def to_s
@@ -57,6 +60,10 @@ module ActiveResource
   class UnauthorizedAccess < ClientError # :nodoc:
   end
 
+  # 402 Payment Required
+  class PaymentRequired < ClientError # :nodoc:
+  end
+
   # 403 Forbidden
   class ForbiddenAccess < ClientError # :nodoc:
   end

data/lib/active_resource/formats.rb

@@ -10,7 +10,11 @@ module ActiveResource
     #   ActiveResource::Formats[:xml]  # => ActiveResource::Formats::XmlFormat
     #   ActiveResource::Formats[:json] # => ActiveResource::Formats::JsonFormat
     def self.[](mime_type_reference)
-      ActiveResource::Formats.const_get(ActiveSupport::Inflector.camelize(mime_type_reference.to_s) + "Format")
+      case mime_type_reference.to_s
+      when "xml" then XmlFormat
+      when "json" then JsonFormat
+      else ActiveResource::Formats.const_get(ActiveSupport::Inflector.camelize(mime_type_reference.to_s) + "Format")
+      end
     end
 
     def self.remove_root(data)

data/lib/active_resource/http_mock.rb

@@ -58,12 +58,12 @@ module ActiveResource
       end
 
       [ :post, :patch, :put, :get, :delete, :head ].each do |method|
-        # def post(path, request_headers = {}, body = nil, status = 200, response_headers = {})
-        #   @responses[Request.new(:post, path, nil, request_headers)] = Response.new(body || "", status, response_headers)
+        # def post(path, request_headers = {}, body = nil, status = 200, response_headers = {}, options: {})
+        #   @responses[Request.new(:post, path, nil, request_headers, options)] = Response.new(body || "", status, response_headers)
         # end
         module_eval <<-EOE, __FILE__, __LINE__ + 1
-          def #{method}(path, request_headers = {}, body = nil, status = 200, response_headers = {})
-            request  = Request.new(:#{method}, path, nil, request_headers)
+          def #{method}(path, request_headers = {}, body = nil, status = 200, response_headers = {}, options = {})
+            request  = Request.new(:#{method}, path, nil, request_headers, options)
             response = Response.new(body || "", status, response_headers)
 
             delete_duplicate_responses(request)
@@ -241,11 +241,11 @@ module ActiveResource
     end
 
     # body?       methods
-    { true  => %w(post patch put),
-      false => %w(get delete head) }.each do |has_body, methods|
+    { true  => %w[post patch put],
+      false => %w[get delete head] }.each do |has_body, methods|
       methods.each do |method|
-        # def post(path, body, headers)
-        #   request = ActiveResource::Request.new(:post, path, body, headers)
+        # def post(path, body, headers, options = {})
+        #   request = ActiveResource::Request.new(:post, path, body, headers, options)
         #   self.class.requests << request
         #   if response = self.class.responses.assoc(request)
         #     response[1]
@@ -254,8 +254,8 @@ module ActiveResource
         #   end
         # end
         module_eval <<-EOE, __FILE__, __LINE__ + 1
-          def #{method}(path, #{'body, ' if has_body}headers)
-            request = ActiveResource::Request.new(:#{method}, path, #{has_body ? 'body, ' : 'nil, '}headers)
+          def #{method}(path, #{'body, ' if has_body}headers, options = {})
+            request = ActiveResource::Request.new(:#{method}, path, #{has_body ? 'body, ' : 'nil, '}headers, options)
             self.class.requests << request
             if response = self.class.responses.assoc(request)
               response[1]
@@ -279,19 +279,34 @@ module ActiveResource
   class Request
     attr_accessor :path, :method, :body, :headers
 
-    def initialize(method, path, body = nil, headers = {})
-      @method, @path, @body, @headers = method, path, body, headers
+    def initialize(method, path, body = nil, headers = {}, options = {})
+      @method, @path, @body, @headers, @options = method, path, body, headers, options
     end
 
     def ==(req)
-      path == req.path && method == req.method && headers_match?(req)
+      same_path?(req) && method == req.method && headers_match?(req)
     end
 
     def to_s
       "<#{method.to_s.upcase}: #{path} [#{headers}] (#{body})>"
     end
 
+    # Removes query parameters from the path.
+    #
+    # @return [String] the path without query parameters
+    def remove_query_params_from_path
+      path.split("?").first
+    end
+
     private
+      def same_path?(req)
+        if @options && @options[:omit_query_in_path]
+          remove_query_params_from_path == req.remove_query_params_from_path
+        else
+          path == req.path
+        end
+      end
+
       def headers_match?(req)
         # Ignore format header on equality if it's not defined
         format_header = ActiveResource::Connection::HTTP_FORMAT_HEADER_NAMES[method]
@@ -360,11 +375,11 @@ module ActiveResource
         end
 
         def unstub_http?
-          HttpMock.net_connection_enabled? && defined?(@http) && @http.kind_of?(HttpMock)
+          HttpMock.net_connection_enabled? && (!defined?(@http) || @http.kind_of?(HttpMock))
         end
 
         def stub_http?
-          HttpMock.net_connection_disabled? && defined?(@http) && @http.kind_of?(Net::HTTP)
+          HttpMock.net_connection_disabled? && (!defined?(@http) || @http.kind_of?(Net::HTTP))
         end
       end
   end

data/lib/active_resource/inheriting_hash.rb

@@ -11,5 +11,24 @@ module ActiveResource
     def [](key)
       super || @parent_hash[key]
     end
+
+    # Merges the flattened parent hash (if it's an InheritingHash)
+    # with ourself
+    def to_hash
+      @parent_hash.to_hash.merge(self)
+    end
+
+    # So we can see the merged object in IRB or the Rails console
+    def pretty_print(pp)
+      pp.pp_hash to_hash
+    end
+
+    def inspect
+      to_hash.inspect
+    end
+
+    def to_s
+      inspect
+    end
   end
 end

data/lib/active_resource/log_subscriber.rb

@@ -14,7 +14,7 @@ module ActiveResource
       log_level_method = code.to_i < 400 ? :info : :error
 
       send log_level_method, "#{event.payload[:method].to_s.upcase} #{event.payload[:request_uri]}"
-      send log_level_method, "--> %d %s %d (%.1fms)" % [code, message, body.to_s.length, event.duration]
+      send log_level_method, "--> %d %s %d (%.1fms)" % [ code, message, body.to_s.length, event.duration ]
     end
 
     def logger

data/lib/active_resource/railtie.rb

@@ -5,6 +5,8 @@ require "rails"
 
 module ActiveResource
   class Railtie < Rails::Railtie
+    config.eager_load_namespaces << ActiveResource
+
     config.active_resource = ActiveSupport::OrderedOptions.new
 
     initializer "active_resource.set_configs" do |app|
@@ -21,5 +23,21 @@ module ActiveResource
         app.config.active_job.custom_serializers << ActiveResource::ActiveJobSerializer
       end
     end
+
+    initializer "active_resource.deprecator" do |app|
+      if app.respond_to?(:deprecators)
+        app.deprecators[:active_resource] = ActiveResource.deprecator
+      end
+    end
+
+    initializer "active_resource.logger" do
+      ActiveSupport.on_load(:active_resource) { self.logger ||= ::Rails.logger }
+    end
+
+    initializer "active_resource.http_mock" do
+      ActiveSupport.on_load(:active_support_test_case) do
+        teardown { ActiveResource::HttpMock.reset! }
+      end
+    end
   end
 end

data/lib/active_resource/rescuable.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module ActiveResource
+  # = Active Resource \Rescuable
+  #
+  # Provides
+  # {rescue_from}[rdoc-ref:ActiveSupport::Rescuable::ClassMethods#rescue_from]
+  # for resources. Wraps calls over the network to handle configured errors.
+  module Rescuable
+    extend ActiveSupport::Concern
+
+    included do
+      include ActiveSupport::Rescuable
+
+      around_save :handle_exceptions
+      around_destroy :handle_exceptions
+    end
+
+    private
+      def handle_exceptions
+        yield
+      rescue => exception
+        rescue_with_handler(exception) || raise
+      end
+  end
+end

data/lib/active_resource/schema.rb

@@ -4,7 +4,7 @@ module ActiveResource # :nodoc:
   class Schema # :nodoc:
     # attributes can be known to be one of these types. They are easy to
     # cast to/from.
-    KNOWN_ATTRIBUTE_TYPES = %w( string text integer float decimal datetime timestamp time date binary boolean )
+    KNOWN_ATTRIBUTE_TYPES = %w[ string text integer float decimal datetime timestamp time date binary boolean ]
 
     # An array of attribute definitions, representing the attributes that
     # have been defined.

data/lib/active_resource/serialization.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module ActiveResource
+  # Compatibilitiy with Active Record's
+  # {serialize}[link:https://api.rubyonrails.org/classes/ActiveRecord/AttributeMethods/Serialization/ClassMethods.html#method-i-serialize]
+  # method as the <tt>:coder</tt> option.
+  #
+  # === Writing to String columns
+  #
+  # Encodes Active Resource instances into a string to be stored in the
+  # database. Decodes strings read from the database into Active Resource
+  # instances.
+  #
+  #   class User < ActiveRecord::Base
+  #     serialize :person, coder: Person
+  #   end
+  #
+  #   class Person < ActiveResource::Base
+  #     schema do
+  #       attribute :name, :string
+  #     end
+  #   end
+  #
+  #   user = User.new
+  #   user.person = Person.new name: "Matz"
+  #
+  # Writing string values incorporates the Base.format:
+  #
+  #   Person.format = :json
+  #
+  #   user.person = Person.new name: "Matz"
+  #   user.person_before_type_cast # => "{\"name\":\"Matz\"}"
+  #
+  #   Person.format = :xml
+  #
+  #   user.person = Person.new name: "Matz"
+  #   user.person_before_type_cast # => "<?xml version=\"1.0\" encoding=\"UTF-8\"?><person><name>Matz</name></person>"
+  #
+  # Instances are loaded as persisted when decoded from data containing a
+  # primary key value, and new records when missing a primary key value:
+  #
+  #   user.person = Person.new
+  #   user.person.persisted? # => false
+  #
+  #   user.person = Person.find(1)
+  #   user.person.persisted? # => true
+  #
+  # === Writing to JSON and JSONB columns
+  #
+  #   class User < ActiveRecord::Base
+  #     serialize :person, coder: ActiveResource::Coder.new(Person, :serializable_hash)
+  #   end
+  #
+  #   class Person < ActiveResource::Base
+  #     schema do
+  #       attribute :name, :string
+  #     end
+  #   end
+  #
+  #   user = User.new
+  #   user.person = Person.new name: "Matz"
+  #   user.person.name # => "Matz"
+  #
+  #   user.person_before_type_cast # => {"name"=>"Matz"}
+  module Serialization
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :coder, instance_accessor: false, instance_predicate: false
+    end
+
+    module ClassMethods
+      delegate :dump, :load, to: :coder
+
+      def inherited(subclass) # :nodoc:
+        super
+        subclass.coder = Coder.new(subclass)
+      end
+    end
+  end
+end

data/lib/active_resource/validations.rb

@@ -15,7 +15,7 @@ module ActiveResource
     # or not (by passing true).
     def from_array(messages, save_cache = false)
       clear unless save_cache
-      humanized_attributes = Hash[@base.known_attributes.map { |attr_name| [attr_name.humanize, attr_name] }]
+      humanized_attributes = Hash[@base.known_attributes.map { |attr_name| [ attr_name.humanize, attr_name ] }]
       messages.each do |message|
         attr_message = humanized_attributes.keys.sort_by { |a| -a.length }.detect do |attr_name|
           if message[0, attr_name.size + 1] == "#{attr_name} "
@@ -57,7 +57,7 @@ module ActiveResource
         errors = decoded["errors"] || {}
         if errors.kind_of?(Array)
           # 3.2.1-style with array of strings
-          ActiveSupport::Deprecation.warn("Returning errors as an array of strings is deprecated.")
+          ActiveResource.deprecator.warn("Returning errors as an array of strings is deprecated.")
           from_array errors, save_cache
         else
           # 3.2.2+ style
@@ -65,7 +65,7 @@ module ActiveResource
         end
       else
         # <3.2-style respond_with - lacks 'errors' key
-        ActiveSupport::Deprecation.warn('Returning errors as a hash without a root "errors" key is deprecated.')
+        ActiveResource.deprecator.warn('Returning errors as a hash without a root "errors" key is deprecated.')
         from_hash decoded, save_cache
       end
     end
@@ -160,7 +160,7 @@ module ActiveResource
     #   my_person.valid?
     #   # => false
     #
-    def valid?
+    def valid?(context = nil)
       run_callbacks :validate do
         super
         load_remote_errors(@remote_errors, true) if defined?(@remote_errors) && @remote_errors.present?

data/lib/active_resource/version.rb

@@ -3,10 +3,10 @@
 module ActiveResource
   module VERSION # :nodoc:
     MAJOR = 6
-    MINOR = 0
+    MINOR = 2
     TINY  = 0
     PRE   = nil
 
-    STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
+    STRING = [ MAJOR, MINOR, TINY, PRE ].compact.join(".")
   end
 end

data/lib/active_resource/where_clause.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module ActiveResource
+  class WhereClause < BasicObject # :nodoc:
+    delegate_missing_to :resources
+
+    def initialize(resource_class, options = {})
+      @resource_class = resource_class
+      @options = options
+      @resources = nil
+      @loaded = false
+    end
+
+    def where(clauses = {})
+      all(params: clauses)
+    end
+
+    def all(options = {})
+      WhereClause.new(@resource_class, @options.deep_merge(options))
+    end
+
+    def load
+      unless @loaded
+        @resources = @resource_class.find(:all, @options)
+        @loaded = true
+      end
+
+      self
+    end
+
+    def reload
+      reset
+      load
+    end
+
+    private
+      def resources
+        load
+        @resources
+      end
+
+      def reset
+        @resources = nil
+        @loaded = false
+      end
+  end
+end

data/lib/active_resource.rb

@@ -23,6 +23,8 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #++
 
+require "uri"
+
 require "active_support"
 require "active_model"
 require "active_resource/exceptions"
@@ -31,17 +33,35 @@ require "active_resource/version"
 module ActiveResource
   extend ActiveSupport::Autoload
 
+  URI_PARSER = defined?(URI::RFC2396_PARSER) ? URI::RFC2396_PARSER : URI::RFC2396_Parser.new
+
   autoload :Base
   autoload :Callbacks
+  autoload :Coder
   autoload :Connection
   autoload :CustomMethods
   autoload :Formats
   autoload :HttpMock
+  autoload :Rescuable
   autoload :Schema
+  autoload :Serialization
   autoload :Singleton
   autoload :InheritingHash
   autoload :Validations
   autoload :Collection
+  eager_autoload do
+    autoload :WhereClause
+  end
+
+  if ActiveSupport::VERSION::STRING >= "7.1"
+    def self.deprecator
+      @deprecator ||= ActiveSupport::Deprecation.new(VERSION::STRING, "ActiveResource")
+    end
+  else
+    def self.deprecator
+      ActiveSupport::Deprecation
+    end
+  end
 end
 
 require "active_resource/railtie" if defined?(Rails.application)

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: activeresource
 version: !ruby/object:Gem::Version
-  version: 6.0.0
+  version: 6.2.0
 platform: ruby
 authors:
 - David Heinemeier Hansson
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-01-10 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -16,28 +15,28 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '7.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '7.0'
 - !ruby/object:Gem::Dependency
   name: activemodel
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '7.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '7.0'
 - !ruby/object:Gem::Dependency
   name: activemodel-serializers-xml
   requirement: !ruby/object:Gem::Requirement
@@ -112,6 +111,7 @@ files:
 - lib/active_resource/associations/builder/has_one.rb
 - lib/active_resource/base.rb
 - lib/active_resource/callbacks.rb
+- lib/active_resource/coder.rb
 - lib/active_resource/collection.rb
 - lib/active_resource/connection.rb
 - lib/active_resource/custom_methods.rb
@@ -124,22 +124,24 @@ files:
 - lib/active_resource/log_subscriber.rb
 - lib/active_resource/railtie.rb
 - lib/active_resource/reflection.rb
+- lib/active_resource/rescuable.rb
 - lib/active_resource/schema.rb
+- lib/active_resource/serialization.rb
 - lib/active_resource/singleton.rb
 - lib/active_resource/threadsafe_attributes.rb
 - lib/active_resource/validations.rb
 - lib/active_resource/version.rb
+- lib/active_resource/where_clause.rb
 - lib/activeresource.rb
 homepage: http://www.rubyonrails.org
 licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/rails/activeresource/issues
-  changelog_uri: https://github.com/rails/activeresource/releases/tag/v6.0.0
+  changelog_uri: https://github.com/rails/activeresource/releases/tag/v6.2.0
   documentation_uri: http://rubydoc.info/gems/activeresource
-  source_code_uri: https://github.com/rails/activeresource/tree/v6.0.0
+  source_code_uri: https://github.com/rails/activeresource/tree/v6.2.0
   rubygems_mfa_required: 'true'
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -147,15 +149,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.0
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.32
-signing_key: 
+rubygems_version: 3.6.7
 specification_version: 4
 summary: REST modeling framework (part of Rails).
 test_files: []