ric 0.12.0 → 0.12.2

data/vendor/bundle/ruby/2.5.0/gems/activeresource-5.1.0/lib/active_resource/log_subscriber.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module ActiveResource
+  class LogSubscriber < ActiveSupport::LogSubscriber
+    def request(event)
+      result = event.payload[:result]
+
+      # When result is nil, the connection could not even be initiated
+      # with the server, so we log an internal synthetic error response (523).
+      code    = result.try(:code)    || 523  # matches CloudFlare's convention
+      message = result.try(:message) || "ActiveResource connection error"
+      body    = result.try(:body)    || ""
+
+      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]
+    end
+
+    def logger
+      ActiveResource::Base.logger
+    end
+  end
+end
+
+ActiveResource::LogSubscriber.attach_to :active_resource

data/vendor/bundle/ruby/2.5.0/gems/activeresource-5.1.0/lib/active_resource/railtie.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "active_resource"
+require "rails"
+
+module ActiveResource
+  class Railtie < Rails::Railtie
+    config.active_resource = ActiveSupport::OrderedOptions.new
+
+    initializer "active_resource.set_configs" do |app|
+      ActiveSupport.on_load(:active_resource) do
+        app.config.active_resource.each do |k, v|
+          send "#{k}=", v
+        end
+      end
+    end
+
+    initializer "active_resource.add_active_job_serializer" do |app|
+      if defined? app.config.active_job.custom_serializers
+        require "active_resource/active_job_serializer"
+        app.config.active_job.custom_serializers << ActiveResource::ActiveJobSerializer
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/activeresource-5.1.0/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/vendor/bundle/ruby/2.5.0/gems/activeresource-5.1.0/lib/active_resource/schema.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+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 )
+
+    # An array of attribute definitions, representing the attributes that
+    # have been defined.
+    attr_accessor :attrs
+
+    # The internals of an Active Resource Schema are very simple -
+    # unlike an Active Record TableDefinition (on which it is based).
+    # It provides a set of convenience methods for people to define their
+    # schema using the syntax:
+    #  schema do
+    #    string :foo
+    #    integer :bar
+    #  end
+    #
+    #  The schema stores the name and type of each attribute. That is then
+    #  read out by the schema method to populate the schema of the actual
+    #  resource.
+    def initialize
+      @attrs = {}
+    end
+
+    def attribute(name, type, options = {})
+      raise ArgumentError, "Unknown Attribute type: #{type.inspect} for key: #{name.inspect}" unless type.nil? || Schema::KNOWN_ATTRIBUTE_TYPES.include?(type.to_s)
+
+      the_type = type.to_s
+      # TODO: add defaults
+      # the_attr = [type.to_s]
+      # the_attr << options[:default] if options.has_key? :default
+      @attrs[name.to_s] = the_type
+      self
+    end
+
+    # The following are the attribute types supported by Active Resource
+    # migrations.
+    KNOWN_ATTRIBUTE_TYPES.each do |attr_type|
+      # def string(*args)
+      #   options = args.extract_options!
+      #   attr_names = args
+      #
+      #   attr_names.each { |name| attribute(name, 'string', options) }
+      # end
+      class_eval <<-EOV, __FILE__, __LINE__ + 1
+        def #{attr_type}(*args)
+          options = args.extract_options!
+          attr_names = args
+
+          attr_names.each { |name| attribute(name, '#{attr_type}', options) }
+        end
+      EOV
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/activeresource-5.1.0/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/vendor/bundle/ruby/2.5.0/gems/activeresource-5.1.0/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/vendor/bundle/ruby/2.5.0/gems/activeresource-5.1.0/lib/active_resource/validations.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/array/wrap"
+require "active_support/core_ext/object/blank"
+
+module ActiveResource
+  class ResourceInvalid < ClientError  #:nodoc:
+  end
+
+  # Active Resource validation is reported to and from this object, which is used by Base#save
+  # to determine whether the object in a valid state to be saved. See usage example in Validations.
+  class Errors < ActiveModel::Errors
+    # Grabs errors from an array of messages (like ActiveRecord::Validations).
+    # The second parameter directs the errors cache to be cleared (default)
+    # 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] }]
+      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} "
+            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)
+      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 []
+      from_array array, save_cache
+    end
+  end
+
+  # Module to support validation and errors with Active Resource objects. The module overrides
+  # Base#save to rescue ActiveResource::ResourceInvalid exceptions and parse the errors returned
+  # in the web service response. The module also adds an +errors+ collection that mimics the interface
+  # of the errors provided by ActiveModel::Errors.
+  #
+  # ==== Example
+  #
+  # Consider a Person resource on the server requiring both a +first_name+ and a +last_name+ with a
+  # <tt>validates_presence_of :first_name, :last_name</tt> declaration in the model:
+  #
+  #   person = Person.new(:first_name => "Jim", :last_name => "")
+  #   person.save                   # => false (server returns an HTTP 422 status code and errors)
+  #   person.valid?                 # => false
+  #   person.errors.empty?          # => false
+  #   person.errors.count           # => 1
+  #   person.errors.full_messages   # => ["Last name can't be empty"]
+  #   person.errors[:last_name]  # => ["can't be empty"]
+  #   person.last_name = "Halpert"
+  #   person.save                   # => true (and person is now saved to the remote service)
+  #
+  module Validations
+    extend  ActiveSupport::Concern
+    include ActiveModel::Validations
+
+    included do
+      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 = {})
+      perform_validation = options[:validate] != false
+
+      # clear the remote validations so they don't interfere with the local
+      # ones. Otherwise we get an endless loop and can never change the
+      # fields so as to make the resource valid.
+      @remote_errors = nil
+      if perform_validation && valid? || !perform_validation
+        save_without_validation
+        true
+      else
+        false
+      end
+    rescue ResourceInvalid => error
+      # cache the remote errors because every call to <tt>valid?</tt> clears
+      # all errors. We must keep a copy to add these back after local
+      # validations.
+      @remote_errors = error
+      load_remote_errors(@remote_errors, true)
+      false
+    end
+
+
+    # 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:
+      case self.class.format
+      when ActiveResource::Formats[:xml]
+        errors.from_xml(remote_errors.response.body, save_cache)
+      when ActiveResource::Formats[:json]
+        errors.from_json(remote_errors.response.body, save_cache)
+      end
+    end
+
+    # Checks for errors on an object (i.e., is resource.errors empty?).
+    #
+    # Runs all the specified local validations and returns true if no errors
+    # were added, otherwise false.
+    # Runs local validations (eg those on your Active Resource model), and
+    # also any errors returned from the remote system the last time we
+    # saved.
+    # Remote errors can only be cleared by trying to re-save the resource.
+    #
+    # ==== Examples
+    #   my_person = Person.create(params[:person])
+    #   my_person.valid?
+    #   # => true
+    #
+    #   my_person.errors.add('login', 'can not be empty') if my_person.login == ''
+    #   my_person.valid?
+    #   # => false
+    #
+    def valid?
+      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.
+    def errors
+      @errors ||= Errors.new(self)
+    end
+  end
+end