rubocop 0.42.0 → 0.52.1

data/lib/rubocop/cop/style/multiline_method_call_indentation.rb

@@ -1,176 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks the indentation of the method name part in method calls
-      # that span more than one line.
-      #
-      # @example
-      #   # bad
-      #   while a
-      #   .b
-      #     something
-      #   end
-      #
-      #   # good, EnforcedStyle: aligned
-      #   while a
-      #         .b
-      #     something
-      #   end
-      #
-      #   # good, EnforcedStyle: aligned
-      #   Thing.a
-      #        .b
-      #        .c
-      #
-      #   # good, EnforcedStyle: indented
-      #   while a
-      #       .b
-      #     something
-      #   end
-      class MultilineMethodCallIndentation < Cop
-        include ConfigurableEnforcedStyle
-        include AutocorrectAlignment
-        include MultilineExpressionIndentation
-
-        def validate_config
-          if style == :aligned && cop_config['IndentationWidth']
-            raise ValidationError,
-                  'The `Style/MultilineMethodCallIndentation`' \
-                  ' cop only accepts an `IndentationWidth` ' \
-                  'configuration parameter when ' \
-                  '`EnforcedStyle` is `indented`.'
-          end
-        end
-
-        private
-
-        def relevant_node?(send_node)
-          send_node.loc.dot # Only check method calls with dot operator
-        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)
-                           else
-                             indentation(lhs) + correct_indentation(node)
-                           end
-          @column_delta = correct_column - rhs.column
-          rhs if @column_delta.nonzero?
-        end
-
-        def extra_indentation(given_style)
-          if given_style == :indented_relative_to_receiver
-            configured_indentation_width
-          else
-            0
-          end
-        end
-
-        def message(node, lhs, rhs)
-          if @base
-            base_source = @base.source[/[^\n]*/]
-            if style == :indented_relative_to_receiver
-              "Indent `#{rhs.source}` #{configured_indentation_width} spaces " \
-              "more than `#{base_source}` on line #{@base.line}."
-            else
-              "Align `#{rhs.source}` with `#{base_source}` on " \
-              "line #{@base.line}."
-            end
-          else
-            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
-        end
-
-        def alignment_base(node, rhs, given_style)
-          return nil if given_style == :indented
-
-          if given_style == :indented_relative_to_receiver
-            receiver_base = receiver_alignment_base(node)
-            return receiver_base if receiver_base
-          end
-
-          semantic_alignment_base(node, rhs) ||
-            syntactic_alignment_base(node, rhs)
-        end
-
-        def syntactic_alignment_base(lhs, rhs)
-          # a if b
-          #      .c
-          n = kw_node_with_special_indentation(lhs)
-          if n
-            case n.type
-            when :if, :while, :until then expression, = *n
-            when :for                then _, expression, = *n
-            when :return             then expression, = *n
-            end
-            return expression.source_range
-          end
-
-          # a = b
-          #     .c
-          n = part_of_assignment_rhs(lhs, rhs)
-          return assignment_rhs(n).source_range if n
-
-          # a + b
-          #     .c
-          n = operation_rhs(lhs)
-          return n.source_range if n
-        end
-
-        # a.b
-        #  .c
-        def semantic_alignment_base(node, rhs)
-          return unless rhs.source.start_with?('.')
-
-          node = semantic_alignment_node(node)
-          return unless node
-
-          node.loc.dot.join(node.loc.selector)
-        end
-
-        # a
-        #   .b
-        #   .c
-        def receiver_alignment_base(node)
-          node = semantic_alignment_node(node)
-          return unless node
-
-          node.receiver.source_range
-        end
-
-        def semantic_alignment_node(node)
-          return if argument_in_method_call(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.dot
-
-          return if node.loc.dot.line != node.loc.line
-          node
-        end
-
-        def operation_rhs(node)
-          receiver, = *node
-          receiver.each_ancestor(:send) do |a|
-            _, method, args = *a
-            return args if operator?(method) && args &&
-                           within_node?(receiver, args)
-          end
-          nil
-        end
-      end
-    end
-  end
-end

data/lib/rubocop/cop/style/op_method.rb

@@ -1,44 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop makes sure that certain binary operator methods have their
-      # sole  parameter named `other`.
-      #
-      # @example
-      #
-      #   # bad
-      #   def +(amount); end
-      #
-      #   # good
-      #   def +(other); end
-      class OpMethod < Cop
-        MSG = 'When defining the `%s` operator, ' \
-              'name its argument `other`.'.freeze
-
-        OP_LIKE_METHODS = [:eql?, :equal?].freeze
-
-        BLACKLISTED = [:+@, :-@, :[], :[]=, :<<, :`].freeze
-
-        TARGET_ARGS = [s(:args, s(:arg, :other)),
-                       s(:args, s(:arg, :_other))].freeze
-
-        def on_def(node)
-          name, args, _body = *node
-          return unless op_method?(name) &&
-                        args.children.one? &&
-                        !TARGET_ARGS.include?(args)
-
-          add_offense(args.children[0], :expression, format(MSG, name))
-        end
-
-        def op_method?(name)
-          return false if BLACKLISTED.include?(name)
-          name !~ /\A\w/ || OP_LIKE_METHODS.include?(name)
-        end
-      end
-    end
-  end
-end

data/lib/rubocop/cop/style/predicate_name.rb

@@ -1,68 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop makes sure that predicates are named properly.
-      #
-      # @example
-      #   # bad
-      #   def is_even?(value) ...
-      #
-      #   # good
-      #   def even?(value)
-      #
-      #   # bad
-      #   def has_value? ...
-      #
-      #   # good
-      #   def value? ...
-      class PredicateName < Cop
-        include OnMethodDef
-
-        private
-
-        def on_method_def(node, method_name, _args, _body)
-          predicate_prefixes.each do |prefix|
-            method_name = method_name.to_s
-            next unless method_name.start_with?(prefix)
-            next if method_name == expected_name(method_name, prefix)
-            next if predicate_whitelist.include?(method_name)
-            add_offense(
-              node,
-              :name,
-              message(method_name, expected_name(method_name, prefix))
-            )
-          end
-        end
-
-        def expected_name(method_name, prefix)
-          new_name = if prefix_blacklist.include?(prefix)
-                       method_name.sub(prefix, '')
-                     else
-                       method_name.dup
-                     end
-          new_name << '?' unless method_name.end_with?('?')
-          new_name
-        end
-
-        def message(method_name, new_name)
-          "Rename `#{method_name}` to `#{new_name}`."
-        end
-
-        def prefix_blacklist
-          cop_config['NamePrefixBlacklist']
-        end
-
-        def predicate_prefixes
-          cop_config['NamePrefix']
-        end
-
-        def predicate_whitelist
-          cop_config['NameWhitelist']
-        end
-      end
-    end
-  end
-end

data/lib/rubocop/cop/style/space_after_comma.rb

@@ -1,22 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # Checks for comma (,) not followed by some kind of space.
-      class SpaceAfterComma < Cop
-        include SpaceAfterPunctuation
-
-        def space_style_before_rcurly
-          cfg = config.for_cop('Style/SpaceInsideHashLiteralBraces')
-          cfg['EnforcedStyle'] || 'space'
-        end
-
-        def kind(token)
-          'comma' if token.type == :tCOMMA
-        end
-      end
-    end
-  end
-end

data/lib/rubocop/cop/style/space_after_not.rb

@@ -1,42 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks for space after `!`.
-      #
-      # @example
-      #   # bad
-      #   ! something
-      #
-      #   # good
-      #   !something
-      class SpaceAfterNot < Cop
-        MSG = 'Do not leave space between `!` and its argument.'.freeze
-
-        def on_send(node)
-          if node.keyword_bang? && whitespace_after_bang_op?(node)
-            add_offense(node, :expression)
-          end
-        end
-
-        def whitespace_after_bang_op?(node)
-          receiver, _method_name, *_args = *node
-          receiver.loc.column - node.loc.column > 1
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            receiver, _method_name, *_args = *node
-            space_range =
-              Parser::Source::Range.new(node.loc.selector.source_buffer,
-                                        node.loc.selector.end_pos,
-                                        receiver.source_range.begin_pos)
-            corrector.remove(space_range)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/rubocop/cop/style/space_around_operators.rb

@@ -1,132 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # Checks that operators have space around them, except for **
-      # which should not have surrounding space.
-      class SpaceAroundOperators < Cop
-        include IfNode
-        include PrecedingFollowingAlignment
-        include HashNode # any_pairs_on_the_same_line?
-
-        def on_pair(node)
-          return unless node.loc.operator.is?('=>')
-
-          align_hash_config = config.for_cop('Style/AlignHash')
-          return if align_hash_config['EnforcedHashRocketStyle'] == 'table' &&
-                    !any_pairs_on_the_same_line?(node.parent)
-
-          _, right = *node
-          check_operator(node.loc.operator, right.source_range)
-        end
-
-        def on_if(node)
-          return unless ternary?(node)
-          _, if_branch, else_branch = *node
-
-          check_operator(node.loc.question, if_branch.source_range)
-          check_operator(node.loc.colon, else_branch.source_range)
-        end
-
-        def on_resbody(node)
-          if node.loc.assoc
-            _, variable, = *node
-            check_operator(node.loc.assoc, variable.source_range)
-          end
-        end
-
-        def on_send(node)
-          if node.loc.operator # aref assignment, attribute assignment
-            on_special_asgn(node)
-          elsif !node.unary_operation? && !called_with_dot?(node)
-            op = node.method_name
-            if operator_with_regular_syntax?(op)
-              _, _, right, = *node
-              check_operator(node.loc.selector, right.source_range)
-            end
-          end
-        end
-
-        def on_binary(node)
-          _, right, = *node
-          return if right.nil?
-          check_operator(node.loc.operator, right.source_range)
-        end
-
-        def on_special_asgn(node)
-          return unless node.loc.operator
-          _, _, right, = *node
-          check_operator(node.loc.operator, right.source_range)
-        end
-
-        alias on_or       on_binary
-        alias on_and      on_binary
-        alias on_lvasgn   on_binary
-        alias on_masgn    on_binary
-        alias on_casgn    on_special_asgn
-        alias on_ivasgn   on_binary
-        alias on_cvasgn   on_binary
-        alias on_gvasgn   on_binary
-        alias on_class    on_binary
-        alias on_or_asgn  on_binary
-        alias on_and_asgn on_binary
-        alias on_op_asgn  on_special_asgn
-
-        private
-
-        def called_with_dot?(node)
-          node.loc.dot
-        end
-
-        def operator_with_regular_syntax?(op)
-          ![:[], :!, :[]=].include?(op) && operator?(op)
-        end
-
-        def check_operator(op, right_operand)
-          with_space = range_with_surrounding_space(op)
-          return if with_space.source.start_with?("\n")
-
-          if op.is?('**')
-            unless with_space.is?('**')
-              add_offense(with_space, op,
-                          'Space around operator `**` detected.')
-            end
-          elsif with_space.source !~ /^\s.*\s$/
-            add_offense(with_space, op, 'Surrounding space missing for ' \
-                                        "operator `#{op.source}`.")
-          elsif excess_leading_space?(op, with_space)
-            add_offense(with_space, op, "Operator `#{op.source}` should be " \
-                                        'surrounded by a single space.')
-          elsif excess_trailing_space?(right_operand, with_space)
-            add_offense(with_space, op, "Operator `#{op.source}` should be " \
-                                        'surrounded by a single space.')
-          end
-        end
-
-        def excess_leading_space?(op, with_space)
-          with_space.source =~ /^  / &&
-            (!allow_for_alignment? || !aligned_with_operator?(op))
-        end
-
-        def excess_trailing_space?(right_operand, with_space)
-          with_space.source =~ /  $/ &&
-            (!allow_for_alignment? || !aligned_with_something?(right_operand))
-        end
-
-        def autocorrect(range)
-          lambda do |corrector|
-            if range.source =~ /\*\*/
-              corrector.replace(range, '**')
-            elsif range.source.end_with?("\n")
-              corrector.replace(range, " #{range.source.strip}\n")
-            else
-              corrector.replace(range, " #{range.source.strip} ")
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/rubocop/cop/style/space_before_block_braces.rb

@@ -1,65 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # Checks that block braces have or don't have a space before the opening
-      # brace depending on configuration.
-      class SpaceBeforeBlockBraces < Cop
-        include ConfigurableEnforcedStyle
-
-        def on_block(node)
-          return if node.loc.begin.is?('do') # No braces.
-
-          # If braces are on separate lines, and the BlockDelimiters cop is
-          # enabled, those braces will be changed to do..end by the user or by
-          # auto-correct, so reporting space issues is not useful, and it
-          # creates auto-correct conflicts.
-          if config.for_cop('Style/BlockDelimiters')['Enabled'] &&
-             block_length(node) > 0
-            return
-          end
-
-          left_brace = node.loc.begin
-          space_plus_brace = range_with_surrounding_space(left_brace)
-          used_style =
-            space_plus_brace.source.start_with?('{') ? :no_space : :space
-
-          case used_style
-          when style  then correct_style_detected
-          when :space then space_detected(left_brace, space_plus_brace)
-          else             space_missing(left_brace)
-          end
-        end
-
-        private
-
-        def space_missing(left_brace)
-          add_offense(left_brace, left_brace,
-                      'Space missing to the left of {.') do
-            opposite_style_detected
-          end
-        end
-
-        def space_detected(left_brace, space_plus_brace)
-          space = Parser::Source::Range.new(left_brace.source_buffer,
-                                            space_plus_brace.begin_pos,
-                                            left_brace.begin_pos)
-          add_offense(space, space, 'Space detected to the left of {.') do
-            opposite_style_detected
-          end
-        end
-
-        def autocorrect(range)
-          lambda do |corrector|
-            case range.source
-            when /\s/ then corrector.remove(range)
-            else           corrector.insert_before(range, ' ')
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/rubocop/cop/style/space_before_comma.rb

@@ -1,17 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # Checks for comma (,) preceded by space.
-      class SpaceBeforeComma < Cop
-        include SpaceBeforePunctuation
-
-        def kind(token)
-          'comma' if token.type == :tCOMMA
-        end
-      end
-    end
-  end
-end

data/lib/rubocop/cop/style/space_before_semicolon.rb

@@ -1,17 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # Checks for semicolon (;) preceded by space.
-      class SpaceBeforeSemicolon < Cop
-        include SpaceBeforePunctuation
-
-        def kind(token)
-          'semicolon' if token.type == :tSEMI
-        end
-      end
-    end
-  end
-end