activeresource 3.2.22.5 → 5.1.1

data/lib/active_resource/callbacks.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/array/wrap"
+
+module ActiveResource
+  module Callbacks
+    extend ActiveSupport::Concern
+
+    CALLBACKS = [
+      :before_validation, :after_validation, :before_save, :around_save, :after_save,
+      :before_create, :around_create, :after_create, :before_update, :around_update,
+      :after_update, :before_destroy, :around_destroy, :after_destroy
+    ]
+
+    included do
+      extend ActiveModel::Callbacks
+      include ActiveModel::Validations::Callbacks
+
+      define_model_callbacks :save, :create, :update, :destroy
+    end
+  end
+end

data/lib/active_resource/collection.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/module/delegation"
+require "active_support/inflector"
+
+module ActiveResource # :nodoc:
+  class Collection # :nodoc:
+    SELF_DEFINE_METHODS = [:to_a, :collect!, :map!]
+    include Enumerable
+    delegate :to_yaml, :all?, *(Array.instance_methods(false) - SELF_DEFINE_METHODS), to: :to_a
+
+    # The array of actual elements returned by index actions
+    attr_accessor :elements, :resource_class, :original_params
+
+    # ActiveResource::Collection is a wrapper to handle parsing index responses that
+    # do not directly map to Rails conventions.
+    #
+    # You can define a custom class that inherets from ActiveResource::Collection
+    # in order to to set the elements instance.
+    #
+    # GET /posts.json delivers following response body:
+    #   {
+    #     posts: [
+    #       {
+    #         title: "ActiveResource now has associations",
+    #         body: "Lorem Ipsum"
+    #       },
+    #       {...}
+    #     ],
+    #     next_page: "/posts.json?page=2"
+    #   }
+    #
+    # A Post class can be setup to handle it with:
+    #
+    #   class Post < ActiveResource::Base
+    #     self.site = "http://example.com"
+    #     self.collection_parser = PostCollection
+    #   end
+    #
+    # And the collection parser:
+    #
+    #   class PostCollection < ActiveResource::Collection
+    #     attr_accessor :next_page
+    #     def initialize(parsed = {})
+    #       @elements = parsed['posts']
+    #       @next_page = parsed['next_page']
+    #     end
+    #   end
+    #
+    # The result from a find method that returns multiple entries will now be a
+    # PostParser instance.  ActiveResource::Collection includes Enumerable and
+    # instances can be iterated over just like an array.
+    #    @posts = Post.find(:all) # => PostCollection:xxx
+    #    @posts.next_page         # => "/posts.json?page=2"
+    #    @posts.map(&:id)         # =>[1, 3, 5 ...]
+    #
+    # The initialize method will receive the ActiveResource::Formats parsed result
+    # and should set @elements.
+    def initialize(elements = [])
+      @elements = elements
+    end
+
+    def to_a
+      elements
+    end
+
+    def collect!
+      return elements unless block_given?
+      set = []
+      each { |o| set << yield(o) }
+      @elements = set
+      self
+    end
+    alias map! collect!
+
+    def first_or_create(attributes = {})
+      first || resource_class.create(original_params.update(attributes))
+    rescue NoMethodError
+      raise "Cannot create resource from resource type: #{resource_class.inspect}"
+    end
+
+    def first_or_initialize(attributes = {})
+      first || resource_class.new(original_params.update(attributes))
+    rescue NoMethodError
+      raise "Cannot build resource from resource type: #{resource_class.inspect}"
+    end
+
+    def where(clauses = {})
+      raise ArgumentError, "expected a clauses Hash, got #{clauses.inspect}" unless clauses.is_a? Hash
+      new_clauses = original_params.merge(clauses)
+      resource_class.where(new_clauses)
+    end
+  end
+end

data/lib/active_resource/connection.rb

@@ -1,26 +1,28 @@
-require 'active_support/core_ext/benchmark'
-require 'active_support/core_ext/uri'
-require 'active_support/core_ext/object/inclusion'
-require 'net/https'
-require 'date'
-require 'time'
-require 'uri'
+# frozen_string_literal: true
+
+require "active_support/core_ext/benchmark"
+require "active_support/core_ext/uri"
+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.
   # This class is used by ActiveResource::Base to interface with REST
   # services.
   class Connection
-
-    HTTP_FORMAT_HEADER_NAMES = {  :get => 'Accept',
-      :put => 'Content-Type',
-      :post => 'Content-Type',
-      :delete => 'Accept',
-      :head => 'Accept'
+    HTTP_FORMAT_HEADER_NAMES = {  get: "Accept",
+      put: "Content-Type",
+      post: "Content-Type",
+      patch: "Content-Type",
+      delete: "Accept",
+      head: "Accept"
     }
 
-    attr_reader :site, :user, :password, :auth_type, :timeout, :proxy, :ssl_options
-    attr_accessor :format
+    attr_reader :site, :user, :password, :bearer_token, :auth_type, :timeout, :open_timeout, :read_timeout, :proxy, :ssl_options
+    attr_accessor :format, :logger
 
     class << self
       def requests
@@ -30,34 +32,35 @@ module ActiveResource
 
     # The +site+ parameter is required and will set the +site+
     # attribute to the URI for the remote resource service.
-    def initialize(site, format = ActiveResource::Formats::JsonFormat)
-      raise ArgumentError, 'Missing site URI' unless site
-      @user = @password = nil
+    def initialize(site, format = ActiveResource::Formats::JsonFormat, logger: nil)
+      raise ArgumentError, "Missing site URI" unless site
+      @proxy = @user = @password = @bearer_token = nil
       self.site = site
       self.format = format
+      self.logger = logger
     end
 
     # Set URI for remote service.
     def site=(site)
-      @site = site.is_a?(URI) ? site : URI.parser.parse(site)
+      @site = site.is_a?(URI) ? site : URI.parse(site)
+      @ssl_options ||= {} if @site.is_a?(URI::HTTPS)
       @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.
     def proxy=(proxy)
-      @proxy = proxy.is_a?(URI) ? proxy : URI.parser.parse(proxy)
+      @proxy = proxy.is_a?(URI) ? proxy : URI.parse(proxy)
     end
 
     # Sets the user for remote service.
-    def user=(user)
-      @user = user
-    end
+    attr_writer :user
 
     # Sets the password for remote service.
-    def password=(password)
-      @password = password
-    end
+    attr_writer :password
+
+    # Sets the bearer token for remote service.
+    attr_writer :bearer_token
 
     # Sets the auth type for remote service.
     def auth_type=(auth_type)
@@ -65,14 +68,16 @@ module ActiveResource
     end
 
     # Sets the number of seconds after which HTTP requests to the remote service should time out.
-    def timeout=(timeout)
-      @timeout = timeout
-    end
+    attr_writer :timeout
+
+    # Sets the number of seconds after which HTTP connects to the remote service should time out.
+    attr_writer :open_timeout
+
+    # Sets the number of seconds after which HTTP read requests to the remote service should time out.
+    attr_writer :read_timeout
 
     # Hash of options applied to Net::HTTP instance when +site+ protocol is 'https'.
-    def ssl_options=(opts={})
-      @ssl_options = opts
-    end
+    attr_writer :ssl_options
 
     # Executes a GET request.
     # Used to get (find) resources.
@@ -86,15 +91,21 @@ module ActiveResource
       with_auth { request(:delete, path, build_request_headers(headers, :delete, self.site.merge(path))) }
     end
 
+    # Executes a PATCH request (see HTTP protocol documentation if unfamiliar).
+    # Used to update resources.
+    def patch(path, body = "", headers = {})
+      with_auth { request(:patch, path, body.to_s, build_request_headers(headers, :patch, self.site.merge(path))) }
+    end
+
     # Executes a PUT request (see HTTP protocol documentation if unfamiliar).
     # Used to update resources.
-    def put(path, body = '', headers = {})
+    def put(path, body = "", headers = {})
       with_auth { request(:put, path, body.to_s, build_request_headers(headers, :put, self.site.merge(path))) }
     end
 
     # Executes a POST request.
     # Used to create new resources.
-    def post(path, body = '', headers = {})
+    def post(path, body = "", headers = {})
       with_auth { request(:post, path, body.to_s, build_request_headers(headers, :post, self.site.merge(path))) }
     end
 
@@ -122,32 +133,32 @@ module ActiveResource
       # Handles response and error codes from the remote service.
       def handle_response(response)
         case response.code.to_i
-          when 301, 302, 303, 307
-            raise(Redirection.new(response))
-          when 200...400
-            response
-          when 400
-            raise(BadRequest.new(response))
-          when 401
-            raise(UnauthorizedAccess.new(response))
-          when 403
-            raise(ForbiddenAccess.new(response))
-          when 404
-            raise(ResourceNotFound.new(response))
-          when 405
-            raise(MethodNotAllowed.new(response))
-          when 409
-            raise(ResourceConflict.new(response))
-          when 410
-            raise(ResourceGone.new(response))
-          when 422
-            raise(ResourceInvalid.new(response))
-          when 401...500
-            raise(ClientError.new(response))
-          when 500...600
-            raise(ServerError.new(response))
-          else
-            raise(ConnectionError.new(response, "Unknown response code: #{response.code}"))
+        when 301, 302, 303, 307
+          raise(Redirection.new(response))
+        when 200...400
+          response
+        when 400
+          raise(BadRequest.new(response))
+        when 401
+          raise(UnauthorizedAccess.new(response))
+        when 403
+          raise(ForbiddenAccess.new(response))
+        when 404
+          raise(ResourceNotFound.new(response))
+        when 405
+          raise(MethodNotAllowed.new(response))
+        when 409
+          raise(ResourceConflict.new(response))
+        when 410
+          raise(ResourceGone.new(response))
+        when 422
+          raise(ResourceInvalid.new(response))
+        when 401...500
+          raise(ClientError.new(response))
+        when 500...600
+          raise(ServerError.new(response))
+        else
+          raise(ConnectionError.new(response, "Unknown response code: #{response.code}"))
         end
       end
 
@@ -159,45 +170,36 @@ module ActiveResource
 
       def new_http
         if @proxy
-          Net::HTTP.new(@site.host, @site.port, @proxy.host, @proxy.port, @proxy.user, @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)
         end
       end
 
       def configure_http(http)
-        http = apply_ssl_options(http)
-
-        # Net::HTTP timeouts default to 60 seconds.
-        if @timeout
-          http.open_timeout = @timeout
-          http.read_timeout = @timeout
+        apply_ssl_options(http).tap do |https|
+          # Net::HTTP timeouts default to 60 seconds.
+          if defined? @timeout
+            https.open_timeout = @timeout
+            https.read_timeout = @timeout
+          end
+          https.open_timeout = @open_timeout if defined?(@open_timeout)
+          https.read_timeout = @read_timeout if defined?(@read_timeout)
         end
-
-        http
       end
 
       def apply_ssl_options(http)
-        return http unless @site.is_a?(URI::HTTPS)
-
-        http.use_ssl     = true
-        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-        return http unless defined?(@ssl_options)
+        http.tap do |https|
+          # Skip config if site is already a https:// URI.
+          if defined? @ssl_options
+            http.use_ssl = true
 
-        http.ca_path     = @ssl_options[:ca_path] if @ssl_options[:ca_path]
-        http.ca_file     = @ssl_options[:ca_file] if @ssl_options[:ca_file]
-
-        http.cert        = @ssl_options[:cert] if @ssl_options[:cert]
-        http.key         = @ssl_options[:key]  if @ssl_options[:key]
-
-        http.cert_store  = @ssl_options[:cert_store]  if @ssl_options[:cert_store]
-        http.ssl_timeout = @ssl_options[:ssl_timeout] if @ssl_options[:ssl_timeout]
-
-        http.verify_mode     = @ssl_options[:verify_mode]     if @ssl_options[:verify_mode]
-        http.verify_callback = @ssl_options[:verify_callback] if @ssl_options[:verify_callback]
-        http.verify_depth    = @ssl_options[:verify_depth]    if @ssl_options[:verify_depth]
-
-        http
+            # All the SSL options have corresponding http settings.
+            @ssl_options.each { |key, value| http.send "#{key}=", value }
+          end
+        end
       end
 
       def default_header
@@ -218,7 +220,7 @@ module ActiveResource
         yield
       rescue UnauthorizedAccess => e
         raise if retried || auth_type != :digest
-        @response_auth_header = e.response['WWW-Authenticate']
+        @response_auth_header = e.response["WWW-Authenticate"]
         retried = true
         retry
       end
@@ -226,10 +228,12 @@ module ActiveResource
       def authorization_header(http_method, uri)
         if @user || @password
           if auth_type == :digest
-            { 'Authorization' => digest_auth_header(http_method, uri) }
+            { "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}" }
         else
           {}
         end
@@ -244,8 +248,8 @@ module ActiveResource
         ha1 = Digest::MD5.hexdigest("#{@user}:#{params['realm']}:#{@password}")
         ha2 = Digest::MD5.hexdigest("#{http_method.to_s.upcase}:#{request_uri}")
 
-        params.merge!('cnonce' => client_nonce)
-        request_digest = Digest::MD5.hexdigest([ha1, params['nonce'], "0", params['cnonce'], params['qop'], ha2].join(":"))
+        params["cnonce"] = client_nonce
+        request_digest = Digest::MD5.hexdigest([ha1, params["nonce"], "0", params["cnonce"], params["qop"], ha2].join(":"))
         "Digest #{auth_attributes_for(uri, request_digest, params)}"
       end
 
@@ -262,26 +266,29 @@ module ActiveResource
       end
 
       def auth_attributes_for(uri, request_digest, params)
-        [
-          %Q(username="#{@user}"),
-          %Q(realm="#{params['realm']}"),
-          %Q(qop="#{params['qop']}"),
-          %Q(uri="#{uri.path}"),
-          %Q(nonce="#{params['nonce']}"),
-          %Q(nc="0"),
-          %Q(cnonce="#{params['cnonce']}"),
-          %Q(opaque="#{params['opaque']}"),
-          %Q(response="#{request_digest}")].join(", ")
+        auth_attrs =
+          [
+            %Q(username="#{@user}"),
+            %Q(realm="#{params['realm']}"),
+            %Q(qop="#{params['qop']}"),
+            %Q(uri="#{uri.path}"),
+            %Q(nonce="#{params['nonce']}"),
+            'nc="0"',
+            %Q(cnonce="#{params['cnonce']}"),
+            %Q(response="#{request_digest}")]
+
+        auth_attrs << %Q(opaque="#{params['opaque']}") unless params["opaque"].blank?
+        auth_attrs.join(", ")
       end
 
       def http_format_header(http_method)
-        {HTTP_FORMAT_HEADER_NAMES[http_method] => format.mime_type}
+        { HTTP_FORMAT_HEADER_NAMES[http_method] => format.mime_type }
       end
 
       def legitimize_auth_type(auth_type)
         return :basic if auth_type.nil?
         auth_type = auth_type.to_sym
-        auth_type.in?([:basic, :digest]) ? auth_type : :basic
+        auth_type.in?([:basic, :digest, :bearer]) ? auth_type : :basic
       end
   end
 end