study_line 0.1.6 → 0.2.1

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.57.2/lib/rubocop/cop/layout/extra_spacing.rb

@@ -1,191 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Layout
-      # Checks for extra/unnecessary whitespace.
-      #
-      # @example
-      #
-      #   # good if AllowForAlignment is true
-      #   name      = "RuboCop"
-      #   # Some comment and an empty line
-      #
-      #   website  += "/rubocop/rubocop" unless cond
-      #   puts        "rubocop"          if     debug
-      #
-      #   # bad for any configuration
-      #   set_app("RuboCop")
-      #   website  = "https://github.com/rubocop/rubocop"
-      #
-      #   # good only if AllowBeforeTrailingComments is true
-      #   object.method(arg)  # this is a comment
-      #
-      #   # good even if AllowBeforeTrailingComments is false or not set
-      #   object.method(arg) # this is a comment
-      #
-      #   # good with either AllowBeforeTrailingComments or AllowForAlignment
-      #   object.method(arg)         # this is a comment
-      #   another_object.method(arg) # this is another comment
-      #   some_object.method(arg)    # this is some comment
-      class ExtraSpacing < Base
-        extend AutoCorrector
-        include PrecedingFollowingAlignment
-        include RangeHelp
-
-        MSG_UNNECESSARY = 'Unnecessary spacing detected.'
-        MSG_UNALIGNED_ASGN = '`=` is not aligned with the %<location>s assignment.'
-
-        def on_new_investigation
-          return if processed_source.blank?
-
-          @aligned_comments = aligned_locations(processed_source.comments.map(&:loc))
-          @corrected = Set.new if force_equal_sign_alignment?
-
-          processed_source.tokens.each_cons(2) do |token1, token2|
-            check_tokens(processed_source.ast, token1, token2)
-          end
-        end
-
-        private
-
-        def aligned_locations(locs) # rubocop:disable Metrics/AbcSize
-          return [] if locs.empty?
-
-          aligned = Set[locs.first.line, locs.last.line]
-          locs.each_cons(3) do |before, loc, after|
-            col = loc.column
-            aligned << loc.line if col == before.column || col == after.column
-          end
-
-          # if locs.size > 2 and the size of variable `aligned`
-          # has not increased from its initial value, there are not aligned lines.
-          return [] if locs.size > 2 && aligned.size == 2
-
-          aligned
-        end
-
-        def check_tokens(ast, token1, token2)
-          return if token2.type == :tNL
-
-          if force_equal_sign_alignment? && assignment_tokens.include?(token2)
-            check_assignment(token2)
-          else
-            check_other(token1, token2, ast)
-          end
-        end
-
-        def check_assignment(token)
-          return unless aligned_with_preceding_assignment(token) == :no
-
-          message = format(MSG_UNALIGNED_ASGN, location: 'preceding')
-          add_offense(token.pos, message: message) do |corrector|
-            align_equal_signs(token.pos, corrector)
-          end
-        end
-
-        def check_other(token1, token2, ast)
-          return false if allow_for_trailing_comments? && token2.text.start_with?('#')
-
-          extra_space_range(token1, token2) do |range|
-            next if ignored_range?(ast, range.begin_pos)
-
-            add_offense(range, message: MSG_UNNECESSARY) { |corrector| corrector.remove(range) }
-          end
-        end
-
-        def extra_space_range(token1, token2)
-          return if token1.line != token2.line
-
-          start_pos = token1.end_pos
-          end_pos = token2.begin_pos - 1
-          return if end_pos <= start_pos
-
-          return if allow_for_alignment? && aligned_tok?(token2)
-
-          yield range_between(start_pos, end_pos)
-        end
-
-        def aligned_tok?(token)
-          if token.comment?
-            @aligned_comments.include?(token.line)
-          else
-            aligned_with_something?(token.pos)
-          end
-        end
-
-        def ignored_range?(ast, start_pos)
-          ignored_ranges(ast).any? { |r| r.include?(start_pos) }
-        end
-
-        # Returns an array of ranges that should not be reported. It's the
-        # extra spaces between the keys and values in a multiline hash,
-        # since those are handled by the Layout/HashAlignment cop.
-        def ignored_ranges(ast)
-          return [] unless ast
-
-          @ignored_ranges ||= begin
-            ranges = []
-            on_node(:pair, ast) do |pair|
-              next if pair.parent.single_line?
-
-              key, value = *pair
-              ranges << (key.source_range.end_pos...value.source_range.begin_pos)
-            end
-            ranges
-          end
-        end
-
-        def force_equal_sign_alignment?
-          cop_config['ForceEqualSignAlignment']
-        end
-
-        def align_equal_signs(range, corrector)
-          lines  = all_relevant_assignment_lines(range.line)
-          tokens = assignment_tokens.select { |t| lines.include?(t.line) }
-
-          columns  = tokens.map { |t| align_column(t) }
-          align_to = columns.max
-
-          tokens.each { |token| align_equal_sign(corrector, token, align_to) }
-        end
-
-        def align_equal_sign(corrector, token, align_to)
-          return unless @corrected.add?(token)
-
-          diff = align_to - token.pos.last_column
-
-          if diff.positive?
-            corrector.insert_before(token.pos, ' ' * diff)
-          elsif diff.negative?
-            corrector.remove_preceding(token.pos, -diff)
-          end
-        end
-
-        def all_relevant_assignment_lines(line_number)
-          last_line_number = processed_source.lines.size
-
-          (
-            relevant_assignment_lines(line_number.downto(1)) +
-            relevant_assignment_lines(line_number.upto(last_line_number))
-          )
-            .uniq
-            .sort
-        end
-
-        def align_column(asgn_token)
-          # if we removed unneeded spaces from the beginning of this =,
-          # what column would it end from?
-          line    = processed_source.lines[asgn_token.line - 1]
-          leading = line[0...asgn_token.column]
-          spaces  = leading.size - (leading =~ / *\Z/)
-          asgn_token.pos.last_column - spaces + 1
-        end
-
-        def allow_for_trailing_comments?
-          cop_config['AllowBeforeTrailingComments']
-        end
-      end
-    end
-  end
-end

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

@@ -1,180 +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 the ArrayAlignment cop.
-      #
-      # 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)
-          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
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.57.2/lib/rubocop/cop/layout/first_parameter_indentation.rb

@@ -1,101 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Layout
-      # Checks the indentation of the first parameter in a method
-      # definition. Parameters after the first one are checked by
-      # Layout/ParameterAlignment, not by this cop.
-      #
-      # For indenting the first argument of method _calls_, check out
-      # Layout/FirstArgumentIndentation, which supports options related to
-      # nesting that are irrelevant for method _definitions_.
-      #
-      # @example
-      #
-      #   # bad
-      #   def some_method(
-      #   first_param,
-      #   second_param)
-      #     123
-      #   end
-      #
-      # @example EnforcedStyle: consistent (default)
-      #   # The first parameter should always be indented one step more than the
-      #   # preceding line.
-      #
-      #   # good
-      #   def some_method(
-      #     first_param,
-      #   second_param)
-      #     123
-      #   end
-      #
-      # @example EnforcedStyle: align_parentheses
-      #   # The first parameter should always be indented one step more than the
-      #   # opening parenthesis.
-      #
-      #   # good
-      #   def some_method(
-      #                    first_param,
-      #   second_param)
-      #     123
-      #   end
-      class FirstParameterIndentation < Base
-        include Alignment
-        include ConfigurableEnforcedStyle
-        include MultilineElementIndentation
-        extend AutoCorrector
-
-        MSG = 'Use %<configured_indentation_width>d spaces for indentation ' \
-              'in method args, relative to %<base_description>s.'
-
-        def on_def(node)
-          return if node.arguments.empty?
-          return if node.arguments.loc.begin.nil?
-
-          check(node)
-        end
-        alias on_defs on_def
-
-        private
-
-        def autocorrect(corrector, node)
-          AlignmentCorrector.correct(corrector, processed_source, node, @column_delta)
-        end
-
-        def brace_alignment_style
-          :align_parentheses
-        end
-
-        def check(def_node)
-          return if ignored_node?(def_node)
-
-          left_parenthesis = def_node.arguments.loc.begin
-          first_elem = def_node.arguments.first
-          return unless first_elem
-          return if same_line?(first_elem, left_parenthesis)
-
-          check_first(first_elem, left_parenthesis, nil, 0)
-        end
-
-        # Returns the description of what the correct indentation is based on.
-        def base_description(_)
-          if style == brace_alignment_style
-            'the position of the opening parenthesis'
-          else
-            'the start of the line where the left parenthesis is'
-          end
-        end
-
-        def message(base_description)
-          format(
-            MSG,
-            configured_indentation_width: configured_indentation_width,
-            base_description: base_description
-          )
-        end
-      end
-    end
-  end
-end