ric 0.13.0 → 0.14.0

data/vendor/bundle/ruby/2.5.0/gems/activesupport-5.2.3/lib/active_support/core_ext/module/attribute_accessors_per_thread.rb

@@ -1,150 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/array/extract_options"
-require "active_support/core_ext/regexp"
-
-# Extends the module object with class/module and instance accessors for
-# class/module attributes, just like the native attr* accessors for instance
-# attributes, but does so on a per-thread basis.
-#
-# So the values are scoped within the Thread.current space under the class name
-# of the module.
-class Module
-  # Defines a per-thread class attribute and creates class and instance reader methods.
-  # The underlying per-thread class variable is set to +nil+, if it is not previously defined.
-  #
-  #   module Current
-  #     thread_mattr_reader :user
-  #   end
-  #
-  #   Current.user # => nil
-  #   Thread.current[:attr_Current_user] = "DHH"
-  #   Current.user # => "DHH"
-  #
-  # The attribute name must be a valid method name in Ruby.
-  #
-  #   module Foo
-  #     thread_mattr_reader :"1_Badname"
-  #   end
-  #   # => NameError: invalid attribute name: 1_Badname
-  #
-  # If you want to opt out of the creation of the instance reader method, pass
-  # <tt>instance_reader: false</tt> or <tt>instance_accessor: false</tt>.
-  #
-  #   class Current
-  #     thread_mattr_reader :user, instance_reader: false
-  #   end
-  #
-  #   Current.new.user # => NoMethodError
-  def thread_mattr_reader(*syms) # :nodoc:
-    options = syms.extract_options!
-
-    syms.each do |sym|
-      raise NameError.new("invalid attribute name: #{sym}") unless /^[_A-Za-z]\w*$/.match?(sym)
-
-      # The following generated method concatenates `name` because we want it
-      # to work with inheritance via polymorphism.
-      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-        def self.#{sym}
-          Thread.current["attr_" + name + "_#{sym}"]
-        end
-      EOS
-
-      unless options[:instance_reader] == false || options[:instance_accessor] == false
-        class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-          def #{sym}
-            self.class.#{sym}
-          end
-        EOS
-      end
-    end
-  end
-  alias :thread_cattr_reader :thread_mattr_reader
-
-  # Defines a per-thread class attribute and creates a class and instance writer methods to
-  # allow assignment to the attribute.
-  #
-  #   module Current
-  #     thread_mattr_writer :user
-  #   end
-  #
-  #   Current.user = "DHH"
-  #   Thread.current[:attr_Current_user] # => "DHH"
-  #
-  # If you want to opt out of the creation of the instance writer method, pass
-  # <tt>instance_writer: false</tt> or <tt>instance_accessor: false</tt>.
-  #
-  #   class Current
-  #     thread_mattr_writer :user, instance_writer: false
-  #   end
-  #
-  #   Current.new.user = "DHH" # => NoMethodError
-  def thread_mattr_writer(*syms) # :nodoc:
-    options = syms.extract_options!
-    syms.each do |sym|
-      raise NameError.new("invalid attribute name: #{sym}") unless /^[_A-Za-z]\w*$/.match?(sym)
-
-      # The following generated method concatenates `name` because we want it
-      # to work with inheritance via polymorphism.
-      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-        def self.#{sym}=(obj)
-          Thread.current["attr_" + name + "_#{sym}"] = obj
-        end
-      EOS
-
-      unless options[:instance_writer] == false || options[:instance_accessor] == false
-        class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-          def #{sym}=(obj)
-            self.class.#{sym} = obj
-          end
-        EOS
-      end
-    end
-  end
-  alias :thread_cattr_writer :thread_mattr_writer
-
-  # Defines both class and instance accessors for class attributes.
-  #
-  #   class Account
-  #     thread_mattr_accessor :user
-  #   end
-  #
-  #   Account.user = "DHH"
-  #   Account.user     # => "DHH"
-  #   Account.new.user # => "DHH"
-  #
-  # If a subclass changes the value, the parent class' value is not changed.
-  # Similarly, if the parent class changes the value, the value of subclasses
-  # is not changed.
-  #
-  #   class Customer < Account
-  #   end
-  #
-  #   Customer.user = "Rafael"
-  #   Customer.user # => "Rafael"
-  #   Account.user  # => "DHH"
-  #
-  # To opt out of the instance writer method, pass <tt>instance_writer: false</tt>.
-  # To opt out of the instance reader method, pass <tt>instance_reader: false</tt>.
-  #
-  #   class Current
-  #     thread_mattr_accessor :user, instance_writer: false, instance_reader: false
-  #   end
-  #
-  #   Current.new.user = "DHH"  # => NoMethodError
-  #   Current.new.user          # => NoMethodError
-  #
-  # Or pass <tt>instance_accessor: false</tt>, to opt out both instance methods.
-  #
-  #   class Current
-  #     mattr_accessor :user, instance_accessor: false
-  #   end
-  #
-  #   Current.new.user = "DHH"  # => NoMethodError
-  #   Current.new.user          # => NoMethodError
-  def thread_mattr_accessor(*syms)
-    thread_mattr_reader(*syms)
-    thread_mattr_writer(*syms)
-  end
-  alias :thread_cattr_accessor :thread_mattr_accessor
-end

data/vendor/bundle/ruby/2.5.0/gems/activesupport-5.2.3/lib/active_support/core_ext/module/concerning.rb

@@ -1,134 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/concern"
-
-class Module
-  # = Bite-sized separation of concerns
-  #
-  # We often find ourselves with a medium-sized chunk of behavior that we'd
-  # like to extract, but only mix in to a single class.
-  #
-  # Extracting a plain old Ruby object to encapsulate it and collaborate or
-  # delegate to the original object is often a good choice, but when there's
-  # no additional state to encapsulate or we're making DSL-style declarations
-  # about the parent class, introducing new collaborators can obfuscate rather
-  # than simplify.
-  #
-  # The typical route is to just dump everything in a monolithic class, perhaps
-  # with a comment, as a least-bad alternative. Using modules in separate files
-  # means tedious sifting to get a big-picture view.
-  #
-  # = Dissatisfying ways to separate small concerns
-  #
-  # == Using comments:
-  #
-  #   class Todo < ApplicationRecord
-  #     # Other todo implementation
-  #     # ...
-  #
-  #     ## Event tracking
-  #     has_many :events
-  #
-  #     before_create :track_creation
-  #
-  #     private
-  #       def track_creation
-  #         # ...
-  #       end
-  #   end
-  #
-  # == With an inline module:
-  #
-  # Noisy syntax.
-  #
-  #   class Todo < ApplicationRecord
-  #     # Other todo implementation
-  #     # ...
-  #
-  #     module EventTracking
-  #       extend ActiveSupport::Concern
-  #
-  #       included do
-  #         has_many :events
-  #         before_create :track_creation
-  #       end
-  #
-  #       private
-  #         def track_creation
-  #           # ...
-  #         end
-  #     end
-  #     include EventTracking
-  #   end
-  #
-  # == Mix-in noise exiled to its own file:
-  #
-  # Once our chunk of behavior starts pushing the scroll-to-understand-it
-  # boundary, we give in and move it to a separate file. At this size, the
-  # increased overhead can be a reasonable tradeoff even if it reduces our
-  # at-a-glance perception of how things work.
-  #
-  #   class Todo < ApplicationRecord
-  #     # Other todo implementation
-  #     # ...
-  #
-  #     include TodoEventTracking
-  #   end
-  #
-  # = Introducing Module#concerning
-  #
-  # By quieting the mix-in noise, we arrive at a natural, low-ceremony way to
-  # separate bite-sized concerns.
-  #
-  #   class Todo < ApplicationRecord
-  #     # Other todo implementation
-  #     # ...
-  #
-  #     concerning :EventTracking do
-  #       included do
-  #         has_many :events
-  #         before_create :track_creation
-  #       end
-  #
-  #       private
-  #         def track_creation
-  #           # ...
-  #         end
-  #     end
-  #   end
-  #
-  #   Todo.ancestors
-  #   # => [Todo, Todo::EventTracking, ApplicationRecord, Object]
-  #
-  # This small step has some wonderful ripple effects. We can
-  # * grok the behavior of our class in one glance,
-  # * clean up monolithic junk-drawer classes by separating their concerns, and
-  # * stop leaning on protected/private for crude "this is internal stuff" modularity.
-  module Concerning
-    # Define a new concern and mix it in.
-    def concerning(topic, &block)
-      include concern(topic, &block)
-    end
-
-    # A low-cruft shortcut to define a concern.
-    #
-    #   concern :EventTracking do
-    #     ...
-    #   end
-    #
-    # is equivalent to
-    #
-    #   module EventTracking
-    #     extend ActiveSupport::Concern
-    #
-    #     ...
-    #   end
-    def concern(topic, &module_definition)
-      const_set topic, Module.new {
-        extend ::ActiveSupport::Concern
-        module_eval(&module_definition)
-      }
-    end
-  end
-  include Concerning
-end

data/vendor/bundle/ruby/2.5.0/gems/activesupport-5.2.3/lib/active_support/core_ext/module/delegation.rb

@@ -1,287 +0,0 @@
-# frozen_string_literal: true
-
-require "set"
-require "active_support/core_ext/regexp"
-
-class Module
-  # Error generated by +delegate+ when a method is called on +nil+ and +allow_nil+
-  # option is not used.
-  class DelegationError < NoMethodError; end
-
-  RUBY_RESERVED_KEYWORDS = %w(alias and BEGIN begin break case class def defined? do
-  else elsif END end ensure false for if in module next nil not or redo rescue retry
-  return self super then true undef unless until when while yield)
-  DELEGATION_RESERVED_KEYWORDS = %w(_ arg args block)
-  DELEGATION_RESERVED_METHOD_NAMES = Set.new(
-    RUBY_RESERVED_KEYWORDS + DELEGATION_RESERVED_KEYWORDS
-  ).freeze
-
-  # Provides a +delegate+ class method to easily expose contained objects'
-  # public methods as your own.
-  #
-  # ==== Options
-  # * <tt>:to</tt> - Specifies the target object
-  # * <tt>:prefix</tt> - Prefixes the new method with the target name or a custom prefix
-  # * <tt>:allow_nil</tt> - if set to true, prevents a +Module::DelegationError+
-  #   from being raised
-  #
-  # The macro receives one or more method names (specified as symbols or
-  # strings) and the name of the target object via the <tt>:to</tt> option
-  # (also a symbol or string).
-  #
-  # Delegation is particularly useful with Active Record associations:
-  #
-  #   class Greeter < ActiveRecord::Base
-  #     def hello
-  #       'hello'
-  #     end
-  #
-  #     def goodbye
-  #       'goodbye'
-  #     end
-  #   end
-  #
-  #   class Foo < ActiveRecord::Base
-  #     belongs_to :greeter
-  #     delegate :hello, to: :greeter
-  #   end
-  #
-  #   Foo.new.hello   # => "hello"
-  #   Foo.new.goodbye # => NoMethodError: undefined method `goodbye' for #<Foo:0x1af30c>
-  #
-  # Multiple delegates to the same target are allowed:
-  #
-  #   class Foo < ActiveRecord::Base
-  #     belongs_to :greeter
-  #     delegate :hello, :goodbye, to: :greeter
-  #   end
-  #
-  #   Foo.new.goodbye # => "goodbye"
-  #
-  # Methods can be delegated to instance variables, class variables, or constants
-  # by providing them as a symbols:
-  #
-  #   class Foo
-  #     CONSTANT_ARRAY = [0,1,2,3]
-  #     @@class_array  = [4,5,6,7]
-  #
-  #     def initialize
-  #       @instance_array = [8,9,10,11]
-  #     end
-  #     delegate :sum, to: :CONSTANT_ARRAY
-  #     delegate :min, to: :@@class_array
-  #     delegate :max, to: :@instance_array
-  #   end
-  #
-  #   Foo.new.sum # => 6
-  #   Foo.new.min # => 4
-  #   Foo.new.max # => 11
-  #
-  # It's also possible to delegate a method to the class by using +:class+:
-  #
-  #   class Foo
-  #     def self.hello
-  #       "world"
-  #     end
-  #
-  #     delegate :hello, to: :class
-  #   end
-  #
-  #   Foo.new.hello # => "world"
-  #
-  # Delegates can optionally be prefixed using the <tt>:prefix</tt> option. If the value
-  # is <tt>true</tt>, the delegate methods are prefixed with the name of the object being
-  # delegated to.
-  #
-  #   Person = Struct.new(:name, :address)
-  #
-  #   class Invoice < Struct.new(:client)
-  #     delegate :name, :address, to: :client, prefix: true
-  #   end
-  #
-  #   john_doe = Person.new('John Doe', 'Vimmersvej 13')
-  #   invoice = Invoice.new(john_doe)
-  #   invoice.client_name    # => "John Doe"
-  #   invoice.client_address # => "Vimmersvej 13"
-  #
-  # It is also possible to supply a custom prefix.
-  #
-  #   class Invoice < Struct.new(:client)
-  #     delegate :name, :address, to: :client, prefix: :customer
-  #   end
-  #
-  #   invoice = Invoice.new(john_doe)
-  #   invoice.customer_name    # => 'John Doe'
-  #   invoice.customer_address # => 'Vimmersvej 13'
-  #
-  # If the target is +nil+ and does not respond to the delegated method a
-  # +Module::DelegationError+ is raised. If you wish to instead return +nil+,
-  # use the <tt>:allow_nil</tt> option.
-  #
-  #   class User < ActiveRecord::Base
-  #     has_one :profile
-  #     delegate :age, to: :profile
-  #   end
-  #
-  #   User.new.age
-  #   # => Module::DelegationError: User#age delegated to profile.age, but profile is nil
-  #
-  # But if not having a profile yet is fine and should not be an error
-  # condition:
-  #
-  #   class User < ActiveRecord::Base
-  #     has_one :profile
-  #     delegate :age, to: :profile, allow_nil: true
-  #   end
-  #
-  #   User.new.age # nil
-  #
-  # Note that if the target is not +nil+ then the call is attempted regardless of the
-  # <tt>:allow_nil</tt> option, and thus an exception is still raised if said object
-  # does not respond to the method:
-  #
-  #   class Foo
-  #     def initialize(bar)
-  #       @bar = bar
-  #     end
-  #
-  #     delegate :name, to: :@bar, allow_nil: true
-  #   end
-  #
-  #   Foo.new("Bar").name # raises NoMethodError: undefined method `name'
-  #
-  # The target method must be public, otherwise it will raise +NoMethodError+.
-  def delegate(*methods, to: nil, prefix: nil, allow_nil: nil)
-    unless to
-      raise ArgumentError, "Delegation needs a target. Supply an options hash with a :to key as the last argument (e.g. delegate :hello, to: :greeter)."
-    end
-
-    if prefix == true && /^[^a-z_]/.match?(to)
-      raise ArgumentError, "Can only automatically set the delegation prefix when delegating to a method."
-    end
-
-    method_prefix = \
-      if prefix
-        "#{prefix == true ? to : prefix}_"
-      else
-        ""
-      end
-
-    location = caller_locations(1, 1).first
-    file, line = location.path, location.lineno
-
-    to = to.to_s
-    to = "self.#{to}" if DELEGATION_RESERVED_METHOD_NAMES.include?(to)
-
-    methods.map do |method|
-      # Attribute writer methods only accept one argument. Makes sure []=
-      # methods still accept two arguments.
-      definition = /[^\]]=$/.match?(method) ? "arg" : "*args, &block"
-
-      # The following generated method calls the target exactly once, storing
-      # the returned value in a dummy variable.
-      #
-      # Reason is twofold: On one hand doing less calls is in general better.
-      # On the other hand it could be that the target has side-effects,
-      # whereas conceptually, from the user point of view, the delegator should
-      # be doing one call.
-      if allow_nil
-        method_def = [
-          "def #{method_prefix}#{method}(#{definition})",
-          "_ = #{to}",
-          "if !_.nil? || nil.respond_to?(:#{method})",
-          "  _.#{method}(#{definition})",
-          "end",
-        "end"
-        ].join ";"
-      else
-        exception = %(raise DelegationError, "#{self}##{method_prefix}#{method} delegated to #{to}.#{method}, but #{to} is nil: \#{self.inspect}")
-
-        method_def = [
-          "def #{method_prefix}#{method}(#{definition})",
-          " _ = #{to}",
-          "  _.#{method}(#{definition})",
-          "rescue NoMethodError => e",
-          "  if _.nil? && e.name == :#{method}",
-          "    #{exception}",
-          "  else",
-          "    raise",
-          "  end",
-          "end"
-        ].join ";"
-      end
-
-      module_eval(method_def, file, line)
-    end
-  end
-
-  # When building decorators, a common pattern may emerge:
-  #
-  #   class Partition
-  #     def initialize(event)
-  #       @event = event
-  #     end
-  #
-  #     def person
-  #       @event.detail.person || @event.creator
-  #     end
-  #
-  #     private
-  #       def respond_to_missing?(name, include_private = false)
-  #         @event.respond_to?(name, include_private)
-  #       end
-  #
-  #       def method_missing(method, *args, &block)
-  #         @event.send(method, *args, &block)
-  #       end
-  #   end
-  #
-  # With <tt>Module#delegate_missing_to</tt>, the above is condensed to:
-  #
-  #   class Partition
-  #     delegate_missing_to :@event
-  #
-  #     def initialize(event)
-  #       @event = event
-  #     end
-  #
-  #     def person
-  #       @event.detail.person || @event.creator
-  #     end
-  #   end
-  #
-  # The target can be anything callable within the object, e.g. instance
-  # variables, methods, constants, etc.
-  #
-  # The delegated method must be public on the target, otherwise it will
-  # raise +NoMethodError+.
-  def delegate_missing_to(target)
-    target = target.to_s
-    target = "self.#{target}" if DELEGATION_RESERVED_METHOD_NAMES.include?(target)
-
-    module_eval <<-RUBY, __FILE__, __LINE__ + 1
-      def respond_to_missing?(name, include_private = false)
-        # It may look like an oversight, but we deliberately do not pass
-        # +include_private+, because they do not get delegated.
-
-        #{target}.respond_to?(name) || super
-      end
-
-      def method_missing(method, *args, &block)
-        if #{target}.respond_to?(method)
-          #{target}.public_send(method, *args, &block)
-        else
-          begin
-            super
-          rescue NoMethodError
-            if #{target}.nil?
-              raise DelegationError, "\#{method} delegated to #{target}, but #{target} is nil"
-            else
-              raise
-            end
-          end
-        end
-      end
-    RUBY
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/activesupport-5.2.3/lib/active_support/core_ext/module/introspection.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/inflector"
-
-class Module
-  # Returns the name of the module containing this one.
-  #
-  #   M::N.parent_name # => "M"
-  def parent_name
-    if defined?(@parent_name)
-      @parent_name
-    else
-      parent_name = name =~ /::[^:]+\Z/ ? $`.freeze : nil
-      @parent_name = parent_name unless frozen?
-      parent_name
-    end
-  end
-
-  # Returns the module which contains this one according to its name.
-  #
-  #   module M
-  #     module N
-  #     end
-  #   end
-  #   X = M::N
-  #
-  #   M::N.parent # => M
-  #   X.parent    # => M
-  #
-  # The parent of top-level and anonymous modules is Object.
-  #
-  #   M.parent          # => Object
-  #   Module.new.parent # => Object
-  def parent
-    parent_name ? ActiveSupport::Inflector.constantize(parent_name) : Object
-  end
-
-  # Returns all the parents of this module according to its name, ordered from
-  # nested outwards. The receiver is not contained within the result.
-  #
-  #   module M
-  #     module N
-  #     end
-  #   end
-  #   X = M::N
-  #
-  #   M.parents    # => [Object]
-  #   M::N.parents # => [M, Object]
-  #   X.parents    # => [M, Object]
-  def parents
-    parents = []
-    if parent_name
-      parts = parent_name.split("::")
-      until parts.empty?
-        parents << ActiveSupport::Inflector.constantize(parts * "::")
-        parts.pop
-      end
-    end
-    parents << Object unless parents.include? Object
-    parents
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/activesupport-5.2.3/lib/active_support/core_ext/module/reachable.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/module/anonymous"
-require "active_support/core_ext/string/inflections"
-
-class Module
-  def reachable? #:nodoc:
-    !anonymous? && name.safe_constantize.equal?(self)
-  end
-  deprecate :reachable?
-end

data/vendor/bundle/ruby/2.5.0/gems/activesupport-5.2.3/lib/active_support/core_ext/module/redefine_method.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-class Module
-  if RUBY_VERSION >= "2.3"
-    # Marks the named method as intended to be redefined, if it exists.
-    # Suppresses the Ruby method redefinition warning. Prefer
-    # #redefine_method where possible.
-    def silence_redefinition_of_method(method)
-      if method_defined?(method) || private_method_defined?(method)
-        # This suppresses the "method redefined" warning; the self-alias
-        # looks odd, but means we don't need to generate a unique name
-        alias_method method, method
-      end
-    end
-  else
-    def silence_redefinition_of_method(method)
-      if method_defined?(method) || private_method_defined?(method)
-        alias_method :__rails_redefine, method
-        remove_method :__rails_redefine
-      end
-    end
-  end
-
-  # Replaces the existing method definition, if there is one, with the passed
-  # block as its body.
-  def redefine_method(method, &block)
-    visibility = method_visibility(method)
-    silence_redefinition_of_method(method)
-    define_method(method, &block)
-    send(visibility, method)
-  end
-
-  # Replaces the existing singleton method definition, if there is one, with
-  # the passed block as its body.
-  def redefine_singleton_method(method, &block)
-    singleton_class.redefine_method(method, &block)
-  end
-
-  def method_visibility(method) # :nodoc:
-    case
-    when private_method_defined?(method)
-      :private
-    when protected_method_defined?(method)
-      :protected
-    else
-      :public
-    end
-  end
-end