rubocop 1.90.0 → 1.92.0

data/lib/rubocop/cop/layout/space_inside_block_braces.rb

@@ -153,7 +153,7 @@ module RuboCop
           else
             column = node.source_range.column
             return if multiline_block?(left_brace, right_brace) &&
-                      aligned_braces?(inner, right_brace, column)
+                      aligned_braces?(inner, right_brace, column, left_brace)
 
             space_inside_right_brace(inner, right_brace, column)
           end
@@ -163,14 +163,21 @@ module RuboCop
           left_brace.first_line != right_brace.first_line
         end
 
-        def aligned_braces?(inner, right_brace, column)
-          column == right_brace.column || column == inner_last_space_count(inner)
+        def aligned_braces?(inner, right_brace, column, left_brace)
+          column == right_brace.column ||
+            column == inner_last_space_count(inner) ||
+            aligned_with_opening_brace_line?(left_brace, right_brace)
         end
 
         def inner_last_space_count(inner)
           inner.split("\n").last.count(' ')
         end
 
+        def aligned_with_opening_brace_line?(left_brace, right_brace)
+          begins_its_line?(right_brace) &&
+            right_brace.column == left_brace.source_line[/\A\s*/].length
+        end
+
         def no_space_inside_left_brace(left_brace, args_delimiter)
           if pipe?(args_delimiter)
             if left_brace.end_pos == args_delimiter.begin_pos &&
@@ -197,9 +204,7 @@ module RuboCop
                       'Space between { and | detected.')
             end
           else
-            brace_with_space = range_with_surrounding_space(left_brace, side: :right)
-            space(brace_with_space.begin_pos + 1, brace_with_space.end_pos,
-                  'Space inside { detected.')
+            space_after_left_brace(left_brace)
           end
         end
 
@@ -207,6 +212,20 @@ module RuboCop
           args_delimiter&.is?('|')
         end
 
+        def space_after_left_brace(left_brace)
+          brace_with_space = range_with_surrounding_space(left_brace, side: :right)
+          return if brace_with_space.source.match?(/\R/)
+          return if comment_at?(brace_with_space.end_pos)
+
+          space(
+            brace_with_space.begin_pos + 1, brace_with_space.end_pos, 'Space inside { detected.'
+          )
+        end
+
+        def comment_at?(pos)
+          processed_source.comments.any? { |comment| comment.source_range.begin_pos == pos }
+        end
+
         def space_inside_right_brace(inner, right_brace, column)
           brace_with_space = range_with_surrounding_space(right_brace, side: :left)
           begin_pos = brace_with_space.begin_pos
@@ -216,7 +235,7 @@ module RuboCop
             begin_pos = end_pos - (right_brace.column - column)
           end
 
-          if inner.end_with?(']')
+          if closing_bracket_on_own_line?(inner)
             end_pos -= 1
             begin_pos = end_pos - (inner_last_space_count(inner) - column)
           end
@@ -224,6 +243,10 @@ module RuboCop
           space(begin_pos, end_pos, 'Space inside } detected.')
         end
 
+        def closing_bracket_on_own_line?(inner)
+          inner[/[^\n]*\z/].match?(/\A\s*\]\z/)
+        end
+
         def no_space(begin_pos, end_pos, msg)
           if style == :space
             offense(begin_pos, end_pos, msg)
@@ -241,7 +264,7 @@ module RuboCop
         end
 
         def offense(begin_pos, end_pos, msg, style_param = 'EnforcedStyle')
-          return if begin_pos > end_pos
+          return if begin_pos >= end_pos
 
           range = range_between(begin_pos, end_pos)
           add_offense(range, message: msg) do |corrector|

data/lib/rubocop/cop/lint/ambiguous_operator.rb

@@ -37,7 +37,7 @@ module RuboCop
                      'should be %<possible>s.'
 
         def self.autocorrect_incompatible_with
-          [Naming::BlockForwarding]
+          [Naming::BlockForwarding, Style::ArgumentsForwarding]
         end
 
         def on_new_investigation

data/lib/rubocop/cop/lint/ambiguous_operator_precedence.rb

@@ -56,7 +56,8 @@ module RuboCop
         end
 
         def on_send(node)
-          return if node.parenthesized?
+          # `foo.*` is a regular method call, not a binary operator.
+          return if node.parenthesized? || node.loc.dot
 
           return unless (parent = node.parent)
           return unless operator?(parent)

data/lib/rubocop/cop/lint/argument_mismatch.rb

@@ -21,7 +21,9 @@ module RuboCop
       #
       # Constructor calls (`Foo.new`) and keyword-argument validation are out of
       # scope: only positional arity of explicitly defined singleton methods is
-      # checked.
+      # checked. `new` is skipped outright, because `Class#new` is not in the
+      # index: any `new` the index does find sits below it in the method
+      # resolution order, where Ruby would never reach it.
       #
       # @example
       #   # Given the project defines:
@@ -45,8 +47,7 @@ module RuboCop
         MSG = 'Wrong number of arguments to `%<method>s` (given %<given>d, expected %<expected>s).'
 
         def on_send(node)
-          return unless project_index
-          return unless node.receiver&.const_type?
+          return unless checkable_call?(node)
 
           shape = resolved_signature_shape(node)
           return unless shape
@@ -61,6 +62,10 @@ module RuboCop
 
         private
 
+        def checkable_call?(node)
+          project_index && node.receiver&.const_type? && !node.method?(:new)
+        end
+
         def message(node, given, min, max)
           format(MSG, method: node.method_name, given: given, expected: expected_range(min, max))
         end
@@ -77,9 +82,14 @@ module RuboCop
           nil
         end
 
+        # A call with an explicit receiver cannot reach a private method, so its
+        # signature says nothing about the call. This matters because `Object`
+        # closes the singleton ancestry of every constant, and a bare `def` at
+        # the top level of any file — what every block-based DSL produces — is a
+        # private instance method of `Object`.
         def singleton_signature_shape(declaration, method_name)
           member = indexed_singleton_member(declaration, "#{method_name}()")
-          return nil unless member
+          return nil unless member&.public?
 
           indexed_member_shape(member)
         end

data/lib/rubocop/cop/lint/assignment_in_condition.rb

@@ -106,6 +106,8 @@ module RuboCop
         def traverse_node(node, &block)
           # if the node is a block, any assignments are irrelevant
           return if node.any_block_type?
+          # an assignment inside `defined?` is never executed
+          return if node.defined_type?
 
           result = yield node if ASGN_TYPES.include?(node.type)
 

data/lib/rubocop/cop/lint/cop_directive_syntax.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-# rubocop:disable Lint/RedundantCopDisableDirective
-# rubocop:disable Style/DoubleCopDisableDirective
 module RuboCop
   module Cop
     module Lint
@@ -23,12 +21,11 @@ module RuboCop
       #   # good
       #   # rubocop:disable all
       #
-      #   # bad
+      #   # bad - only the first directive takes effect
       #   # rubocop:disable Layout/LineLength # rubocop:disable Style/Encoding
       #
       #   # good
-      #   # rubocop:disable Layout/LineLength
-      #   # rubocop:disable Style/Encoding
+      #   # rubocop:disable Layout/LineLength, Style/Encoding
       #
       #   # bad
       #   # rubocop:wrongmode Layout/LineLength
@@ -55,13 +52,19 @@ module RuboCop
       #   # rubocop:disable Layout/LineLength
       #
       class CopDirectiveSyntax < Base
+        extend AutoCorrector
+
         COMMON_MSG = 'Malformed directive comment detected.'
 
         MISSING_MODE_NAME_MSG = 'The mode name is missing.'
-        INVALID_MODE_NAME_MSG = 'The mode name must be one of `enable`, `disable`, `disable-next`, `todo`, `todo-next`, `push`, or `pop`.' # rubocop:disable Layout/LineLength
+        INVALID_MODE_NAME_MSG = 'The mode name must be one of `enable`, `disable`, `disable-next`, `enable-next`, `todo`, `todo-next`, `next`, `push`, or `pop`.' # rubocop:disable Layout/LineLength -- the message lists every mode and does not wrap
         MISSING_COP_NAME_MSG = 'The cop name is missing.'
+        MULTIPLE_DIRECTIVES_MSG = 'Only the first directive on a line takes effect. ' \
+                                  'List the cop names in a single directive instead.'
         MALFORMED_COP_NAMES_MSG = 'Cop names must be separated by commas. ' \
                                   'Comment in the directive must start with `--`.'
+        INVALID_SIGNED_ARGS_MSG = '`push` and `next` arguments must be `+`- or `-`-prefixed ' \
+                                  'cop names, and `pop` takes no arguments.'
         NEXT_DIRECTIVE_AT_EOL_MSG = 'A `-next` directive must be on its own line, above the ' \
                                     'statement it applies to.'
         INVALID_KEYWORD_MSG = 'The directive keyword must be `rubocop`, not `%<keyword>s`.'
@@ -89,7 +92,11 @@ module RuboCop
         private
 
         def check_directive(comment, directive_comment)
-          if directive_comment.malformed?
+          if (directives = multiple_directives(comment, directive_comment))
+            add_offense(comment, message: "#{COMMON_MSG} #{MULTIPLE_DIRECTIVES_MSG}") do |corrector|
+              merge_directives(corrector, comment, directives)
+            end
+          elsif directive_comment.malformed?
             add_offense(comment, message: offense_message(directive_comment))
           elsif misplaced_next_directive?(directive_comment)
             add_offense(comment, message: NEXT_DIRECTIVE_AT_EOL_MSG)
@@ -98,13 +105,72 @@ module RuboCop
           end
         end
 
-        # An EOL `disable-next` is not honored - it must fail loudly instead
-        # of silently doing nothing.
+        # Everything after the first directive in a comment is trailing text as
+        # far as the parser is concerned, so a second directive written on the
+        # same line disables nothing at all. A valid `--` reason may mention a
+        # directive as plain text, which should not be treated as another one.
+        def multiple_directives(comment, directive_comment)
+          matches = comment.text.to_enum(:scan, DirectiveComment::DIRECTIVE_COMMENT_REGEXP)
+                           .map { Regexp.last_match }
+          matches = filter_reason_matches(matches, directive_comment)
+
+          matches if matches.size > 1
+        end
+
+        def filter_reason_matches(matches, directive_comment)
+          return matches unless directive_comment.reason
+
+          [matches.first, *matches.drop(1).reject { |match| match.post_match.match?(/\S/) }]
+        end
+
+        def merge_directives(corrector, comment, directives)
+          return unless directives_adjacent?(comment, directives)
+          return unless (mode = merged_mode(directives))
+          return unless (cops = merged_cops(directives))
+
+          corrector.replace(comment, "# rubocop:#{mode} #{cops.join(', ')}")
+        end
+
+        # `all` covers every cop already, so folding it into a list of names
+        # would be a rewrite rather than a merge.
+        def merged_cops(directives)
+          cops = directives.flat_map { |match| match[2].to_s.split(',').map(&:strip) }
+          cops = cops.reject(&:empty?).uniq
+          cops unless cops.empty? || cops.include?('all')
+        end
+
+        # Anything written between the directives is a `--` reason or prose,
+        # and merging around it would either move it or drop it.
+        def directives_adjacent?(comment, directives)
+          text = comment.text
+          bounds = directives.map { |match| match.end(0) }
+                             .zip(directives.map { |match| match.begin(0) }[1..] + [text.length])
+          bounds.all? { |from, to| text[from...to].strip.empty? }
+        end
+
+        # `todo` is an alias of `disable`, so those two combine. Anything else
+        # (an `enable` beside a `disable`, or directives of different scopes)
+        # means different things per directive and can't be folded into one.
+        def merged_mode(directives)
+          modes = directives.map { |match| match[1] }.uniq
+          return modes.first if modes.size == 1
+          return modes.first if (modes - %w[disable todo]).empty?
+
+          nil
+        end
+
+        # An EOL next-statement directive is not honored - it must fail
+        # loudly instead of silently doing nothing.
         def misplaced_next_directive?(directive_comment)
-          directive_comment.disable_next? &&
+          next_statement_directive?(directive_comment) &&
             !processed_source.comment_config.comment_only_line?(directive_comment.line_number)
         end
 
+        def next_statement_directive?(directive_comment)
+          directive_comment.disable_next? || directive_comment.enable_next? ||
+            directive_comment.next?
+        end
+
         # rubocop:disable-next Metrics/MethodLength
         def offense_message(directive_comment)
           comment = directive_comment.comment
@@ -116,6 +182,8 @@ module RuboCop
                              INVALID_MODE_NAME_MSG
                            elsif directive_comment.missing_cop_name?
                              MISSING_COP_NAME_MSG
+                           elsif directive_comment.invalid_signed_args?
+                             INVALID_SIGNED_ARGS_MSG
                            else
                              MALFORMED_COP_NAMES_MSG
                            end
@@ -142,10 +210,10 @@ module RuboCop
         end
 
         def unknown_cop_name(directive_comment)
-          return if directive_comment.push? || directive_comment.pop? || directive_comment.all_cops?
+          return if directive_comment.pop? || directive_comment.all_cops?
 
           registry = directive_comment.cop_registry
-          directive_comment.raw_cop_names.find do |name|
+          directive_names(directive_comment).find do |name|
             next false if registry.department?(name)
 
             qualified = registry.qualified_cop_name(name, nil, warn: false)
@@ -153,6 +221,14 @@ module RuboCop
           end
         end
 
+        def directive_names(directive_comment)
+          if directive_comment.push? || directive_comment.next?
+            directive_comment.signed_args.values.flatten
+          else
+            directive_comment.raw_cop_names
+          end
+        end
+
         def unknown_cop_message(directive_comment, name)
           similar = NameSimilarity.find_similar_name(name, directive_comment.cop_registry.names)
           suggestion = similar ? " (did you mean `#{similar}`?)" : ''
@@ -162,5 +238,3 @@ module RuboCop
     end
   end
 end
-# rubocop:enable Lint/RedundantCopDisableDirective
-# rubocop:enable Style/DoubleCopDisableDirective

data/lib/rubocop/cop/lint/duplicate_methods.rb

@@ -435,7 +435,7 @@ module RuboCop
 
         def anon_block_scope_id(anon_block)
           parent = anon_block.parent
-          return unless parent&.type?(:any_block, :begin, :call, :casgn, :any_def)
+          return unless parent&.type?(:any_block, :begin, :call, :casgn, :ivasgn, :any_def)
 
           if (receiver = scope_receiver(parent, anon_block))
             "#{receiver.source}.#{parent.method_name}"

data/lib/rubocop/cop/lint/empty_block.rb

@@ -63,7 +63,7 @@ module RuboCop
       class EmptyBlock < Base
         MSG = 'Empty block detected.'
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler -- an empty block has no parameters to number
           return if node.body
           return if allow_empty_lambdas? && node.lambda_or_proc?
           return if cop_config['AllowComments'] && allow_comment?(node)

data/lib/rubocop/cop/lint/empty_conditional_body.rb

@@ -97,12 +97,14 @@ module RuboCop
         end
 
         def can_simplify_conditional?(node)
-          node.else_branch && node.loc.else.source == 'else'
+          !node.elsif? && node.else_branch && node.loc.else.source == 'else'
         end
 
         def remove_empty_branch(corrector, node)
           range = if empty_if_branch?(node) && else_branch?(node)
                     branch_range(node)
+                  elsif node.condition.last_line == node.loc.else.line
+                    node.source_range.with(end_pos: node.loc.else.begin_pos)
                   else
                     deletion_range(branch_range(node))
                   end

data/lib/rubocop/cop/lint/literal_as_condition.rb

@@ -48,7 +48,7 @@ module RuboCop
           add_offense(node.lhs) do |corrector|
             # Don't autocorrect `'foo' && return` because having `return` as
             # the leftmost node can lead to a void value expression syntax error.
-            next if node.rhs.type?(:return, :break, :next)
+            next if void_value_expression?(node.rhs)
 
             corrector.replace(node, node.rhs.source)
           end
@@ -60,7 +60,7 @@ module RuboCop
           add_offense(node.lhs) do |corrector|
             # Don't autocorrect `'foo' && return` because having `return` as
             # the leftmost node can lead to a void value expression syntax error.
-            next if node.rhs.type?(:return, :break, :next)
+            next if void_value_expression?(node.rhs)
 
             corrector.replace(node, node.rhs.source)
           end
@@ -98,6 +98,8 @@ module RuboCop
             end
           elsif node.condition.falsey_literal?
             add_offense(node.condition) do |corrector|
+              next if orphans_loop_control_keyword?(node)
+
               corrector.replace(node, node.body.child_nodes.map(&:source).join("\n"))
             end
           end
@@ -127,6 +129,8 @@ module RuboCop
             end
           elsif node.condition.truthy_literal?
             add_offense(node.condition) do |corrector|
+              next if orphans_loop_control_keyword?(node)
+
               corrector.replace(node, node.body.child_nodes.map(&:source).join("\n"))
             end
           end
@@ -175,6 +179,21 @@ module RuboCop
 
         private
 
+        # Unwrapping the body of a loop that runs once would leave a `break`,
+        # `next` or `redo` that belongs to it outside of any loop.
+        def orphans_loop_control_keyword?(node)
+          node.body.each_node(:next, :break, :redo).any? do |control|
+            inner = control.each_ancestor.take_while { |ancestor| !ancestor.equal?(node) }
+            inner.none? { |ancestor| ancestor.any_block_type? || ancestor.loop_keyword? }
+          end
+        end
+
+        def void_value_expression?(node)
+          node = node.children.last while node&.begin_type?
+
+          node&.type?(:return, :break, :next)
+        end
+
         def check_for_literal(node)
           cond = condition(node)
           if cond.literal?
@@ -267,6 +286,8 @@ module RuboCop
                        "#{node.else_branch.source.sub('elsif', 'if')}\nend"
                      elsif node.else? || node.ternary?
                        node.else_branch.source
+                     elsif node.value_used?
+                       'nil'
                      else
                        '' # Equivalent to removing the node
                      end

data/lib/rubocop/cop/lint/literal_in_interpolation.rb

@@ -24,30 +24,16 @@ module RuboCop
         MSG = 'Literal interpolation detected.'
         COMPOSITE = %i[array hash pair irange erange].freeze
 
-        # rubocop:disable-next Metrics/AbcSize
         def on_interpolation(begin_node)
           final_node = begin_node.children.last
           return unless offending?(final_node)
-
-          # %W and %I split the content into words before expansion
-          # treating each interpolation as a word component, so
-          # interpolation should not be removed if the expanded value
-          # contains a space character.
-          expanded_value = autocorrected_value(final_node)
-          expanded_value = handle_special_regexp_chars(begin_node, expanded_value)
-
-          return if in_array_percent_literal?(begin_node) && /\s|\A\z/.match?(expanded_value)
+          return unless (expanded_value = correctable_value(begin_node, final_node))
 
           add_offense(final_node) do |corrector|
             next if final_node.dstr_type? # nested, fixed in next iteration
+            next if follows_literal_interpolation?(begin_node)
 
-            replacement = if final_node.str_type? && !final_node.value.valid_encoding?
-                            final_node.source.delete_prefix('"').delete_suffix('"')
-                          else
-                            expanded_value
-                          end
-
-            corrector.replace(final_node.parent, replacement)
+            corrector.replace(final_node.parent, replacement(final_node, expanded_value))
           end
         end
 
@@ -73,6 +59,22 @@ module RuboCop
           node.array_type? && grandparent.regexp_type?
         end
 
+        def correctable_value(begin_node, final_node)
+          value = autocorrected_value(final_node)
+          value = handle_special_regexp_chars(begin_node, value)
+          return if starts_interpolation_after_hash_sign?(begin_node, value)
+
+          value = escape_trailing_hash_sign(begin_node, value)
+
+          # %W and %I split the content into words before expansion
+          # treating each interpolation as a word component, so
+          # interpolation should not be removed if the expanded value
+          # contains a space character.
+          return if in_array_percent_literal?(begin_node) && /\s|\A\z/.match?(value)
+
+          value
+        end
+
         # rubocop:disable-next Metrics/MethodLength, Metrics/CyclomaticComplexity
         def autocorrected_value(node)
           case node.type
@@ -116,6 +118,17 @@ module RuboCop
           end
         end
 
+        def starts_interpolation_after_hash_sign?(begin_node, value)
+          source = processed_source.buffer.source
+          range = begin_node.source_range
+          # Removing an empty value puts the `#` right before what follows the interpolation.
+          following = "#{value}#{source[range.end_pos]}"
+          return false unless following.start_with?('{', '@', '$')
+          return false unless source[range.begin_pos - 1] == '#'
+
+          unescaped_hash_sign?(source[0...range.begin_pos])
+        end
+
         def autocorrected_value_for_string(node)
           return node.source.delete_prefix('"').delete_suffix('"') unless node.value.valid_encoding?
 
@@ -180,7 +193,9 @@ module RuboCop
         end
 
         def space_literal?(node)
-          node.str_type? && node.value.valid_encoding? && node.value.blank?
+          # `String#blank?` misses Unicode spaces such as U+3000 that
+          # `Layout/TrailingWhitespace` treats as trailing whitespace.
+          node.str_type? && node.value.valid_encoding? && node.value.match?(/\A[[:space:]]*\z/)
         end
 
         def ends_heredoc_line?(node)
@@ -188,7 +203,8 @@ module RuboCop
           return false unless grandparent&.dstr_type? && grandparent.heredoc?
 
           line = processed_source.lines[node.last_line - 1]
-          line.size == node.loc.last_column + 1
+
+          line.size == node.parent.source_range.last_column
         end
 
         def in_array_percent_literal?(node)
@@ -198,6 +214,34 @@ module RuboCop
           grandparent = parent.parent
           grandparent&.array_type? && grandparent.percent_literal?
         end
+
+        def escape_trailing_hash_sign(begin_node, value)
+          following = processed_source.buffer.source[begin_node.source_range.end_pos]
+          return value unless %w[{ @ $].include?(following) && unescaped_hash_sign?(value)
+
+          "#{value.delete_suffix('#')}\\#"
+        end
+
+        def unescaped_hash_sign?(text)
+          text.end_with?('#') && text.delete_suffix('#')[/\\*\z/].length.even?
+        end
+
+        # Each interpolation is checked against the original source, so correcting it in the
+        # same pass as a preceding one that leaves a `#` (or nothing) could join that `#` and
+        # a `{` from this one. It's left for the next iteration instead.
+        def follows_literal_interpolation?(begin_node)
+          previous = begin_node.left_sibling
+          return false unless previous&.begin_type? && offending?(previous.children.last)
+
+          value = correctable_value(previous, previous.children.last)
+          value && (value.empty? || value.end_with?('#'))
+        end
+
+        def replacement(node, expanded_value)
+          return expanded_value unless node.str_type? && !node.value.valid_encoding?
+
+          node.source.delete_prefix('"').delete_suffix('"')
+        end
       end
     end
   end

data/lib/rubocop/cop/lint/loop.rb

@@ -42,6 +42,8 @@ module RuboCop
       #     break if some_condition
       #   end
       class Loop < Base
+        include Alignment
+        include RangeHelp
         extend AutoCorrector
 
         MSG = 'Use `Kernel#loop` with `break` rather than `begin/end/until`(or `while`).'
@@ -62,7 +64,8 @@ module RuboCop
           add_offense(node.loc.keyword) do |corrector|
             corrector.replace(body.loc.begin, 'loop do')
             corrector.remove(keyword_and_condition_range(node))
-            corrector.insert_before(body.loc.end, build_break_line(node))
+
+            insert_break_line(corrector, node, body)
           end
         end
 
@@ -70,9 +73,28 @@ module RuboCop
           node.body.loc.end.end.join(node.source_range.end)
         end
 
+        def insert_break_line(corrector, node, body)
+          if body.single_line?
+            corrector.replace(space_before_end(body), build_break_line(node))
+          else
+            corrector.insert_before(body.loc.end, build_break_line(node))
+          end
+        end
+
+        def space_before_end(body)
+          range = range_with_surrounding_space(range: body.loc.end, side: :left, newlines: false)
+
+          range.with(end_pos: body.loc.end.begin_pos)
+        end
+
         def build_break_line(node)
           conditional_keyword = node.while_post_type? ? 'unless' : 'if'
-          "break #{conditional_keyword} #{node.condition.source}\n#{indent(node)}"
+          break_line = "break #{conditional_keyword} #{node.condition.source}\n#{indent(node)}"
+          return break_line unless node.body.single_line?
+
+          # A single-line `begin ... end` keeps its body and `end` on one line,
+          # so the `break` has to start a line of its own.
+          "\n#{indent(node, offset: configured_indentation_width)}#{break_line}"
         end
       end
     end