activeresource 3.2.22.5 → 5.1.1

data/lib/active_resource/reflection.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/class/attribute"
+require "active_support/core_ext/module/deprecation"
+
+module ActiveResource
+  # = Active Resource reflection
+  #
+  # Associations in ActiveResource would be used to resolve nested attributes
+  # in a response with correct classes.
+  # Now they could be specified over Associations with the options :class_name
+  module Reflection # :nodoc:
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :reflections
+      self.reflections = {}
+    end
+
+    module ClassMethods
+      def create_reflection(macro, name, options)
+        reflection = AssociationReflection.new(macro, name, options)
+        self.reflections = self.reflections.merge(name => reflection)
+        reflection
+      end
+    end
+
+
+    class AssociationReflection
+      def initialize(macro, name, options)
+        @macro, @name, @options = macro, name, options
+      end
+
+      # Returns the name of the macro.
+      #
+      # <tt>has_many :clients</tt> returns <tt>:clients</tt>
+      attr_reader :name
+
+      # Returns the macro type.
+      #
+      # <tt>has_many :clients</tt> returns <tt>:has_many</tt>
+      attr_reader :macro
+
+      # Returns the hash of options used for the macro.
+      #
+      # <tt>has_many :clients</tt> returns +{}+
+      attr_reader :options
+
+      # Returns the class for the macro.
+      #
+      # <tt>has_many :clients</tt> returns the Client class
+      def klass
+        @klass ||= class_name.constantize
+      end
+
+      # Returns the class name for the macro.
+      #
+      # <tt>has_many :clients</tt> returns <tt>'Client'</tt>
+      def class_name
+        @class_name ||= derive_class_name
+      end
+
+      # Returns the foreign_key for the macro.
+      def foreign_key
+        @foreign_key ||= self.options[:foreign_key] || "#{self.name.to_s.downcase}_id"
+      end
+
+      private
+        def derive_class_name
+          (options[:class_name] ? options[:class_name].to_s.camelize : name.to_s.classify)
+        end
+
+        def derive_foreign_key
+          options[:foreign_key] ? options[:foreign_key].to_s : "#{name.to_s.downcase}_id"
+        end
+    end
+  end
+end

data/lib/active_resource/schema.rb

@@ -1,4 +1,4 @@
-require 'active_resource/exceptions'
+# frozen_string_literal: true
 
 module ActiveResource # :nodoc:
   class Schema # :nodoc:
@@ -31,8 +31,8 @@ module ActiveResource # :nodoc:
 
       the_type = type.to_s
       # TODO: add defaults
-      #the_attr = [type.to_s]
-      #the_attr << options[:default] if options.has_key? :default
+      # the_attr = [type.to_s]
+      # the_attr << options[:default] if options.has_key? :default
       @attrs[name.to_s] = the_type
       self
     end
@@ -47,7 +47,7 @@ module ActiveResource # :nodoc:
       #   attr_names.each { |name| attribute(name, 'string', options) }
       # end
       class_eval <<-EOV, __FILE__, __LINE__ + 1
-        def #{attr_type.to_s}(*args)
+        def #{attr_type}(*args)
           options = args.extract_options!
           attr_names = args
 

data/lib/active_resource/singleton.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module ActiveResource
+  module Singleton
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      attr_writer :singleton_name
+
+      def singleton_name
+        @singleton_name ||= model_name.element
+      end
+
+      # Gets the singleton path for the object.  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
+      #   Weather.singleton_path
+      #   # => /weather.json
+      #
+      #   class Inventory < ActiveResource::Base
+      #     self.site =   "https://37s.sunrise.com"
+      #     self.prefix = "/products/:product_id/"
+      #   end
+      #
+      #   Inventory.singleton_path(:product_id => 5)
+      #   # => /products/5/inventory.json
+      #
+      #   Inventory.singleton_path({:product_id => 5}, {:sold => true})
+      #   # => /products/5/inventory.json?sold=true
+      #
+      def singleton_path(prefix_options = {}, query_options = nil)
+        check_prefix_options(prefix_options)
+
+        prefix_options, query_options = split_options(prefix_options) if query_options.nil?
+        "#{prefix(prefix_options)}#{singleton_name}#{format_extension}#{query_string(query_options)}"
+      end
+
+      # Core method for finding singleton resources.
+      #
+      # ==== Arguments
+      # Takes a single argument of options
+      #
+      # ==== Options
+      # * <tt>:params</tt> - Sets the query and \prefix (nested URL) parameters.
+      #
+      # ==== Examples
+      #   Weather.find
+      #   # => GET /weather.json
+      #
+      #   Weather.find(:params => {:degrees => 'fahrenheit'})
+      #   # => GET /weather.json?degrees=fahrenheit
+      #
+      # == Failure or missing data
+      # A failure to find the requested object raises a ResourceNotFound exception.
+      #
+      #   Inventory.find
+      #   # => raises ResourceNotFound
+      def find(options = {})
+        find_singleton(options)
+      end
+
+      private
+        # Find singleton resource
+        def find_singleton(options)
+          prefix_options, query_options = split_options(options[:params])
+
+          path = singleton_path(prefix_options, query_options)
+          resp = self.format.decode(self.connection.get(path, self.headers).body)
+          instantiate_record(resp, prefix_options)
+        end
+    end
+    # Deletes the resource from the remote service.
+    #
+    # ==== Examples
+    #   weather = Weather.find
+    #   weather.destroy
+    #   Weather.find # 404 (Resource Not Found)
+    def destroy
+      connection.delete(singleton_path, self.class.headers)
+    end
+
+
+    protected
+
+      # Update the resource on the remote service
+      def update
+        connection.put(singleton_path(prefix_options), encode, self.class.headers).tap do |response|
+          load_attributes_from_response(response)
+        end
+      end
+
+      # Create (i.e. \save to the remote service) the \new resource.
+      def create
+        connection.post(singleton_path, encode, self.class.headers).tap do |response|
+          self.id = id_from_response(response)
+          load_attributes_from_response(response)
+        end
+      end
+
+    private
+
+      def singleton_path(options = nil)
+        self.class.singleton_path(options || prefix_options)
+      end
+  end
+end

data/lib/active_resource/threadsafe_attributes.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/duplicable"
+
+module ThreadsafeAttributes
+  def self.included(klass)
+    klass.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    def threadsafe_attribute(*attrs)
+      main_thread = Thread.main # remember this, because it could change after forking
+
+      attrs.each do |attr|
+        define_method attr do
+          get_threadsafe_attribute(attr, main_thread)
+        end
+
+        define_method "#{attr}=" do |value|
+          set_threadsafe_attribute(attr, value, main_thread)
+        end
+
+        define_method "#{attr}_defined?" do
+          threadsafe_attribute_defined?(attr, main_thread)
+        end
+      end
+    end
+  end
+
+  private
+
+    def get_threadsafe_attribute(name, main_thread)
+      if threadsafe_attribute_defined_by_thread?(name, Thread.current)
+        get_threadsafe_attribute_by_thread(name, Thread.current)
+      elsif threadsafe_attribute_defined_by_thread?(name, main_thread)
+        value = get_threadsafe_attribute_by_thread(name, main_thread)
+        value = value.dup if value.duplicable?
+        set_threadsafe_attribute_by_thread(name, value, Thread.current)
+        value
+      end
+    end
+
+    def set_threadsafe_attribute(name, value, main_thread)
+      set_threadsafe_attribute_by_thread(name, value, Thread.current)
+      unless threadsafe_attribute_defined_by_thread?(name, main_thread)
+        set_threadsafe_attribute_by_thread(name, value, main_thread)
+      end
+    end
+
+    def threadsafe_attribute_defined?(name, main_thread)
+      threadsafe_attribute_defined_by_thread?(name, Thread.current) || ((Thread.current != main_thread) && threadsafe_attribute_defined_by_thread?(name, main_thread))
+    end
+
+    def get_threadsafe_attribute_by_thread(name, thread)
+      thread.thread_variable_get "active.resource.#{name}.#{self.object_id}"
+    end
+
+    def set_threadsafe_attribute_by_thread(name, value, thread)
+      thread.thread_variable_set "active.resource.#{name}.#{self.object_id}.defined", true
+      thread.thread_variable_set "active.resource.#{name}.#{self.object_id}", value
+    end
+
+    def threadsafe_attribute_defined_by_thread?(name, thread)
+      thread.thread_variable_get "active.resource.#{name}.#{self.object_id}.defined"
+    end
+end

data/lib/active_resource/validations.rb

@@ -1,5 +1,7 @@
-require 'active_support/core_ext/array/wrap'
-require 'active_support/core_ext/object/blank'
+# frozen_string_literal: true
+
+require "active_support/core_ext/array/wrap"
+require "active_support/core_ext/object/blank"
 
 module ActiveResource
   class ResourceInvalid < ClientError  #:nodoc:
@@ -13,27 +15,64 @@ module ActiveResource
     # or not (by passing true).
     def from_array(messages, save_cache = false)
       clear unless save_cache
-      humanized_attributes = Hash[@base.attributes.keys.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.detect do |attr_name|
+        attr_message = humanized_attributes.keys.sort_by { |a| -a.length }.detect do |attr_name|
           if message[0, attr_name.size + 1] == "#{attr_name} "
             add humanized_attributes[attr_name], message[(attr_name.size + 1)..-1]
           end
         end
-
         self[:base] << message if attr_message.nil?
       end
     end
 
+    # Grabs errors from a hash of attribute => array of errors elements
+    # The second parameter directs the errors cache to be cleared (default)
+    # or not (by passing true)
+    #
+    # Unrecognized attribute names will be humanized and added to the record's
+    # base errors.
+    def from_hash(messages, save_cache = false)
+      clear unless save_cache
+
+      messages.each do |(key, errors)|
+        errors.each do |error|
+          if @base.known_attributes.include?(key)
+            add key, error
+          elsif key == "base"
+            self[:base] << error
+          else
+            # reporting an error on an attribute not in attributes
+            # format and add them to base
+            self[:base] << "#{key.humanize} #{error}"
+          end
+        end
+      end
+    end
+
     # Grabs errors from a json response.
     def from_json(json, save_cache = false)
-      array = Array.wrap(ActiveSupport::JSON.decode(json)['errors']) rescue []
-      from_array array, save_cache
+      decoded = ActiveSupport::JSON.decode(json) || {} rescue {}
+      if decoded.kind_of?(Hash) && (decoded.has_key?("errors") || decoded.empty?)
+        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.")
+          from_array errors, save_cache
+        else
+          # 3.2.2+ style
+          from_hash errors, save_cache
+        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.')
+        from_hash decoded, save_cache
+      end
     end
 
     # Grabs errors from an XML response.
     def from_xml(xml, save_cache = false)
-      array = Array.wrap(Hash.from_xml(xml)['errors']['error']) rescue []
+      array = Array.wrap(Hash.from_xml(xml)["errors"]["error"]) rescue []
       from_array array, save_cache
     end
   end
@@ -63,12 +102,13 @@ module ActiveResource
     include ActiveModel::Validations
 
     included do
-      alias_method_chain :save, :validation
+      alias_method :save_without_validation, :save
+      alias_method :save, :save_with_validation
     end
 
     # Validate a resource and save (POST) it to the remote web service.
     # If any local validations fail - the save (POST) will not be attempted.
-    def save_with_validation(options={})
+    def save_with_validation(options = {})
       perform_validation = options[:validate] != false
 
       # clear the remote validations so they don't interfere with the local
@@ -93,7 +133,7 @@ module ActiveResource
 
     # Loads the set of remote errors into the object's Errors based on the
     # content-type of the error-block received.
-    def load_remote_errors(remote_errors, save_cache = false ) #:nodoc:
+    def load_remote_errors(remote_errors, save_cache = false) #:nodoc:
       case self.class.format
       when ActiveResource::Formats[:xml]
         errors.from_xml(remote_errors.response.body, save_cache)
@@ -121,9 +161,11 @@ module ActiveResource
     #   # => false
     #
     def valid?
-      super
-      load_remote_errors(@remote_errors, true) if defined?(@remote_errors) && @remote_errors.present?
-      errors.empty?
+      run_callbacks :validate do
+        super
+        load_remote_errors(@remote_errors, true) if defined?(@remote_errors) && @remote_errors.present?
+        errors.empty?
+      end
     end
 
     # Returns the Errors object that holds all information about attribute error messages.

data/lib/active_resource/version.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 module ActiveResource
   module VERSION #:nodoc:
-    MAJOR = 3
-    MINOR = 2
-    TINY  = 22
-    PRE   = "5"
+    MAJOR = 5
+    MINOR = 1
+    TINY  = 1
+    PRE   = nil
 
-    STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.')
+    STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end
 end

data/lib/activeresource.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "active_resource"

metadata

@@ -1,43 +1,97 @@
 --- !ruby/object:Gem::Specification
 name: activeresource
 version: !ruby/object:Gem::Version
-  version: 3.2.22.5
+  version: 5.1.1
 platform: ruby
 authors:
 - David Heinemeier Hansson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-14 00:00:00.000000000 Z
+date: 2020-05-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 3.2.22.5
+        version: '5.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 3.2.22.5
+        version: '7'
 - !ruby/object:Gem::Dependency
   name: activemodel
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 3.2.22.5
+        version: '5.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
+- !ruby/object:Gem::Dependency
+  name: activemodel-serializers-xml
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.13.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 3.2.22.5
+        version: 0.13.0
 description: REST on Rails. Wrap your RESTful web app with Ruby classes and work with
   them like Active Record models.
 email: david@loudthinking.com
@@ -46,12 +100,18 @@ extensions: []
 extra_rdoc_files:
 - README.rdoc
 files:
-- CHANGELOG.md
 - MIT-LICENSE
 - README.rdoc
-- examples/performance.rb
 - lib/active_resource.rb
+- lib/active_resource/active_job_serializer.rb
+- lib/active_resource/associations.rb
+- lib/active_resource/associations/builder/association.rb
+- lib/active_resource/associations/builder/belongs_to.rb
+- lib/active_resource/associations/builder/has_many.rb
+- lib/active_resource/associations/builder/has_one.rb
 - lib/active_resource/base.rb
+- lib/active_resource/callbacks.rb
+- lib/active_resource/collection.rb
 - lib/active_resource/connection.rb
 - lib/active_resource/custom_methods.rb
 - lib/active_resource/exceptions.rb
@@ -62,9 +122,13 @@ files:
 - lib/active_resource/log_subscriber.rb
 - lib/active_resource/observing.rb
 - lib/active_resource/railtie.rb
+- lib/active_resource/reflection.rb
 - lib/active_resource/schema.rb
+- lib/active_resource/singleton.rb
+- lib/active_resource/threadsafe_attributes.rb
 - lib/active_resource/validations.rb
 - lib/active_resource/version.rb
+- lib/activeresource.rb
 homepage: http://www.rubyonrails.org
 licenses:
 - MIT
@@ -79,17 +143,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.8.7
+      version: 2.2.2
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.6
+rubygems_version: 3.2.0.pre1
 signing_key: 
 specification_version: 4
 summary: REST modeling framework (part of Rails).
 test_files: []
-has_rdoc: