activesupport 4.2.11.1 → 5.2.4

data/lib/active_support/core_ext/module/attr_internal.rb

@@ -1,12 +1,14 @@
+# frozen_string_literal: true
+
 class Module
   # Declares an attribute reader backed by an internally-named instance variable.
   def attr_internal_reader(*attrs)
-    attrs.each {|attr_name| attr_internal_define(attr_name, :reader)}
+    attrs.each { |attr_name| attr_internal_define(attr_name, :reader) }
   end
 
   # Declares an attribute writer backed by an internally-named instance variable.
   def attr_internal_writer(*attrs)
-    attrs.each {|attr_name| attr_internal_define(attr_name, :writer)}
+    attrs.each { |attr_name| attr_internal_define(attr_name, :writer) }
   end
 
   # Declares an attribute reader and writer backed by an internally-named instance
@@ -18,7 +20,7 @@ class Module
   alias_method :attr_internal, :attr_internal_accessor
 
   class << self; attr_accessor :attr_internal_naming_format end
-  self.attr_internal_naming_format = '@_%s'
+  self.attr_internal_naming_format = "@_%s"
 
   private
     def attr_internal_ivar_name(attr)
@@ -26,12 +28,9 @@ class Module
     end
 
     def attr_internal_define(attr_name, type)
-      internal_name = attr_internal_ivar_name(attr_name).sub(/\A@/, '')
-      # class_eval is necessary on 1.9 or else the methods are made private
-      class_eval do
-        # use native attr_* methods as they are faster on some Ruby implementations
-        send("attr_#{type}", internal_name)
-      end
+      internal_name = attr_internal_ivar_name(attr_name).sub(/\A@/, "")
+      # use native attr_* methods as they are faster on some Ruby implementations
+      send("attr_#{type}", internal_name)
       attr_name, internal_name = "#{attr_name}=", "#{internal_name}=" if type == :writer
       alias_method attr_name, internal_name
       remove_method internal_name

data/lib/active_support/core_ext/module/attribute_accessors.rb

@@ -1,12 +1,16 @@
-require 'active_support/core_ext/array/extract_options'
+# 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.
 class Module
   # Defines a class attribute and creates a class and instance reader methods.
-  # The underlying the class variable is set to +nil+, if it is not previously
-  # defined.
+  # The underlying class variable is set to +nil+, if it is not previously
+  # defined. All class and instance methods created will be public, even if
+  # this method is called with a private or protected access modifier.
   #
   #   module HairColors
   #     mattr_reader :hair_colors
@@ -19,15 +23,15 @@ class Module
   # The attribute name must be a valid method name in Ruby.
   #
   #   module Foo
-  #     mattr_reader :"1_Badname "
+  #     mattr_reader :"1_Badname"
   #   end
-  #   # => NameError: invalid attribute name
+  #   # => NameError: invalid attribute name: 1_Badname
   #
   # If you want to opt out the creation on the instance reader method, pass
   # <tt>instance_reader: false</tt> or <tt>instance_accessor: false</tt>.
   #
   #   module HairColors
-  #     mattr_writer :hair_colors, instance_reader: false
+  #     mattr_reader :hair_colors, instance_reader: false
   #   end
   #
   #   class Person
@@ -36,24 +40,20 @@ class Module
   #
   #   Person.new.hair_colors # => NoMethodError
   #
-  #
-  # Also, you can pass a block to set up the attribute with a default value.
+  # You can set a default value for the attribute.
   #
   #   module HairColors
-  #     cattr_reader :hair_colors do
-  #       [:brown, :black, :blonde, :red]
-  #     end
+  #     mattr_reader :hair_colors, default: [:brown, :black, :blonde, :red]
   #   end
   #
   #   class Person
   #     include HairColors
   #   end
   #
-  #   Person.hair_colors # => [:brown, :black, :blonde, :red]
-  def mattr_reader(*syms)
-    options = syms.extract_options!
+  #   Person.new.hair_colors # => [:brown, :black, :blonde, :red]
+  def mattr_reader(*syms, instance_reader: true, instance_accessor: true, default: nil)
     syms.each do |sym|
-      raise NameError.new("invalid attribute name: #{sym}") unless sym =~ /^[_A-Za-z]\w*$/
+      raise NameError.new("invalid attribute name: #{sym}") unless /\A[_A-Za-z]\w*\z/.match?(sym)
       class_eval(<<-EOS, __FILE__, __LINE__ + 1)
         @@#{sym} = nil unless defined? @@#{sym}
 
@@ -62,20 +62,24 @@ class Module
         end
       EOS
 
-      unless options[:instance_reader] == false || options[:instance_accessor] == false
+      if instance_reader && instance_accessor
         class_eval(<<-EOS, __FILE__, __LINE__ + 1)
           def #{sym}
             @@#{sym}
           end
         EOS
       end
-      class_variable_set("@@#{sym}", yield) if block_given?
+
+      sym_default_value = (block_given? && default.nil?) ? yield : default
+      class_variable_set("@@#{sym}", sym_default_value) unless sym_default_value.nil?
     end
   end
   alias :cattr_reader :mattr_reader
 
   # Defines a class attribute and creates a class and instance writer methods to
-  # allow assignment to the attribute.
+  # allow assignment to the attribute. All class and instance methods created
+  # will be public, even if this method is called with a private or protected
+  # access modifier.
   #
   #   module HairColors
   #     mattr_writer :hair_colors
@@ -103,12 +107,10 @@ class Module
   #
   #   Person.new.hair_colors = [:blonde, :red] # => NoMethodError
   #
-  # Also, you can pass a block to set up the attribute with a default value.
+  # You can set a default value for the attribute.
   #
-  #   class HairColors
-  #     mattr_writer :hair_colors do
-  #       [:brown, :black, :blonde, :red]
-  #     end
+  #   module HairColors
+  #     mattr_writer :hair_colors, default: [:brown, :black, :blonde, :red]
   #   end
   #
   #   class Person
@@ -116,10 +118,9 @@ class Module
   #   end
   #
   #   Person.class_variable_get("@@hair_colors") # => [:brown, :black, :blonde, :red]
-  def mattr_writer(*syms)
-    options = syms.extract_options!
+  def mattr_writer(*syms, instance_writer: true, instance_accessor: true, default: nil)
     syms.each do |sym|
-      raise NameError.new("invalid attribute name: #{sym}") unless sym =~ /^[_A-Za-z]\w*$/
+      raise NameError.new("invalid attribute name: #{sym}") unless /\A[_A-Za-z]\w*\z/.match?(sym)
       class_eval(<<-EOS, __FILE__, __LINE__ + 1)
         @@#{sym} = nil unless defined? @@#{sym}
 
@@ -128,19 +129,23 @@ class Module
         end
       EOS
 
-      unless options[:instance_writer] == false || options[:instance_accessor] == false
+      if instance_writer && instance_accessor
         class_eval(<<-EOS, __FILE__, __LINE__ + 1)
           def #{sym}=(obj)
             @@#{sym} = obj
           end
         EOS
       end
-      send("#{sym}=", yield) if block_given?
+
+      sym_default_value = (block_given? && default.nil?) ? yield : default
+      send("#{sym}=", sym_default_value) unless sym_default_value.nil?
     end
   end
   alias :cattr_writer :mattr_writer
 
   # Defines both class and instance accessors for class attributes.
+  # All class and instance methods created will be public, even if
+  # this method is called with a private or protected access modifier.
   #
   #   module HairColors
   #     mattr_accessor :hair_colors
@@ -150,8 +155,8 @@ class Module
   #     include HairColors
   #   end
   #
-  #   Person.hair_colors = [:brown, :black, :blonde, :red]
-  #   Person.hair_colors     # => [:brown, :black, :blonde, :red]
+  #   HairColors.hair_colors = [:brown, :black, :blonde, :red]
+  #   HairColors.hair_colors # => [:brown, :black, :blonde, :red]
   #   Person.new.hair_colors # => [:brown, :black, :blonde, :red]
   #
   # If a subclass changes the value then that would also change the value for
@@ -161,8 +166,8 @@ class Module
   #   class Male < Person
   #   end
   #
-  #   Male.hair_colors << :blue
-  #   Person.hair_colors # => [:brown, :black, :blonde, :red, :blue]
+  #   Male.new.hair_colors << :blue
+  #   Person.new.hair_colors # => [:brown, :black, :blonde, :red, :blue]
   #
   # 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>.
@@ -191,22 +196,20 @@ class Module
   #   Person.new.hair_colors = [:brown]  # => NoMethodError
   #   Person.new.hair_colors             # => NoMethodError
   #
-  # Also you can pass a block to set up the attribute with a default value.
+  # You can set a default value for the attribute.
   #
   #   module HairColors
-  #     mattr_accessor :hair_colors do
-  #       [:brown, :black, :blonde, :red]
-  #     end
+  #     mattr_accessor :hair_colors, default: [:brown, :black, :blonde, :red]
   #   end
   #
   #   class Person
   #     include HairColors
   #   end
   #
-  #   Person.class_variable_get("@@hair_colors") #=> [:brown, :black, :blonde, :red]
-  def mattr_accessor(*syms, &blk)
-    mattr_reader(*syms, &blk)
-    mattr_writer(*syms, &blk)
+  #   Person.class_variable_get("@@hair_colors") # => [:brown, :black, :blonde, :red]
+  def mattr_accessor(*syms, instance_reader: true, instance_writer: true, instance_accessor: true, default: nil, &blk)
+    mattr_reader(*syms, instance_reader: instance_reader, instance_accessor: instance_accessor, default: default, &blk)
+    mattr_writer(*syms, instance_writer: instance_writer, instance_accessor: instance_accessor, default: default)
   end
   alias :cattr_accessor :mattr_accessor
 end

data/lib/active_support/core_ext/module/attribute_accessors_per_thread.rb

@@ -0,0 +1,150 @@
+# 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/lib/active_support/core_ext/module/concerning.rb

@@ -1,4 +1,6 @@
-require 'active_support/concern'
+# frozen_string_literal: true
+
+require "active_support/concern"
 
 class Module
   # = Bite-sized separation of concerns
@@ -20,7 +22,7 @@ class Module
   #
   # == Using comments:
   #
-  #   class Todo
+  #   class Todo < ApplicationRecord
   #     # Other todo implementation
   #     # ...
   #
@@ -28,7 +30,6 @@ class Module
   #     has_many :events
   #
   #     before_create :track_creation
-  #     after_destroy :track_deletion
   #
   #     private
   #       def track_creation
@@ -40,7 +41,7 @@ class Module
   #
   # Noisy syntax.
   #
-  #   class Todo
+  #   class Todo < ApplicationRecord
   #     # Other todo implementation
   #     # ...
   #
@@ -50,7 +51,6 @@ class Module
   #       included do
   #         has_many :events
   #         before_create :track_creation
-  #         after_destroy :track_deletion
   #       end
   #
   #       private
@@ -63,12 +63,12 @@ class Module
   #
   # == Mix-in noise exiled to its own file:
   #
-  # Once our chunk of behavior starts pushing the scroll-to-understand it's
+  # 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
-  # overhead feels in good proportion to the size of our extraction, despite
-  # diluting our at-a-glance sense of how things really work.
+  # increased overhead can be a reasonable tradeoff even if it reduces our
+  # at-a-glance perception of how things work.
   #
-  #   class Todo
+  #   class Todo < ApplicationRecord
   #     # Other todo implementation
   #     # ...
   #
@@ -80,7 +80,7 @@ class Module
   # By quieting the mix-in noise, we arrive at a natural, low-ceremony way to
   # separate bite-sized concerns.
   #
-  #   class Todo
+  #   class Todo < ApplicationRecord
   #     # Other todo implementation
   #     # ...
   #
@@ -88,7 +88,6 @@ class Module
   #       included do
   #         has_many :events
   #         before_create :track_creation
-  #         after_destroy :track_deletion
   #       end
   #
   #       private
@@ -99,7 +98,7 @@ class Module
   #   end
   #
   #   Todo.ancestors
-  #   # => Todo, Todo::EventTracking, Object
+  #   # => [Todo, Todo::EventTracking, ApplicationRecord, Object]
   #
   # This small step has some wonderful ripple effects. We can
   # * grok the behavior of our class in one glance,

data/lib/active_support/core_ext/module/delegation.rb

@@ -1,14 +1,19 @@
-require 'set'
+# 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_WORDS = Set.new(
-    %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)
+  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'
@@ -17,7 +22,8 @@ class Module
   # ==== 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 +NoMethodError+ to be raised
+  # * <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
@@ -109,18 +115,16 @@ class Module
   #   invoice.customer_address # => 'Vimmersvej 13'
   #
   # If the target is +nil+ and does not respond to the delegated method a
-  # +NoMethodError+ is raised, as with any other value. Sometimes, however, it
-  # makes sense to be robust to that situation and that is the purpose of the
-  # <tt>:allow_nil</tt> option: If the target is not +nil+, or it is and
-  # responds to the method, everything works as usual. But if it is +nil+ and
-  # does not respond to the delegated method, +nil+ is returned.
+  # +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 # raises NoMethodError: undefined method `age'
+  #   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:
@@ -147,36 +151,32 @@ class Module
   #   Foo.new("Bar").name # raises NoMethodError: undefined method `name'
   #
   # The target method must be public, otherwise it will raise +NoMethodError+.
-  #
-  def delegate(*methods)
-    options = methods.pop
-    unless options.is_a?(Hash) && to = options[: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).'
+  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
 
-    prefix, allow_nil = options.values_at(:prefix, :allow_nil)
-
-    if prefix == true && to =~ /^[^a-z_]/
-      raise ArgumentError, 'Can only automatically set the delegation prefix when delegating to a method.'
+    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
 
-    file, line = caller.first.split(':', 2)
-    line = line.to_i
+    location = caller_locations(1, 1).first
+    file, line = location.path, location.lineno
 
     to = to.to_s
-    to = "self.#{to}" if RUBY_RESERVED_WORDS.include?(to)
+    to = "self.#{to}" if DELEGATION_RESERVED_METHOD_NAMES.include?(to)
 
-    methods.each do |method|
+    methods.map do |method|
       # Attribute writer methods only accept one argument. Makes sure []=
       # methods still accept two arguments.
-      definition = (method =~ /[^\]]=$/) ? 'arg' : '*args, &block'
+      definition = /[^\]]=$/.match?(method) ? "arg" : "*args, &block"
 
       # The following generated method calls the target exactly once, storing
       # the returned value in a dummy variable.
@@ -193,7 +193,7 @@ class Module
           "  _.#{method}(#{definition})",
           "end",
         "end"
-        ].join ';'
+        ].join ";"
       else
         exception = %(raise DelegationError, "#{self}##{method_prefix}#{method} delegated to #{to}.#{method}, but #{to} is nil: \#{self.inspect}")
 
@@ -208,10 +208,80 @@ class Module
           "    raise",
           "  end",
           "end"
-        ].join ';'
+        ].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