ric 0.14.2 → 0.14.6

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

@@ -1,194 +0,0 @@
-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

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

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

@@ -1,20 +0,0 @@
-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

@@ -1,285 +0,0 @@
-= 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

@@ -1,26 +0,0 @@
-# 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

@@ -1,33 +0,0 @@
-# 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

@@ -1,16 +0,0 @@
-# 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

@@ -1,14 +0,0 @@
-# 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

@@ -1,14 +0,0 @@
-# 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