study_line 0.2.7 → 0.2.8

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.60.0/lib/rubocop/cop/layout/first_argument_indentation.rb

@@ -1,287 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Layout
-      # Checks the indentation of the first argument in a method call.
-      # Arguments after the first one are checked by `Layout/ArgumentAlignment`,
-      # not by this cop.
-      #
-      # For indenting the first parameter of method _definitions_, check out
-      # `Layout/FirstParameterIndentation`.
-      #
-      # This cop will respect `Layout/ArgumentAlignment` and will not work when
-      # `EnforcedStyle: with_fixed_indentation` is specified for `Layout/ArgumentAlignment`.
-      #
-      # @example
-      #
-      #   # bad
-      #   some_method(
-      #   first_param,
-      #   second_param)
-      #
-      #   foo = some_method(
-      #   first_param,
-      #   second_param)
-      #
-      #   foo = some_method(nested_call(
-      #   nested_first_param),
-      #   second_param)
-      #
-      #   foo = some_method(
-      #   nested_call(
-      #   nested_first_param),
-      #   second_param)
-      #
-      #   some_method nested_call(
-      #   nested_first_param),
-      #   second_param
-      #
-      # @example EnforcedStyle: special_for_inner_method_call_in_parentheses (default)
-      #   # Same as `special_for_inner_method_call` except that the special rule
-      #   # only applies if the outer method call encloses its arguments in
-      #   # parentheses.
-      #
-      #   # good
-      #   some_method(
-      #     first_param,
-      #   second_param)
-      #
-      #   foo = some_method(
-      #     first_param,
-      #   second_param)
-      #
-      #   foo = some_method(nested_call(
-      #                       nested_first_param),
-      #   second_param)
-      #
-      #   foo = some_method(
-      #     nested_call(
-      #       nested_first_param),
-      #   second_param)
-      #
-      #   some_method nested_call(
-      #     nested_first_param),
-      #   second_param
-      #
-      # @example EnforcedStyle: consistent
-      #   # The first argument should always be indented one step more than the
-      #   # preceding line.
-      #
-      #   # good
-      #   some_method(
-      #     first_param,
-      #   second_param)
-      #
-      #   foo = some_method(
-      #     first_param,
-      #   second_param)
-      #
-      #   foo = some_method(nested_call(
-      #     nested_first_param),
-      #   second_param)
-      #
-      #   foo = some_method(
-      #     nested_call(
-      #       nested_first_param),
-      #   second_param)
-      #
-      #   some_method nested_call(
-      #     nested_first_param),
-      #   second_param
-      #
-      # @example EnforcedStyle: consistent_relative_to_receiver
-      #   # The first argument should always be indented one level relative to
-      #   # the parent that is receiving the argument
-      #
-      #   # good
-      #   some_method(
-      #     first_param,
-      #   second_param)
-      #
-      #   foo = some_method(
-      #           first_param,
-      #   second_param)
-      #
-      #   foo = some_method(nested_call(
-      #                       nested_first_param),
-      #   second_param)
-      #
-      #   foo = some_method(
-      #           nested_call(
-      #             nested_first_param),
-      #   second_param)
-      #
-      #   some_method nested_call(
-      #                 nested_first_param),
-      #   second_params
-      #
-      # @example EnforcedStyle: special_for_inner_method_call
-      #   # The first argument should normally be indented one step more than
-      #   # the preceding line, but if it's a argument for a method call that
-      #   # is itself a argument in a method call, then the inner argument
-      #   # should be indented relative to the inner method.
-      #
-      #   # good
-      #   some_method(
-      #     first_param,
-      #   second_param)
-      #
-      #   foo = some_method(
-      #     first_param,
-      #   second_param)
-      #
-      #   foo = some_method(nested_call(
-      #                       nested_first_param),
-      #   second_param)
-      #
-      #   foo = some_method(
-      #     nested_call(
-      #       nested_first_param),
-      #   second_param)
-      #
-      #   some_method nested_call(
-      #                 nested_first_param),
-      #   second_param
-      #
-      class FirstArgumentIndentation < Base
-        include Alignment
-        include ConfigurableEnforcedStyle
-        include RangeHelp
-        extend AutoCorrector
-
-        MSG = 'Indent the first argument one step more than %<base>s.'
-
-        def on_send(node)
-          return unless should_check?(node)
-          return if same_line?(node, node.first_argument)
-          return if style != :consistent && enforce_first_argument_with_fixed_indentation? &&
-                    !enable_layout_first_method_argument_line_break?
-
-          indent = base_indentation(node) + configured_indentation_width
-
-          check_alignment([node.first_argument], indent)
-        end
-        alias on_csend on_send
-        alias on_super on_send
-
-        private
-
-        def should_check?(node)
-          node.arguments? && !bare_operator?(node) && !node.setter_method?
-        end
-
-        def autocorrect(corrector, node)
-          AlignmentCorrector.correct(corrector, processed_source, node, column_delta)
-        end
-
-        def bare_operator?(node)
-          node.operator_method? && !node.dot?
-        end
-
-        def message(arg_node)
-          return 'Bad indentation of the first argument.' unless arg_node
-
-          send_node = arg_node.parent
-          text = base_range(send_node, arg_node).source.strip
-          base = if !text.include?("\n") && special_inner_call_indentation?(send_node)
-                   "`#{text}`"
-                 elsif comment_line?(text.lines.reverse_each.first)
-                   'the start of the previous line (not counting the comment)'
-                 else
-                   'the start of the previous line'
-                 end
-
-          format(MSG, base: base)
-        end
-
-        def base_indentation(node)
-          if special_inner_call_indentation?(node)
-            column_of(base_range(node, node.first_argument))
-          else
-            previous_code_line(node.first_argument.first_line) =~ /\S/
-          end
-        end
-
-        def special_inner_call_indentation?(node)
-          return false if style == :consistent
-          return true  if style == :consistent_relative_to_receiver
-
-          parent = node.parent
-
-          return false unless eligible_method_call?(parent)
-          return false if !parent.parenthesized? &&
-                          style == :special_for_inner_method_call_in_parentheses
-
-          # The node must begin inside the parent, otherwise node is the first
-          # part of a chained method call.
-          node.source_range.begin_pos > parent.source_range.begin_pos
-        end
-
-        # @!method eligible_method_call?(node)
-        def_node_matcher :eligible_method_call?, <<~PATTERN
-          (send _ !:[]= ...)
-        PATTERN
-
-        def base_range(send_node, arg_node)
-          parent = send_node.parent
-          start_node = if parent && (parent.splat_type? || parent.kwsplat_type?)
-                         send_node.parent
-                       else
-                         send_node
-                       end
-          range_between(start_node.source_range.begin_pos, arg_node.source_range.begin_pos)
-        end
-
-        # Returns the column of the given range. For single line ranges, this
-        # is simple. For ranges with line breaks, we look a the last code line.
-        def column_of(range)
-          source = range.source.strip
-          if source.include?("\n")
-            previous_code_line(range.line + source.count("\n") + 1) =~ /\S/
-          else
-            display_column(range)
-          end
-        end
-
-        # Takes the line number of a given code line and returns a string
-        # containing the previous line that's not a comment line or a blank
-        # line.
-        def previous_code_line(line_number)
-          line = ''
-          while line.blank? || comment_lines.include?(line_number)
-            line_number -= 1
-            line = processed_source.lines[line_number - 1]
-          end
-          line
-        end
-
-        def comment_lines
-          @comment_lines ||=
-            processed_source
-            .comments
-            .select { |c| begins_its_line?(c.source_range) }
-            .map { |c| c.loc.line }
-        end
-
-        def on_new_investigation
-          @comment_lines = nil
-        end
-
-        def enforce_first_argument_with_fixed_indentation?
-          return false unless argument_alignment_config['Enabled']
-
-          argument_alignment_config['EnforcedStyle'] == 'with_fixed_indentation'
-        end
-
-        def enable_layout_first_method_argument_line_break?
-          config.for_cop('Layout/FirstMethodArgumentLineBreak')['Enabled']
-        end
-
-        def argument_alignment_config
-          config.for_cop('Layout/ArgumentAlignment')
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.60.0/lib/rubocop/cop/layout/first_array_element_indentation.rb

@@ -1,195 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Layout
-      # Checks the indentation of the first element in an array literal
-      # where the opening bracket and the first element are on separate lines.
-      # The other elements' indentations are handled by `Layout/ArrayAlignment` cop.
-      #
-      # This cop will respect `Layout/ArrayAlignment` and will not work when
-      # `EnforcedStyle: with_fixed_indentation` is specified for `Layout/ArrayAlignment`.
-      #
-      # By default, array literals that are arguments in a method call with
-      # parentheses, and where the opening square bracket of the array is on the
-      # same line as the opening parenthesis of the method call, shall have
-      # their first element indented one step (two spaces) more than the
-      # position inside the opening parenthesis.
-      #
-      # Other array literals shall have their first element indented one step
-      # more than the start of the line where the opening square bracket is.
-      #
-      # This default style is called 'special_inside_parentheses'. Alternative
-      # styles are 'consistent' and 'align_brackets'. Here are examples:
-      #
-      # @example EnforcedStyle: special_inside_parentheses (default)
-      #   # The `special_inside_parentheses` style enforces that the first
-      #   # element in an array literal where the opening bracket and first
-      #   # element are on separate lines is indented one step (two spaces) more
-      #   # than the position inside the opening parenthesis.
-      #
-      #   # bad
-      #   array = [
-      #     :value
-      #   ]
-      #   and_in_a_method_call([
-      #     :no_difference
-      #                        ])
-      #
-      #   # good
-      #   array = [
-      #     :value
-      #   ]
-      #   but_in_a_method_call([
-      #                          :its_like_this
-      #                        ])
-      #
-      # @example EnforcedStyle: consistent
-      #   # The `consistent` style enforces that the first element in an array
-      #   # literal where the opening bracket and the first element are on
-      #   # separate lines is indented the same as an array literal which is not
-      #   # defined inside a method call.
-      #
-      #   # bad
-      #   # consistent
-      #   array = [
-      #     :value
-      #   ]
-      #   but_in_a_method_call([
-      #                          :its_like_this
-      #   ])
-      #
-      #   # good
-      #   array = [
-      #     :value
-      #   ]
-      #   and_in_a_method_call([
-      #     :no_difference
-      #   ])
-      #
-      # @example EnforcedStyle: align_brackets
-      #   # The `align_brackets` style enforces that the opening and closing
-      #   # brackets are indented to the same position.
-      #
-      #   # bad
-      #   # align_brackets
-      #   and_now_for_something = [
-      #                             :completely_different
-      #   ]
-      #
-      #   # good
-      #   # align_brackets
-      #   and_now_for_something = [
-      #                             :completely_different
-      #                           ]
-      class FirstArrayElementIndentation < Base
-        include Alignment
-        include ConfigurableEnforcedStyle
-        include MultilineElementIndentation
-        extend AutoCorrector
-
-        MSG = 'Use %<configured_indentation_width>d spaces for indentation ' \
-              'in an array, relative to %<base_description>s.'
-
-        def on_array(node)
-          check(node, nil) if node.loc.begin
-        end
-
-        def on_send(node)
-          return if style != :consistent && enforce_first_argument_with_fixed_indentation?
-
-          each_argument_node(node, :array) do |array_node, left_parenthesis|
-            check(array_node, left_parenthesis)
-          end
-        end
-        alias on_csend on_send
-
-        private
-
-        def autocorrect(corrector, node)
-          AlignmentCorrector.correct(corrector, processed_source, node, @column_delta)
-        end
-
-        def brace_alignment_style
-          :align_brackets
-        end
-
-        def check(array_node, left_parenthesis)
-          return if ignored_node?(array_node)
-
-          left_bracket = array_node.loc.begin
-          first_elem = array_node.values.first
-          if first_elem
-            return if same_line?(first_elem, left_bracket)
-
-            check_first(first_elem, left_bracket, left_parenthesis, 0)
-          end
-
-          check_right_bracket(array_node.loc.end, first_elem, left_bracket, left_parenthesis)
-        end
-
-        def check_right_bracket(right_bracket, first_elem, left_bracket, left_parenthesis)
-          # if the right bracket is on the same line as the last value, accept
-          return if /\S/.match?(right_bracket.source_line[0...right_bracket.column])
-
-          expected_column, indent_base_type = indent_base(left_bracket, first_elem,
-                                                          left_parenthesis)
-          @column_delta = expected_column - right_bracket.column
-          return if @column_delta.zero?
-
-          msg = message_for_right_bracket(indent_base_type)
-          add_offense(right_bracket, message: msg) do |corrector|
-            autocorrect(corrector, right_bracket)
-          end
-        end
-
-        # Returns the description of what the correct indentation is based on.
-        def base_description(indent_base_type)
-          case indent_base_type
-          when :left_brace_or_bracket
-            'the position of the opening bracket'
-          when :first_column_after_left_parenthesis
-            'the first position after the preceding left parenthesis'
-          when :parent_hash_key
-            'the parent hash key'
-          else
-            'the start of the line where the left square bracket is'
-          end
-        end
-
-        def message(base_description)
-          format(
-            MSG,
-            configured_indentation_width: configured_indentation_width,
-            base_description: base_description
-          )
-        end
-
-        def message_for_right_bracket(indent_base_type)
-          case indent_base_type
-          when :left_brace_or_bracket
-            'Indent the right bracket the same as the left bracket.'
-          when :first_column_after_left_parenthesis
-            'Indent the right bracket the same as the first position ' \
-            'after the preceding left parenthesis.'
-          when :parent_hash_key
-            'Indent the right bracket the same as the parent hash key.' \
-          else
-            'Indent the right bracket the same as the start of the line ' \
-            'where the left bracket is.'
-          end
-        end
-
-        def enforce_first_argument_with_fixed_indentation?
-          return false unless array_alignment_config['Enabled']
-
-          array_alignment_config['EnforcedStyle'] == 'with_fixed_indentation'
-        end
-
-        def array_alignment_config
-          config.for_cop('Layout/ArrayAlignment')
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.60.0/lib/rubocop/cop/layout/first_array_element_line_break.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Layout
-      # Checks for a line break before the first element in a
-      # multi-line array.
-      #
-      # @example
-      #
-      #   # bad
-      #   [ :a,
-      #     :b]
-      #
-      #   # good
-      #   [
-      #     :a,
-      #     :b]
-      #
-      #   # good
-      #   [:a, :b]
-      #
-      # @example AllowMultilineFinalElement: false (default)
-      #
-      #   # bad
-      #   [ :a, {
-      #     :b => :c
-      #   }]
-      #
-      #   # good
-      #   [
-      #     :a, {
-      #     :b => :c
-      #   }]
-      #
-      # @example AllowMultilineFinalElement: true
-      #
-      #   # good
-      #   [:a, {
-      #     :b => :c
-      #   }]
-      #
-      class FirstArrayElementLineBreak < Base
-        include FirstElementLineBreak
-        extend AutoCorrector
-
-        MSG = 'Add a line break before the first element of a multi-line array.'
-
-        def on_array(node)
-          return if !node.loc.begin && !assignment_on_same_line?(node)
-
-          check_children_line_break(node, node.children, ignore_last: ignore_last_element?)
-        end
-
-        private
-
-        def assignment_on_same_line?(node)
-          source = node.source_range.source_line[0...node.loc.column]
-          /\s*=\s*$/.match?(source)
-        end
-
-        def ignore_last_element?
-          !!cop_config['AllowMultilineFinalElement']
-        end
-      end
-    end
-  end
-end