rubocop 0.51.0 → 0.87.0

data/lib/rubocop/ast/traversal.rb

@@ -1,171 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module AST
-    # Provides methods for traversing an AST.
-    # Does not transform an AST; for that, use Parser::AST::Processor.
-    # Override methods to perform custom processing. Remember to call `super`
-    # if you want to recursively process descendant nodes.
-    module Traversal
-      def walk(node)
-        return if node.nil?
-        send(:"on_#{node.type}", node)
-        nil
-      end
-
-      NO_CHILD_NODES    = %i[true false nil int float complex
-                             rational str sym regopt self lvar
-                             ivar cvar gvar nth_ref back_ref cbase
-                             arg restarg blockarg shadowarg
-                             kwrestarg zsuper lambda redo retry].freeze
-      ONE_CHILD_NODE    = %i[splat kwsplat block_pass not break next
-                             preexe postexe match_current_line defined?
-                             arg_expr].freeze
-      MANY_CHILD_NODES  = %i[dstr dsym xstr regexp array hash pair
-                             irange erange mlhs masgn or_asgn and_asgn
-                             undef alias args super yield or and
-                             while_post until_post iflipflop eflipflop
-                             match_with_lvasgn begin kwbegin return].freeze
-      SECOND_CHILD_ONLY = %i[lvasgn ivasgn cvasgn gvasgn optarg kwarg
-                             kwoptarg].freeze
-
-      NO_CHILD_NODES.each do |type|
-        module_eval("def on_#{type}(node); end")
-      end
-
-      ONE_CHILD_NODE.each do |type|
-        module_eval(<<-RUBY)
-          def on_#{type}(node)
-            if (child = node.children[0])
-              send(:"on_\#{child.type}", child)
-            end
-          end
-        RUBY
-      end
-
-      MANY_CHILD_NODES.each do |type|
-        module_eval(<<-RUBY)
-          def on_#{type}(node)
-            node.children.each { |child| send(:"on_\#{child.type}", child) }
-            nil
-          end
-        RUBY
-      end
-
-      SECOND_CHILD_ONLY.each do |type|
-        # Guard clause is for nodes nested within mlhs
-        module_eval(<<-RUBY)
-          def on_#{type}(node)
-            if (child = node.children[1])
-              send(:"on_\#{child.type}", child)
-            end
-          end
-        RUBY
-      end
-
-      def on_const(node)
-        return unless (child = node.children[0])
-        send(:"on_#{child.type}", child)
-      end
-
-      def on_casgn(node)
-        children = node.children
-        if (child = children[0]) # always const???
-          send(:"on_#{child.type}", child)
-        end
-        return unless (child = children[2])
-        send(:"on_#{child.type}", child)
-      end
-
-      def on_class(node)
-        children = node.children
-        child = children[0] # always const???
-        send(:"on_#{child.type}", child)
-        if (child = children[1])
-          send(:"on_#{child.type}", child)
-        end
-        return unless (child = children[2])
-        send(:"on_#{child.type}", child)
-      end
-
-      def on_def(node)
-        children = node.children
-        on_args(children[1])
-        return unless (child = children[2])
-        send(:"on_#{child.type}", child)
-      end
-
-      def on_send(node)
-        node.children.each_with_index do |child, i|
-          next if i == 1
-          send(:"on_#{child.type}", child) if child
-        end
-        nil
-      end
-
-      alias on_csend on_send
-
-      def on_op_asgn(node)
-        children = node.children
-        child = children[0]
-        send(:"on_#{child.type}", child)
-        child = children[2]
-        send(:"on_#{child.type}", child)
-      end
-
-      def on_defs(node)
-        children = node.children
-        child = children[0]
-        send(:"on_#{child.type}", child)
-        on_args(children[2])
-        return unless (child = children[3])
-        send(:"on_#{child.type}", child)
-      end
-
-      def on_if(node)
-        children = node.children
-        child = children[0]
-        send(:"on_#{child.type}", child)
-        if (child = children[1])
-          send(:"on_#{child.type}", child)
-        end
-        return unless (child = children[2])
-        send(:"on_#{child.type}", child)
-      end
-
-      def on_while(node)
-        children = node.children
-        child = children[0]
-        send(:"on_#{child.type}", child)
-        return unless (child = children[1])
-        send(:"on_#{child.type}", child)
-      end
-
-      alias on_until  on_while
-      alias on_module on_while
-      alias on_sclass on_while
-
-      def on_block(node)
-        children = node.children
-        child = children[0]
-        send(:"on_#{child.type}", child) # can be send, zsuper...
-        on_args(children[1])
-        return unless (child = children[2])
-        send(:"on_#{child.type}", child)
-      end
-
-      def on_case(node)
-        node.children.each do |child|
-          send(:"on_#{child.type}", child) if child
-        end
-        nil
-      end
-
-      alias on_rescue  on_case
-      alias on_resbody on_case
-      alias on_ensure  on_case
-      alias on_for     on_case
-      alias on_when    on_case
-    end
-  end
-end

data/lib/rubocop/cop/internal_affairs/deprecated_positional_arguments.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module InternalAffairs
-      # Enforces use of keyword arguments for `#add_offense`.
-      #
-      # @example
-      #
-      #   # bad
-      #   add_offense(node, :selector, 'message')
-      #   add_offense(node, :selector, message: 'message')
-      #
-      #   # good
-      #   add_offense(node, location: :selector, message: 'message')
-      #
-      class DeprecatedPositionalArguments < Cop
-        MSG = 'Use of positional arguments on `#add_offense` is ' \
-          'deprecated.'.freeze
-
-        ARGUMENTS = %i[location message severity].freeze
-
-        def on_send(node)
-          return unless node.method_name == :add_offense
-
-          positional_arguments(node) do |arguments|
-            location = range_between(
-              arguments.first.loc.expression.begin_pos,
-              arguments.last.loc.expression.end_pos
-            )
-
-            add_offense(node, location: location)
-          end
-        end
-
-        def autocorrect(node)
-          positional_arguments(node) do |arguments|
-            # Can't autocorrect splat.
-            next if arguments.any?(&:splat_type?)
-
-            lambda do |corrector|
-              arguments.zip(ARGUMENTS).each do |(arg, keyword)|
-                corrector.replace(arg.source_range, "#{keyword}: #{arg.source}")
-              end
-            end
-          end
-        end
-
-        private
-
-        def positional_arguments(node)
-          arguments = extract_arguments(node)
-
-          positional_args =
-            case arguments
-            when :empty?.to_proc then []
-            # Keyword arguments only
-            when ->(args) { args.one? && args.first.hash_type? } then []
-            # Mixed style
-            when ->(args) { args.last.hash_type? } then arguments.drop_last(1)
-            # Positional arguments only
-            else arguments
-            end
-
-          yield positional_args if positional_args.any?
-        end
-
-        def extract_arguments(node)
-          node.arguments.butfirst.take_while do |arg|
-            # Filter out block argument
-            next false if arg.block_pass_type?
-            # Filter out kwsplat
-            next false if arg.hash_type? && arg.each_child_node(:kwsplat).any?
-            # Keep all others
-            true
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Layout
-      # Here we check if the elements of a multi-line array literal are
-      # aligned.
-      #
-      # @example
-      #   # bad
-      #   a = [1, 2, 3,
-      #     4, 5, 6]
-      #   array = ['run',
-      #        'forrest',
-      #        'run']
-      #
-      #   # good
-      #   a = [1, 2, 3,
-      #        4, 5, 6]
-      #   a = ['run',
-      #        'forrest',
-      #        'run']
-      class AlignArray < Cop
-        include AutocorrectAlignment
-
-        MSG = 'Align the elements of an array literal if they span more ' \
-              'than one line.'.freeze
-
-        def on_array(node)
-          check_alignment(node.children)
-        end
-      end
-    end
-  end
-end

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

@@ -1,235 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Layout
-      # Check that the keys, separators, and values of a multi-line hash
-      # literal are aligned according to configuration. The configuration
-      # options are:
-      #
-      #   - key (left align keys)
-      #   - separator (align hash rockets and colons, right align keys)
-      #   - table (left align keys, hash rockets, and values)
-      #
-      # The treatment of hashes passed as the last argument to a method call
-      # can also be configured. The options are:
-      #
-      #   - always_inspect
-      #   - always_ignore
-      #   - ignore_implicit (without curly braces)
-      #   - ignore_explicit (with curly braces)
-      #
-      # @example
-      #
-      #   # EnforcedHashRocketStyle: key (default)
-      #   # EnforcedColonStyle: key (default)
-      #
-      #   # good
-      #   {
-      #     foo: bar,
-      #     ba: baz
-      #   }
-      #   {
-      #     :foo => bar,
-      #     :ba => baz
-      #   }
-      #
-      #   # bad
-      #   {
-      #     foo: bar,
-      #      ba: baz
-      #   }
-      #   {
-      #     :foo => bar,
-      #      :ba => baz
-      #   }
-      #
-      # @example
-      #
-      #   # EnforcedHashRocketStyle: separator
-      #   # EnforcedColonStyle: separator
-      #
-      #   #good
-      #   {
-      #     foo: bar,
-      #      ba: baz
-      #   }
-      #   {
-      #     :foo => bar,
-      #      :ba => baz
-      #   }
-      #
-      #   #bad
-      #   {
-      #     foo: bar,
-      #     ba: baz
-      #   }
-      #   {
-      #     :foo => bar,
-      #     :ba => baz
-      #   }
-      #   {
-      #     :foo => bar,
-      #     :ba  => baz
-      #   }
-      #
-      # @example
-      #
-      #   # EnforcedHashRocketStyle: table
-      #   # EnforcedColonStyle: table
-      #
-      #   #good
-      #   {
-      #     foo: bar,
-      #     ba:  baz
-      #   }
-      #   {
-      #     :foo => bar,
-      #     :ba  => baz
-      #   }
-      #
-      #   #bad
-      #   {
-      #     foo: bar,
-      #     ba: baz
-      #   }
-      #   {
-      #     :foo => bar,
-      #      :ba => baz
-      #   }
-      class AlignHash < Cop
-        include HashAlignment
-
-        MSG = 'Align the elements of a hash literal if they span more than ' \
-              'one line.'.freeze
-
-        def on_send(node)
-          return if double_splat?(node)
-
-          last_argument = node.last_argument
-
-          return unless last_argument.hash_type? &&
-                        ignore_hash_argument?(last_argument)
-
-          ignore_node(last_argument)
-        end
-
-        def on_hash(node)
-          return if ignored_node?(node)
-          return if node.pairs.empty? || node.single_line?
-
-          return unless alignment_for_hash_rockets.checkable_layout?(node) &&
-                        alignment_for_colons.checkable_layout?(node)
-
-          check_pairs(node)
-        end
-
-        private
-
-        attr_accessor :column_deltas
-
-        def double_splat?(node)
-          node.children.last.is_a?(Symbol)
-        end
-
-        def check_pairs(node)
-          first_pair = node.pairs.first
-          self.column_deltas = alignment_for(first_pair)
-                               .deltas_for_first_pair(first_pair, node)
-          add_offense(first_pair) unless good_alignment?
-
-          node.children.each do |current|
-            self.column_deltas = alignment_for(current)
-                                 .deltas(first_pair, current)
-            add_offense(current) unless good_alignment?
-          end
-        end
-
-        def ignore_hash_argument?(node)
-          case cop_config['EnforcedLastArgumentHashStyle']
-          when 'always_inspect'  then false
-          when 'always_ignore'   then true
-          when 'ignore_explicit' then node.braces?
-          when 'ignore_implicit' then !node.braces?
-          end
-        end
-
-        def alignment_for(pair)
-          if pair.hash_rocket?
-            alignment_for_hash_rockets
-          else
-            alignment_for_colons
-          end
-        end
-
-        def alignment_for_hash_rockets
-          @alignment_for_hash_rockets ||=
-            new_alignment('EnforcedHashRocketStyle')
-        end
-
-        def alignment_for_colons
-          @alignment_for_colons ||=
-            new_alignment('EnforcedColonStyle')
-        end
-
-        def autocorrect(node)
-          # We can't use the instance variable inside the lambda. That would
-          # just give each lambda the same reference and they would all get the
-          # last value of each. A local variable fixes the problem.
-          key_delta = column_deltas[:key] || 0
-
-          if !node.value
-            correct_no_value(key_delta, node.source_range)
-          else
-            correct_key_value(key_delta, node.key.source_range,
-                              node.value.source_range,
-                              node.loc.operator)
-          end
-        end
-
-        def correct_no_value(key_delta, key)
-          ->(corrector) { adjust(corrector, key_delta, key) }
-        end
-
-        def correct_key_value(key_delta, key, value, separator)
-          # We can't use the instance variable inside the lambda. That would
-          # just give each lambda the same reference and they would all get the
-          # last value of each. Some local variables fix the problem.
-          separator_delta = column_deltas[:separator] || 0
-          value_delta     = column_deltas[:value] || 0
-
-          key_column = key.column
-          key_delta = -key_column if key_delta < -key_column
-
-          lambda do |corrector|
-            adjust(corrector, key_delta, key)
-            adjust(corrector, separator_delta, separator)
-            adjust(corrector, value_delta, value)
-          end
-        end
-
-        def new_alignment(key)
-          case cop_config[key]
-          when 'key'       then KeyAlignment.new
-          when 'table'     then TableAlignment.new
-          when 'separator' then SeparatorAlignment.new
-          else raise "Unknown #{key}: #{cop_config[key]}"
-          end
-        end
-
-        def adjust(corrector, delta, range)
-          if delta > 0
-            corrector.insert_before(range, ' ' * delta)
-          elsif delta < 0
-            range = range_between(range.begin_pos - delta.abs, range.begin_pos)
-            corrector.remove(range)
-          end
-        end
-
-        def good_alignment?
-          column_deltas.values.all?(&:zero?)
-        end
-      end
-    end
-  end
-end

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

@@ -1,114 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Layout
-      # This cop 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 AlignArray 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:
-      #
-      #     # special_inside_parentheses
-      #     array = [
-      #       :value
-      #     ]
-      #     but_in_a_method_call([
-      #                            :its_like_this
-      #                          ])
-      #     # consistent
-      #     array = [
-      #       :value
-      #     ]
-      #     and_in_a_method_call([
-      #       :no_difference
-      #     ])
-      #     # align_brackets
-      #     and_now_for_something = [
-      #                               :completely_different
-      #                             ]
-      #
-      class IndentArray < Cop
-        include AutocorrectAlignment
-        include ConfigurableEnforcedStyle
-        include ArrayHashIndentation
-
-        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
-
-        private
-
-        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 first_elem.source_range.line == left_bracket.line
-            check_first(first_elem, left_bracket, left_parenthesis, 0)
-          end
-
-          check_right_bracket(array_node.loc.end, left_bracket,
-                              left_parenthesis)
-        end
-
-        def check_right_bracket(right_bracket, left_bracket, left_parenthesis)
-          # if the right bracket is on the same line as the last value, accept
-          return if right_bracket.source_line[0...right_bracket.column] =~ /\S/
-
-          expected_column = base_column(left_bracket, left_parenthesis)
-          @column_delta = expected_column - right_bracket.column
-          return if @column_delta.zero?
-
-          msg = if style == :align_brackets
-                  'Indent the right bracket the same as the left bracket.'
-                elsif style == :special_inside_parentheses && left_parenthesis
-                  'Indent the right bracket the same as the first position ' \
-                  'after the preceding left parenthesis.'
-                else
-                  'Indent the right bracket the same as the start of the line' \
-                  ' where the left bracket is.'
-                end
-          add_offense(right_bracket, location: right_bracket, message: msg)
-        end
-
-        # Returns the description of what the correct indentation is based on.
-        def base_description(left_parenthesis)
-          if style == :align_brackets
-            'the position of the opening bracket'
-          elsif left_parenthesis && style == :special_inside_parentheses
-            'the first position after the preceding left parenthesis'
-          else
-            'the start of the line where the left square bracket is'
-          end
-        end
-
-        def message(base_description)
-          format('Use %d spaces for indentation in an array, relative to %s.',
-                 configured_indentation_width, base_description)
-        end
-      end
-    end
-  end
-end