zilla 0.2.0 → 0.2.1

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.46.0/lib/rubocop/cop/layout/multiline_method_argument_line_breaks.rb

@@ -1,104 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Layout
-      # Ensures that each argument in a multi-line method call
-      # starts on a separate line.
-      #
-      # NOTE: This cop does not move the first argument, if you want that to
-      # be on a separate line, see `Layout/FirstMethodArgumentLineBreak`.
-      #
-      # @example AllowMultilineFinalElement: false (default)
-      #
-      #   # bad
-      #   foo(a, b,
-      #     c
-      #   )
-      #
-      #   # bad
-      #   foo(a, b, {
-      #     foo: "bar",
-      #   })
-      #
-      #   # good
-      #   foo(
-      #     a,
-      #     b,
-      #     c
-      #   )
-      #
-      #   # good
-      #   foo(a, b, c)
-      #
-      #   # good
-      #   foo(
-      #     a,
-      #     b,
-      #     {
-      #       foo: "bar",
-      #     }
-      #   )
-      #
-      # @example AllowMultilineFinalElement: true
-      #
-      #   # bad
-      #   foo(a, b,
-      #     c
-      #   )
-      #
-      #   # good
-      #   foo(a, b, {
-      #     foo: "bar",
-      #   })
-      #
-      #   # good
-      #   foo(
-      #     a,
-      #     b,
-      #     c
-      #   )
-      #
-      #   # good
-      #   foo(a, b, c)
-      #
-      #   # good
-      #   foo(
-      #     a,
-      #     b,
-      #     {
-      #       foo: "bar",
-      #     }
-      #   )
-      class MultilineMethodArgumentLineBreaks < Base
-        include MultilineElementLineBreaks
-        extend AutoCorrector
-
-        MSG = 'Each argument in a multi-line method call must start on a separate line.'
-
-        def on_send(node)
-          return if node.method?(:[]=)
-
-          args = node.arguments
-
-          # If there is a trailing hash arg without explicit braces, like this:
-          #
-          #    method(1, 'key1' => value1, 'key2' => value2)
-          #
-          # ...then each key/value pair is treated as a method 'argument'
-          # when determining where line breaks should appear.
-          last_arg = args.last
-          args = args[0...-1] + last_arg.children if last_arg&.hash_type? && !last_arg&.braces?
-
-          check_line_breaks(node, args, ignore_last: ignore_last_element?)
-        end
-
-        private
-
-        def ignore_last_element?
-          !!cop_config['AllowMultilineFinalElement']
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.46.0/lib/rubocop/cop/layout/multiline_method_call_brace_layout.rb

@@ -1,131 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Layout
-      # Checks that the closing brace in a method call is either
-      # on the same line as the last method argument, or a new line.
-      #
-      # When using the `symmetrical` (default) style:
-      #
-      # If a method call's opening brace is on the same line as the first
-      # argument of the call, then the closing brace should be on the same
-      # line as the last argument of the call.
-      #
-      # If an method call's opening brace is on the line above the first
-      # argument of the call, then the closing brace should be on the line
-      # below the last argument of the call.
-      #
-      # When using the `new_line` style:
-      #
-      # The closing brace of a multi-line method call must be on the line
-      # after the last argument of the call.
-      #
-      # When using the `same_line` style:
-      #
-      # The closing brace of a multi-line method call must be on the same
-      # line as the last argument of the call.
-      #
-      # @example EnforcedStyle: symmetrical (default)
-      #   # bad
-      #   foo(a,
-      #     b
-      #   )
-      #
-      #   # bad
-      #   foo(
-      #     a,
-      #     b)
-      #
-      #   # good
-      #   foo(a,
-      #     b)
-      #
-      #   # good
-      #   foo(
-      #     a,
-      #     b
-      #   )
-      #
-      # @example EnforcedStyle: new_line
-      #   # bad
-      #   foo(
-      #     a,
-      #     b)
-      #
-      #   # bad
-      #   foo(a,
-      #     b)
-      #
-      #   # good
-      #   foo(a,
-      #     b
-      #   )
-      #
-      #   # good
-      #   foo(
-      #     a,
-      #     b
-      #   )
-      #
-      # @example EnforcedStyle: same_line
-      #   # bad
-      #   foo(a,
-      #     b
-      #   )
-      #
-      #   # bad
-      #   foo(
-      #     a,
-      #     b
-      #   )
-      #
-      #   # good
-      #   foo(
-      #     a,
-      #     b)
-      #
-      #   # good
-      #   foo(a,
-      #     b)
-      class MultilineMethodCallBraceLayout < Base
-        include MultilineLiteralBraceLayout
-        extend AutoCorrector
-
-        SAME_LINE_MESSAGE = 'Closing method call brace must be on the ' \
-                            'same line as the last argument when opening brace is on the same ' \
-                            'line as the first argument.'
-
-        NEW_LINE_MESSAGE = 'Closing method call brace must be on the ' \
-                           'line after the last argument when opening brace is on a separate ' \
-                           'line from the first argument.'
-
-        ALWAYS_NEW_LINE_MESSAGE = 'Closing method call brace must be on ' \
-                                  'the line after the last argument.'
-
-        ALWAYS_SAME_LINE_MESSAGE = 'Closing method call brace must be on ' \
-                                   'the same line as the last argument.'
-
-        def on_send(node)
-          check_brace_layout(node)
-        end
-
-        private
-
-        def children(node)
-          node.arguments
-        end
-
-        def ignored_literal?(node)
-          single_line_ignoring_receiver?(node) || super
-        end
-
-        def single_line_ignoring_receiver?(node)
-          return false unless node.loc.begin && node.loc.end
-
-          node.loc.begin.line == node.loc.end.line
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.46.0/lib/rubocop/cop/layout/multiline_method_call_indentation.rb

@@ -1,248 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Layout
-      # Checks the indentation of the method name part in method calls
-      # that span more than one line.
-      #
-      # @example EnforcedStyle: aligned (default)
-      #   # bad
-      #   while myvariable
-      #   .b
-      #     # do something
-      #   end
-      #
-      #   # good
-      #   while myvariable
-      #         .b
-      #     # do something
-      #   end
-      #
-      #   # good
-      #   Thing.a
-      #        .b
-      #        .c
-      #
-      # @example EnforcedStyle: indented
-      #   # good
-      #   while myvariable
-      #     .b
-      #
-      #     # do something
-      #   end
-      #
-      # @example EnforcedStyle: indented_relative_to_receiver
-      #   # good
-      #   while myvariable
-      #           .a
-      #           .b
-      #
-      #     # do something
-      #   end
-      #
-      #   # good
-      #   myvariable = Thing
-      #                  .a
-      #                  .b
-      #                  .c
-      class MultilineMethodCallIndentation < Base
-        include ConfigurableEnforcedStyle
-        include Alignment
-        include MultilineExpressionIndentation
-        extend AutoCorrector
-
-        def validate_config
-          return unless style == :aligned && cop_config['IndentationWidth']
-
-          raise ValidationError,
-                'The `Layout/MultilineMethodCallIndentation` ' \
-                'cop only accepts an `IndentationWidth` ' \
-                'configuration parameter when ' \
-                '`EnforcedStyle` is `indented`.'
-        end
-
-        private
-
-        def autocorrect(corrector, node)
-          AlignmentCorrector.correct(corrector, processed_source, node, @column_delta)
-        end
-
-        def relevant_node?(send_node)
-          send_node.loc.dot # Only check method calls with dot operator
-        end
-
-        def right_hand_side(send_node)
-          dot = send_node.loc.dot
-          selector = send_node.loc.selector
-          if send_node.dot? && selector && same_line?(dot, selector)
-            dot.join(selector)
-          elsif selector
-            selector
-          elsif send_node.implicit_call?
-            dot.join(send_node.loc.begin)
-          end
-        end
-
-        def offending_range(node, lhs, rhs, given_style)
-          return false unless begins_its_line?(rhs)
-          return false if not_for_this_cop?(node)
-
-          @base = alignment_base(node, rhs, given_style)
-          correct_column = if @base
-                             @base.column + extra_indentation(given_style, node.parent)
-                           else
-                             indentation(lhs) + correct_indentation(node)
-                           end
-          @column_delta = correct_column - rhs.column
-          rhs if @column_delta.nonzero?
-        end
-
-        def extra_indentation(given_style, parent)
-          if given_style == :indented_relative_to_receiver
-            if parent && (parent.splat_type? || parent.kwsplat_type?)
-              configured_indentation_width - parent.loc.operator.length
-            else
-              configured_indentation_width
-            end
-          else
-            0
-          end
-        end
-
-        def message(node, lhs, rhs)
-          if should_indent_relative_to_receiver?
-            relative_to_receiver_message(rhs)
-          elsif should_align_with_base?
-            align_with_base_message(rhs)
-          else
-            no_base_message(lhs, rhs, node)
-          end
-        end
-
-        def should_indent_relative_to_receiver?
-          @base && style == :indented_relative_to_receiver
-        end
-
-        def should_align_with_base?
-          @base && style != :indented_relative_to_receiver
-        end
-
-        def relative_to_receiver_message(rhs)
-          "Indent `#{rhs.source}` #{configured_indentation_width} spaces " \
-            "more than `#{base_source}` on line #{@base.line}."
-        end
-
-        def align_with_base_message(rhs)
-          "Align `#{rhs.source}` with `#{base_source}` on line #{@base.line}."
-        end
-
-        def base_source
-          @base.source[/[^\n]*/]
-        end
-
-        def no_base_message(lhs, rhs, node)
-          used_indentation = rhs.column - indentation(lhs)
-          what = operation_description(node, rhs)
-
-          "Use #{correct_indentation(node)} (not #{used_indentation}) " \
-            "spaces for indenting #{what} spanning multiple lines."
-        end
-
-        def alignment_base(node, rhs, given_style)
-          case given_style
-          when :aligned
-            semantic_alignment_base(node, rhs) || syntactic_alignment_base(node, rhs)
-          when :indented
-            nil
-          when :indented_relative_to_receiver
-            receiver_alignment_base(node)
-          end
-        end
-
-        def syntactic_alignment_base(lhs, rhs)
-          # a if b
-          #      .c
-          kw_node_with_special_indentation(lhs) do |base|
-            return indented_keyword_expression(base).source_range
-          end
-
-          # a = b
-          #     .c
-          part_of_assignment_rhs(lhs, rhs) { |base| return assignment_rhs(base).source_range }
-
-          # a + b
-          #     .c
-          operation_rhs(lhs) { |base| return base.source_range }
-        end
-
-        # a.b
-        #  .c
-        def semantic_alignment_base(node, rhs)
-          return unless rhs.source.start_with?('.')
-
-          node = semantic_alignment_node(node)
-          return unless node&.loc&.selector
-
-          node.loc.dot.join(node.loc.selector)
-        end
-
-        # a
-        #   .b
-        #   .c
-        def receiver_alignment_base(node)
-          node = node.receiver while node.receiver
-          node = node.parent
-          node = node.parent until node.loc.dot
-
-          node&.receiver&.source_range
-        end
-
-        def semantic_alignment_node(node)
-          return if argument_in_method_call(node, :with_parentheses)
-
-          dot_right_above = get_dot_right_above(node)
-          return dot_right_above if dot_right_above
-
-          node = first_call_has_a_dot(node)
-          return if node.loc.dot.line != node.first_line
-
-          node
-        end
-
-        def get_dot_right_above(node)
-          node.each_ancestor.find do |a|
-            dot = a.loc.respond_to?(:dot) && a.loc.dot
-            next unless dot
-
-            dot.line == node.loc.dot.line - 1 && dot.column == node.loc.dot.column
-          end
-        end
-
-        def first_call_has_a_dot(node)
-          # descend to root of method chain
-          node = node.receiver while node.receiver
-          # ascend to first call which has a dot
-          node = node.parent
-          node = node.parent until node.loc.respond_to?(:dot) && node.loc.dot
-
-          node
-        end
-
-        def operation_rhs(node)
-          operation_rhs = node.receiver.each_ancestor(:send).find do |rhs|
-            operator_rhs?(rhs, node.receiver)
-          end
-
-          return unless operation_rhs
-
-          yield operation_rhs.first_argument
-        end
-
-        def operator_rhs?(node, receiver)
-          node.operator_method? && node.arguments? && within_node?(receiver, node.first_argument)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.46.0/lib/rubocop/cop/layout/multiline_method_definition_brace_layout.rb

@@ -1,128 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Layout
-      # Checks that the closing brace in a method definition is either
-      # on the same line as the last method parameter, or a new line.
-      #
-      # When using the `symmetrical` (default) style:
-      #
-      # If a method definition's opening brace is on the same line as the
-      # first parameter of the definition, then the closing brace should be
-      # on the same line as the last parameter of the definition.
-      #
-      # If an method definition's opening brace is on the line above the first
-      # parameter of the definition, then the closing brace should be on the
-      # line below the last parameter of the definition.
-      #
-      # When using the `new_line` style:
-      #
-      # The closing brace of a multi-line method definition must be on the line
-      # after the last parameter of the definition.
-      #
-      # When using the `same_line` style:
-      #
-      # The closing brace of a multi-line method definition must be on the same
-      # line as the last parameter of the definition.
-      #
-      # @example EnforcedStyle: symmetrical (default)
-      #   # bad
-      #   def foo(a,
-      #     b
-      #   )
-      #   end
-      #
-      #   # bad
-      #   def foo(
-      #     a,
-      #     b)
-      #   end
-      #
-      #   # good
-      #   def foo(a,
-      #     b)
-      #   end
-      #
-      #   # good
-      #   def foo(
-      #     a,
-      #     b
-      #   )
-      #   end
-      #
-      # @example EnforcedStyle: new_line
-      #   # bad
-      #   def foo(
-      #     a,
-      #     b)
-      #   end
-      #
-      #   # bad
-      #   def foo(a,
-      #     b)
-      #   end
-      #
-      #   # good
-      #   def foo(a,
-      #     b
-      #   )
-      #   end
-      #
-      #   # good
-      #   def foo(
-      #     a,
-      #     b
-      #   )
-      #   end
-      #
-      # @example EnforcedStyle: same_line
-      #   # bad
-      #   def foo(a,
-      #     b
-      #   )
-      #   end
-      #
-      #   # bad
-      #   def foo(
-      #     a,
-      #     b
-      #   )
-      #   end
-      #
-      #   # good
-      #   def foo(
-      #     a,
-      #     b)
-      #   end
-      #
-      #   # good
-      #   def foo(a,
-      #     b)
-      #   end
-      class MultilineMethodDefinitionBraceLayout < Base
-        include MultilineLiteralBraceLayout
-        extend AutoCorrector
-
-        SAME_LINE_MESSAGE = 'Closing method definition brace must be on the ' \
-                            'same line as the last parameter when opening brace is on the same ' \
-                            'line as the first parameter.'
-
-        NEW_LINE_MESSAGE = 'Closing method definition brace must be on the ' \
-                           'line after the last parameter when opening brace is on a separate ' \
-                           'line from the first parameter.'
-
-        ALWAYS_NEW_LINE_MESSAGE = 'Closing method definition brace must be ' \
-                                  'on the line after the last parameter.'
-
-        ALWAYS_SAME_LINE_MESSAGE = 'Closing method definition brace must be ' \
-                                   'on the same line as the last parameter.'
-
-        def on_def(node)
-          check_brace_layout(node.arguments)
-        end
-        alias on_defs on_def
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.46.0/lib/rubocop/cop/layout/multiline_method_parameter_line_breaks.rb

@@ -1,101 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Layout
-      # Ensures that each parameter in a multi-line method definition
-      # starts on a separate line.
-      #
-      # NOTE: This cop does not move the first argument, if you want that to
-      # be on a separate line, see `Layout/FirstMethodParameterLineBreak`.
-      #
-      # @example AllowMultilineFinalElement: false (default)
-      #
-      #   # bad
-      #   def foo(a, b,
-      #     c
-      #   )
-      #   end
-      #
-      #   # bad
-      #   def foo(a, b = {
-      #     foo: "bar",
-      #   })
-      #   end
-      #
-      #   # good
-      #   def foo(
-      #     a,
-      #     b,
-      #     c
-      #   )
-      #   end
-      #
-      #   # good
-      #   def foo(
-      #     a,
-      #     b = {
-      #       foo: "bar",
-      #     }
-      #   )
-      #   end
-      #
-      #   # good
-      #   def foo(a, b, c)
-      #   end
-      #
-      # @example AllowMultilineFinalElement: true
-      #
-      #   # bad
-      #   def foo(a, b,
-      #     c
-      #   )
-      #   end
-      #
-      #   # good
-      #   def foo(a, b = {
-      #     foo: "bar",
-      #   })
-      #   end
-      #
-      #   # good
-      #   def foo(
-      #     a,
-      #     b,
-      #     c
-      #   )
-      #   end
-      #
-      #   # good
-      #   def foo(
-      #     a,
-      #     b = {
-      #       foo: "bar",
-      #     }
-      #   )
-      #   end
-      #
-      #   # good
-      #   def foo(a, b, c)
-      #   end
-      class MultilineMethodParameterLineBreaks < Base
-        include MultilineElementLineBreaks
-        extend AutoCorrector
-
-        MSG = 'Each parameter in a multi-line method definition must start on a separate line.'
-
-        def on_def(node)
-          return if node.arguments.empty?
-
-          check_line_breaks(node, node.arguments, ignore_last: ignore_last_element?)
-        end
-
-        private
-
-        def ignore_last_element?
-          !!cop_config['AllowMultilineFinalElement']
-        end
-      end
-    end
-  end
-end