ric 0.11.19 → 0.14.0

data/vendor/bundle/ruby/2.7.0/gems/activemodel-serializers-xml-1.0.2/lib/active_record/serializers/xml_serializer.rb

@@ -0,0 +1,194 @@
+require 'active_support/core_ext/hash/conversions'
+require 'active_model/serializers/xml'
+
+module ActiveRecord #:nodoc:
+  module Serialization
+    include ActiveModel::Serializers::Xml
+
+    # Builds an XML document to represent the model. Some configuration is
+    # available through +options+. However more complicated cases should
+    # override ActiveRecord::Base#to_xml.
+    #
+    # By default the generated XML document will include the processing
+    # instruction and all the object's attributes. For example:
+    #
+    #   <?xml version="1.0" encoding="UTF-8"?>
+    #   <topic>
+    #     <title>The First Topic</title>
+    #     <author-name>David</author-name>
+    #     <id type="integer">1</id>
+    #     <approved type="boolean">false</approved>
+    #     <replies-count type="integer">0</replies-count>
+    #     <bonus-time type="dateTime">2000-01-01T08:28:00+12:00</bonus-time>
+    #     <written-on type="dateTime">2003-07-16T09:28:00+1200</written-on>
+    #     <content>Have a nice day</content>
+    #     <author-email-address>david@loudthinking.com</author-email-address>
+    #     <parent-id></parent-id>
+    #     <last-read type="date">2004-04-15</last-read>
+    #   </topic>
+    #
+    # This behavior can be controlled with <tt>:only</tt>, <tt>:except</tt>,
+    # <tt>:skip_instruct</tt>, <tt>:skip_types</tt>, <tt>:dasherize</tt> and <tt>:camelize</tt> .
+    # The <tt>:only</tt> and <tt>:except</tt> options are the same as for the
+    # +attributes+ method. The default is to dasherize all column names, but you
+    # can disable this setting <tt>:dasherize</tt> to +false+. Setting <tt>:camelize</tt>
+    # to +true+ will camelize all column names - this also overrides <tt>:dasherize</tt>.
+    # To not have the column type included in the XML output set <tt>:skip_types</tt> to +true+.
+    #
+    # For instance:
+    #
+    #   topic.to_xml(skip_instruct: true, except: [ :id, :bonus_time, :written_on, :replies_count ])
+    #
+    #   <topic>
+    #     <title>The First Topic</title>
+    #     <author-name>David</author-name>
+    #     <approved type="boolean">false</approved>
+    #     <content>Have a nice day</content>
+    #     <author-email-address>david@loudthinking.com</author-email-address>
+    #     <parent-id></parent-id>
+    #     <last-read type="date">2004-04-15</last-read>
+    #   </topic>
+    #
+    # To include first level associations use <tt>:include</tt>:
+    #
+    #   firm.to_xml include: [ :account, :clients ]
+    #
+    #   <?xml version="1.0" encoding="UTF-8"?>
+    #   <firm>
+    #     <id type="integer">1</id>
+    #     <rating type="integer">1</rating>
+    #     <name>37signals</name>
+    #     <clients type="array">
+    #       <client>
+    #         <rating type="integer">1</rating>
+    #         <name>Summit</name>
+    #       </client>
+    #       <client>
+    #         <rating type="integer">1</rating>
+    #         <name>Microsoft</name>
+    #       </client>
+    #     </clients>
+    #     <account>
+    #       <id type="integer">1</id>
+    #       <credit-limit type="integer">50</credit-limit>
+    #     </account>
+    #   </firm>
+    #
+    # Additionally, the record being serialized will be passed to a Proc's second
+    # parameter. This allows for ad hoc additions to the resultant document that
+    # incorporate the context of the record being serialized. And by leveraging the
+    # closure created by a Proc, to_xml can be used to add elements that normally fall
+    # outside of the scope of the model -- for example, generating and appending URLs
+    # associated with models.
+    #
+    #   proc = Proc.new { |options, record| options[:builder].tag!('name-reverse', record.name.reverse) }
+    #   firm.to_xml procs: [ proc ]
+    #
+    #   <firm>
+    #     # ... normal attributes as shown above ...
+    #     <name-reverse>slangis73</name-reverse>
+    #   </firm>
+    #
+    # To include deeper levels of associations pass a hash like this:
+    #
+    #   firm.to_xml include: {account: {}, clients: {include: :address}}
+    #   <?xml version="1.0" encoding="UTF-8"?>
+    #   <firm>
+    #     <id type="integer">1</id>
+    #     <rating type="integer">1</rating>
+    #     <name>37signals</name>
+    #     <clients type="array">
+    #       <client>
+    #         <rating type="integer">1</rating>
+    #         <name>Summit</name>
+    #         <address>
+    #           ...
+    #         </address>
+    #       </client>
+    #       <client>
+    #         <rating type="integer">1</rating>
+    #         <name>Microsoft</name>
+    #         <address>
+    #           ...
+    #         </address>
+    #       </client>
+    #     </clients>
+    #     <account>
+    #       <id type="integer">1</id>
+    #       <credit-limit type="integer">50</credit-limit>
+    #     </account>
+    #   </firm>
+    #
+    # To include any methods on the model being called use <tt>:methods</tt>:
+    #
+    #   firm.to_xml methods: [ :calculated_earnings, :real_earnings ]
+    #
+    #   <firm>
+    #     # ... normal attributes as shown above ...
+    #     <calculated-earnings>100000000000000000</calculated-earnings>
+    #     <real-earnings>5</real-earnings>
+    #   </firm>
+    #
+    # To call any additional Procs use <tt>:procs</tt>. The Procs are passed a
+    # modified version of the options hash that was given to +to_xml+:
+    #
+    #   proc = Proc.new { |options| options[:builder].tag!('abc', 'def') }
+    #   firm.to_xml procs: [ proc ]
+    #
+    #   <firm>
+    #     # ... normal attributes as shown above ...
+    #     <abc>def</abc>
+    #   </firm>
+    #
+    # Alternatively, you can yield the builder object as part of the +to_xml+ call:
+    #
+    #   firm.to_xml do |xml|
+    #     xml.creator do
+    #       xml.first_name "David"
+    #       xml.last_name "Heinemeier Hansson"
+    #     end
+    #   end
+    #
+    #   <firm>
+    #     # ... normal attributes as shown above ...
+    #     <creator>
+    #       <first_name>David</first_name>
+    #       <last_name>Heinemeier Hansson</last_name>
+    #     </creator>
+    #   </firm>
+    #
+    # As noted above, you may override +to_xml+ in your ActiveRecord::Base
+    # subclasses to have complete control about what's generated. The general
+    # form of doing this is:
+    #
+    #   class IHaveMyOwnXML < ActiveRecord::Base
+    #     def to_xml(options = {})
+    #       require 'builder'
+    #       options[:indent] ||= 2
+    #       xml = options[:builder] ||= ::Builder::XmlMarkup.new(indent: options[:indent])
+    #       xml.instruct! unless options[:skip_instruct]
+    #       xml.level_one do
+    #         xml.tag!(:second_level, 'content')
+    #       end
+    #     end
+    #   end
+    def to_xml(options = {}, &block)
+      XmlSerializer.new(self, options).serialize(&block)
+    end
+  end
+
+  class XmlSerializer < ActiveModel::Serializers::Xml::Serializer #:nodoc:
+    class Attribute < ActiveModel::Serializers::Xml::Serializer::Attribute #:nodoc:
+      def compute_type
+        klass = @serializable.class
+        cast_type = klass.type_for_attribute(name)
+
+        type = ActiveSupport::XmlMini::TYPE_NAMES[value.class.name] || cast_type.type
+
+        { :text => :string,
+          :time => :datetime }[type] || type
+      end
+      protected :compute_type
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/activemodel-serializers-xml-1.0.2/lib/activemodel-serializers-xml.rb

@@ -0,0 +1 @@
+require 'active_model/serializers'

data/vendor/bundle/ruby/2.7.0/gems/activeresource-5.1.1/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2006-2016 David Heinemeier Hansson
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/vendor/bundle/ruby/2.7.0/gems/activeresource-5.1.1/README.rdoc

@@ -0,0 +1,285 @@
+= Active Resource
+
+Active Resource (ARes) connects business objects and Representational State Transfer (REST)
+web services.  It implements object-relational mapping for REST web services to provide transparent
+proxying capabilities between a client (ActiveResource) and a RESTful service (which is provided by Simply RESTful routing
+in ActionController::Resources).
+
+== Philosophy
+
+Active Resource attempts to provide a coherent wrapper object-relational mapping for REST
+web services. It follows the same philosophy as Active Record, in that one of its prime aims
+is to reduce the amount of code needed to map to these resources.  This is made possible
+by relying on a number of code- and protocol-based conventions that make it easy for Active Resource
+to infer complex relations and structures.  These conventions are outlined in detail in the documentation
+for ActiveResource::Base.
+
+== Overview
+
+Model classes are mapped to remote REST resources by Active Resource much the same way Active Record maps model classes to database
+tables.  When a request is made to a remote resource, a REST JSON request is generated, transmitted, and the result
+received and serialized into a usable Ruby object.
+
+== Download and installation
+
+The latest version of Active Resource can be installed with RubyGems:
+
+  % [sudo] gem install activeresource
+
+Or added to a Gemfile:
+
+  gem 'activeresource'
+
+Source code can be downloaded on GitHub
+
+* https://github.com/rails/activeresource/tree/master/activeresource
+
+=== Configuration and Usage
+
+Putting Active Resource to use is very similar to Active Record.  It's as simple as creating a model class
+that inherits from ActiveResource::Base and providing a <tt>site</tt> class variable to it:
+
+   class Person < ActiveResource::Base
+     self.site = "http://api.people.com:3000"
+   end
+
+Now the Person class is REST enabled and can invoke REST services very similarly to how Active Record invokes
+life cycle methods that operate against a persistent store.
+
+   # Find a person with id = 1
+   tyler = Person.find(1)
+   Person.exists?(1)  # => true
+
+As you can see, the methods are quite similar to Active Record's methods for dealing with database
+records.  But rather than dealing directly with a database record, you're dealing with HTTP resources (which may or may not be database records).
+
+Connection settings (`site`, `headers`, `user`, `password`, `proxy`) and the connections themselves are store in
+thread-local variables to make them thread-safe, so you can also set these dynamically, even in a multi-threaded environment, for instance:
+
+    ActiveResource::Base.site = api_site_for(request)
+
+==== Authentication
+
+Active Resource supports the token based authentication provided by Rails through the <tt>ActionController::HttpAuthentication::Token</tt> class using custom headers.
+
+   class Person < ActiveResource::Base
+     self.headers['Authorization'] = 'Token token="abcd"'
+   end
+
+You can also set any specific HTTP header using the same way.  As mentioned above, headers are thread-safe, so you can set headers dynamically, even in a multi-threaded environment:
+
+    ActiveResource::Base.headers['Authorization'] = current_session_api_token
+    
+Global Authentication to be used across all subclasses of ActiveResource::Base should be handled using the ActiveResource::Connection class.
+
+    ActiveResource::Base.connection.auth_type = :bearer
+    ActiveResource::Base.connection.bearer_token = @bearer_token
+    
+    class Person < ActiveResource::Base
+      self.connection.auth_type = :bearer
+      self.connection.bearer_token = @bearer_token
+    end
+
+ActiveResource supports 2 options for HTTP authentication today.
+
+1. Basic
+
+    ActiveResource::Connection.new("http://my%40email.com:%31%32%33@localhost")
+    # username: my@email.com password: 123
+
+2. Bearer Token
+
+    ActiveResource::Base.connection.auth_type = :bearer
+    ActiveResource::Base.connection.bearer_token = @bearer_token
+
+==== Protocol
+
+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 verbs available in the HTTP specification:
+
+* GET requests are used for finding and retrieving resources.
+* POST requests are used to create new resources.
+* PUT requests are used to update existing resources.
+* DELETE requests are used to delete resources.
+
+For more information on how this protocol works with Active Resource, see the ActiveResource::Base documentation;
+for more general information on REST web services, see the article here[http://en.wikipedia.org/wiki/Representational_State_Transfer].
+
+==== Find
+
+Find requests use the GET method and expect the JSON form of whatever resource/resources is/are being requested.  So,
+for a request for a single element, the JSON of that item is expected in response:
+
+   # Expects a response of
+   #
+   # {"id":1,"first":"Tyler","last":"Durden"}
+   #
+   # for GET http://api.people.com:3000/people/1.json
+   #
+   tyler = Person.find(1)
+
+The JSON document that is received is used to build a new object of type Person, with each
+JSON element becoming an attribute on the object.
+
+   tyler.is_a? Person  # => true
+   tyler.last  # => 'Durden'
+
+Any complex element (one that contains other elements) becomes its own object:
+
+   # With this response:
+   # {"id":1,"first":"Tyler","address":{"street":"Paper St.","state":"CA"}}
+   #
+   # for GET http://api.people.com:3000/people/1.json
+   #
+   tyler = Person.find(1)
+   tyler.address  # => <Person::Address::xxxxx>
+   tyler.address.street  # => 'Paper St.'
+
+Collections can also be requested in a similar fashion
+
+   # Expects a response of
+   #
+   # [
+   #   {"id":1,"first":"Tyler","last":"Durden"},
+   #   {"id":2,"first":"Tony","last":"Stark",}
+   # ]
+   #
+   # for GET http://api.people.com:3000/people.json
+   #
+   people = Person.all
+   people.first  # => <Person::xxx 'first' => 'Tyler' ...>
+   people.last  # => <Person::xxx 'first' => 'Tony' ...>
+
+==== Create
+
+Creating a new resource submits the JSON form of the resource as the body of the request and expects
+a 'Location' header in the response with the RESTful URL location of the newly created resource.  The
+id of the newly created resource is parsed out of the Location response header and automatically set
+as the id of the ARes object.
+
+  # {"first":"Tyler","last":"Durden"}
+  #
+  # is submitted as the body on
+  #
+  # if include_root_in_json is not set or set to false => {"first":"Tyler"}
+  # if include_root_in_json is set to true => {"person":{"first":"Tyler"}}
+  #
+  # POST http://api.people.com:3000/people.json
+  #
+  # when save is called on a new Person object.  An empty response is
+  # is expected with a 'Location' header value:
+  #
+  # Response (201): Location: http://api.people.com:3000/people/2
+  #
+  tyler = Person.new(:first => 'Tyler')
+  tyler.new?  # => true
+  tyler.save  # => true
+  tyler.new?  # => false
+  tyler.id    # => 2
+
+==== Update
+
+'save' is also used to update an existing resource and follows the same protocol as creating a resource
+with the exception that no response headers are needed -- just an empty response when the update on the
+server side was successful.
+
+  # {"first":"Tyler"}
+  #
+  # is submitted as the body on
+  #
+  # if include_root_in_json is not set or set to false => {"first":"Tyler"}
+  # if include_root_in_json is set to true => {"person":{"first":"Tyler"}}
+  #
+  # PUT http://api.people.com:3000/people/1.json
+  #
+  # when save is called on an existing Person object.  An empty response is
+  # is expected with code (204)
+  #
+  tyler = Person.find(1)
+  tyler.first # => 'Tyler'
+  tyler.first = 'Tyson'
+  tyler.save  # => true
+
+==== Delete
+
+Destruction of a resource can be invoked as a class and instance method of the resource.
+
+  # A request is made to
+  #
+  # DELETE http://api.people.com:3000/people/1.json
+  #
+  # for both of these forms.  An empty response with
+  # is expected with response code (200)
+  #
+  tyler = Person.find(1)
+  tyler.destroy  # => true
+  tyler.exists?  # => false
+  Person.delete(2)  # => true
+  Person.exists?(2) # => false
+
+==== Associations
+
+Relationships between resources can be declared using the standard association syntax
+that should be familiar to anyone who uses activerecord. For example, using the
+class definition below:
+
+  class Post < ActiveResource::Base
+    self.site = "http://blog.io"
+    has_many :comments
+  end
+
+  post = Post.find(1)      # issues GET http://blog.io/posts/1.json
+  comments = post.comments # issues GET http://blog.io/comments.json?post_id=1
+
+
+If you control the server, you may wish to include nested resources thus avoiding a
+second network request. Given the resource above, if the response includes comments
+in the response, they will be automatically loaded into the activeresource object.
+The server-side model can be adjusted as follows to include comments in the response.
+
+  class Post < ActiveRecord::Base
+    has_many :comments
+
+    def as_json(options)
+      super.merge(:include=>[:comments])
+    end
+  end
+
+==== Logging
+
+Active Resource instruments the event `request.active_resource` when doing a request
+to the remote service. You can subscribe to it by doing:
+
+   ActiveSupport::Notifications.subscribe('request.active_resource')  do |name, start, finish, id, payload|
+
+The `payload` is a `Hash` with the following keys:
+
+* `method` as a `Symbol`
+* `request_uri` as a `String`
+* `result` as an `Net::HTTPResponse`
+
+== License
+
+Active Resource is released under the MIT license:
+
+* http://www.opensource.org/licenses/MIT
+
+== Contributing to Active Resource
+
+Active Resource is work of many contributors. You're encouraged to submit pull requests, propose
+features and discuss issues.
+
+See {CONTRIBUTING}[https://github.com/rails/activeresource/blob/master/CONTRIBUTING.md].
+
+== Support
+
+Full API documentation is available at
+
+* http://rubydoc.info/gems/activeresource
+
+Bug reports and feature requests can be filed with the rest for the Ruby on Rails project here:
+
+* https://github.com/rails/activeresource/issues
+
+You can find more usage information in the ActiveResource::Base documentation.

data/vendor/bundle/ruby/2.7.0/gems/activeresource-5.1.1/lib/active_resource/active_job_serializer.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module ActiveResource
+  class ActiveJobSerializer < ActiveJob::Serializers::ObjectSerializer
+    def serialize(resource)
+      super(
+        "class" => resource.class.name,
+        "persisted" => resource.persisted?,
+        "prefix_options" => resource.prefix_options.as_json,
+        "attributes" => resource.attributes.as_json
+      )
+    end
+
+    def deserialize(hash)
+      hash["class"].constantize.new(hash["attributes"]).tap do |resource|
+        resource.persisted      = hash["persisted"]
+        resource.prefix_options = hash["prefix_options"]
+      end
+    end
+
+    private
+      def klass
+        ActiveResource::Base
+      end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/activeresource-5.1.1/lib/active_resource/associations/builder/association.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+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]
+
+    # would identify subclasses of association
+    class_attribute :macro
+
+    attr_reader :model, :name, :options, :klass
+
+    def self.build(model, name, options)
+      new(model, name, options).build
+    end
+
+    def initialize(model, name, options)
+      @model, @name, @options = model, name, options
+    end
+
+    def build
+      validate_options
+      model.create_reflection(self.class.macro, name, options)
+    end
+
+    private
+
+      def validate_options
+        options.assert_valid_keys(self.class.valid_options)
+      end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/activeresource-5.1.1/lib/active_resource/associations/builder/belongs_to.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module ActiveResource::Associations::Builder
+  class BelongsTo < Association
+    self.valid_options += [:foreign_key]
+
+    self.macro = :belongs_to
+
+    def build
+      validate_options
+      reflection = model.create_reflection(self.class.macro, name, options)
+      model.defines_belongs_to_finder_method(reflection)
+      reflection
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/activeresource-5.1.1/lib/active_resource/associations/builder/has_many.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module ActiveResource::Associations::Builder
+  class HasMany < Association
+    self.macro = :has_many
+
+    def build
+      validate_options
+      model.create_reflection(self.class.macro, name, options).tap do |reflection|
+        model.defines_has_many_finder_method(reflection)
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/activeresource-5.1.1/lib/active_resource/associations/builder/has_one.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module ActiveResource::Associations::Builder
+  class HasOne < Association
+    self.macro = :has_one
+
+    def build
+      validate_options
+      model.create_reflection(self.class.macro, name, options).tap do |reflection|
+        model.defines_has_one_finder_method(reflection)
+      end
+    end
+  end
+end