rubocop 0.26.1 → 0.27.0

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

@@ -24,40 +24,37 @@ module RuboCop
       #    !current_user.nil?
       #  end
       class NonNilCheck < Cop
-        MSG = 'Explicit non-nil checks are usually redundant.'
+        include OnMethodDef
 
         NIL_NODE = s(:nil)
 
-        def on_def(node)
-          method_name, _args, body = *node
-          process_method(method_name, body)
-        end
-
-        def on_defs(node)
-          _scope, method_name, _args, body = *node
-          process_method(method_name, body)
-        end
-
         def on_send(node)
           return if ignored_node?(node)
           receiver, method, args = *node
 
-          return unless [:!=, :!].include?(method)
-
           if method == :!=
             add_offense(node, :selector) if args == NIL_NODE
-          elsif include_semantic_changes? && method == :!
+          elsif method == :! && include_semantic_changes?
             add_offense(node, :expression) if nil_check?(receiver)
           end
         end
 
         private
 
+        def message(node)
+          _receiver, method, _args = *node
+          if method == :!=
+            'Prefer `!expression.nil?` over `expression != nil`.'
+          else
+            'Explicit non-nil checks are usually redundant.'
+          end
+        end
+
         def include_semantic_changes?
           cop_config['IncludeSemanticChanges']
         end
 
-        def process_method(name, body)
+        def on_method_def(_node, name, _args, body)
           # only predicate methods are handled differently
           return unless name.to_s.end_with?('?')
           return unless body

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

@@ -14,7 +14,7 @@ module RuboCop
 
           # not does not take any arguments
           return unless args.empty? && method_name == :! &&
-            node.loc.selector.is?('not')
+                        node.loc.selector.is?('not')
 
           add_offense(node, :selector)
         end

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

@@ -56,17 +56,14 @@ module RuboCop
             closing_indentation + closing_delimiter + reg_opt
 
           @corrections << lambda do |corrector|
-            corrector.replace(
-              node.loc.expression,
-              corrected_source
-            )
+            corrector.replace(node.loc.expression, corrected_source)
           end
         end
 
         def on_percent_literal(node)
           type = type(node)
           return if uses_preferred_delimiter?(node, type) ||
-            contains_preferred_delimiter?(node, type)
+                    contains_preferred_delimiter?(node, type)
 
           add_offense(node, :expression)
         end
@@ -94,20 +91,18 @@ module RuboCop
           if node.type == :regexp
             *_, next_to_last_child = *middle
             next_to_last_child ||= first_child
-            [
-              source(node, first_child, next_to_last_child),
-              last_child.loc.expression.source
-            ]
+            expression = source(node, first_child, next_to_last_child)
+            reg_opt = last_child.loc.expression.source
           else
-            [
-              if first_child.is_a?(Parser::AST::Node)
-                source(node, first_child, last_child)
-              else
-                first_child.to_s
-              end,
-              ''
-            ]
+            expression = if first_child.is_a?(Parser::AST::Node)
+                           source(node, first_child, last_child)
+                         else
+                           first_child.to_s
+                         end
+            reg_opt = ''
           end
+
+          [expression, reg_opt]
         end
 
         def source(node, begin_node, end_node)

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

@@ -31,7 +31,7 @@ module RuboCop
           # Report offense only if changing case doesn't change semantics,
           # i.e., if the string would become dynamic or has special characters.
           return if node.children !=
-            ProcessedSource.new(corrected(src)).ast.children
+                    ProcessedSource.new(corrected(src)).ast.children
 
           add_offense(node, :begin, msg)
         end

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

@@ -18,11 +18,11 @@ module RuboCop
       #   # good
       #   def value? ...
       class PredicateName < Cop
-        include OnMethod
+        include OnMethodDef
 
         private
 
-        def on_method(node, method_name, _args, _body)
+        def on_method_def(node, method_name, _args, _body)
           predicate_prefices.each do |prefix|
             method_name = method_name.to_s
             next unless method_name.start_with?(prefix)

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

@@ -25,11 +25,11 @@ module RuboCop
       #     something
       #   end
       class RedundantBegin < Cop
-        include OnMethod
+        include OnMethodDef
 
         MSG = 'Redundant `begin` block detected.'
 
-        def on_method(_node, _method_name, _args, body)
+        def on_method_def(_node, _method_name, _args, body)
           return unless body && body.type == :kwbegin
 
           add_offense(body, :begin)

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

@@ -21,7 +21,7 @@ module RuboCop
       # It should be extended to handle methods whose body is if/else
       # or a case expression with a default branch.
       class RedundantReturn < Cop
-        include OnMethod
+        include OnMethodDef
 
         MSG = 'Redundant `return` detected.'
 
@@ -39,7 +39,7 @@ module RuboCop
           end
         end
 
-        def on_method(_node, _method_name, _args, body)
+        def on_method_def(_node, _method_name, _args, body)
           return unless body
 
           if body.type == :return
@@ -56,7 +56,7 @@ module RuboCop
 
         def check_return_node(node)
           return if cop_config['AllowMultipleReturnValues'] &&
-            node.children.size > 1
+                    node.children.size > 1
 
           add_offense(node, :keyword)
         end

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

@@ -94,9 +94,9 @@ module RuboCop
           receiver, method_name, *_args = *node
           return unless receiver && receiver.type == :self
           return if operator?(method_name) || keyword?(method_name) ||
-            constant_name?(method_name) ||
-            @allowed_send_nodes.include?(node) ||
-            @local_variables.include?(method_name)
+                    constant_name?(method_name) ||
+                    @allowed_send_nodes.include?(node) ||
+                    @local_variables.include?(method_name)
 
           add_offense(node, :expression)
         end

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

@@ -53,19 +53,23 @@ module RuboCop
           max = self.class.slash_count['/'].max
           min = self.class.slash_count['%'].min
 
-          self.config_to_allow_offenses = if max > max_slashes
-                                            if max < min
-                                              { 'MaxSlashes' => max }
-                                            else
-                                              { 'Enabled' => false }
-                                            end
-                                          elsif min < max_slashes + 1
-                                            if max < min
-                                              { 'MaxSlashes' => min - 1 }
-                                            else
-                                              { 'Enabled' => false }
-                                            end
-                                          end
+          self.config_to_allow_offenses = calculate_config(max, min)
+        end
+
+        def calculate_config(max, min)
+          if max > max_slashes
+            if max < min
+              { 'MaxSlashes' => max }
+            else
+              { 'Enabled' => false }
+            end
+          elsif min < max_slashes + 1
+            if max < min
+              { 'MaxSlashes' => min - 1 }
+            else
+              { 'Enabled' => false }
+            end
+          end
         end
 
         def error_message(word)

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

@@ -5,7 +5,7 @@ module RuboCop
     module Style
       # This cop checks for uses of rescue in its modifier form.
       class RescueModifier < Cop
-        include OnMethod
+        include OnMethodDef
 
         MSG = 'Avoid using `rescue` in its modifier form.'
 
@@ -20,7 +20,7 @@ module RuboCop
           check(body)
         end
 
-        def on_method(_node, _method_name, _args, body)
+        def on_method_def(_node, _method_name, _args, body)
           check(body)
         end
 

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

@@ -6,7 +6,7 @@ module RuboCop
       # This cop checks for single-line method definitions.
       # It can optionally accept single-line methods with no body.
       class SingleLineMethods < Cop
-        include OnMethod
+        include OnMethodDef
 
         MSG = 'Avoid single-line method definitions.'
 
@@ -16,7 +16,7 @@ module RuboCop
 
         private
 
-        def on_method(node, _method_name, _args, body)
+        def on_method_def(node, _method_name, _args, body)
           start_line = node.loc.keyword.line
           end_line = node.loc.end.line
 
@@ -51,11 +51,14 @@ module RuboCop
           corrector.insert_before(
             range,
             "\n" + ' ' * (node.loc.keyword.column +
-                          indent_steps *
-                          IndentationWidth::CORRECT_INDENTATION)
+                          indent_steps * configured_indentation_width)
           )
         end
 
+        def configured_indentation_width
+          config.for_cop('IndentationWidth')['Width']
+        end
+
         def move_comment(eol_comment, node, corrector)
           text = eol_comment.loc.expression.source
           corrector.insert_before(node.loc.expression,

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

@@ -13,12 +13,12 @@ module RuboCop
       #   # good
       #   def func(x) ... end
       class SpaceAfterMethodName < Cop
-        include OnMethod
+        include OnMethodDef
 
         MSG = 'Never put a space between a method name and the opening ' \
               'parenthesis.'
 
-        def on_method(_node, _method_name, args, _body)
+        def on_method_def(_node, _method_name, args, _body)
           return unless args.loc.begin && args.loc.begin.is?('(')
           expr = args.loc.expression
           pos_before_left_paren = Parser::Source::Range.new(expr.source_buffer,

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

@@ -22,19 +22,25 @@ module RuboCop
           no_surrounding_space = no_surrounding_space?(arg, equals, value)
 
           if style == :space && space_on_both_sides ||
-              style == :no_space && no_surrounding_space
+             style == :no_space && no_surrounding_space
             correct_style_detected
           else
-            range = Parser::Source::Range.new(processed_source.buffer,
-                                              arg.pos.end_pos,
-                                              value.pos.begin_pos)
-            add_offense(range, range) do
-              if style == :space && no_surrounding_space ||
-                  style == :no_space && space_on_both_sides
-                opposite_style_detected
-              else
-                unrecognized_style_detected
-              end
+            incorrect_style_detected(arg, value, space_on_both_sides,
+                                     no_surrounding_space)
+          end
+        end
+
+        def incorrect_style_detected(arg, value, space_on_both_sides,
+                                     no_surrounding_space)
+          range = Parser::Source::Range.new(processed_source.buffer,
+                                            arg.pos.end_pos,
+                                            value.pos.begin_pos)
+          add_offense(range, range) do
+            if style == :space && no_surrounding_space ||
+               style == :no_space && space_on_both_sides
+              opposite_style_detected
+            else
+              unrecognized_style_detected
             end
           end
         end

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

@@ -16,7 +16,7 @@ module RuboCop
           # auto-correct, so reporting space issues is not useful, and it
           # creates auto-correct conflicts.
           if config.for_cop('Style/Blocks')['Enabled'] &&
-              Util.block_length(node) > 0
+             Util.block_length(node) > 0
             return
           end
 

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

@@ -19,7 +19,7 @@ module RuboCop
           # auto-correct, so reporting space issues is not useful, and it
           # creates auto-correct conflicts.
           if config.for_cop('Style/Blocks')['Enabled'] &&
-              Util.block_length(node) > 0
+             Util.block_length(node) > 0
             return
           end
 
@@ -34,25 +34,28 @@ module RuboCop
           sb = node.loc.expression.source_buffer
 
           if left_brace.end_pos == right_brace.begin_pos
-            if style_for_empty_braces == :space
-              offense(sb, left_brace.begin_pos, right_brace.end_pos,
-                      'Space missing inside empty braces.')
-            end
-          else
+            adjacent_braces(sb, left_brace, right_brace)
+          elsif left_brace.line == right_brace.line
             range = Parser::Source::Range.new(sb, left_brace.end_pos,
                                               right_brace.begin_pos)
             inner = range.source
-            unless inner =~ /\n/
-              if inner =~ /\S/
-                braces_with_contents_inside(node, inner, sb)
-              elsif style_for_empty_braces == :no_space
-                offense(sb, range.begin_pos, range.end_pos,
-                        'Space inside empty braces detected.')
-              end
+
+            if inner =~ /\S/
+              braces_with_contents_inside(node, inner, sb)
+            elsif style_for_empty_braces == :no_space
+              offense(sb, range.begin_pos, range.end_pos,
+                      'Space inside empty braces detected.')
             end
           end
         end
 
+        def adjacent_braces(sb, left_brace, right_brace)
+          return if style_for_empty_braces != :space
+
+          offense(sb, left_brace.begin_pos, right_brace.end_pos,
+                  'Space missing inside empty braces.')
+        end
+
         def braces_with_contents_inside(node, inner, sb)
           _method, args, _body = *node
           left_brace, right_brace = node.loc.begin, node.loc.end
@@ -75,7 +78,7 @@ module RuboCop
         def no_space_inside_left_brace(left_brace, args_delimiter, sb)
           if pipe?(args_delimiter)
             if left_brace.end_pos == args_delimiter.begin_pos &&
-                cop_config['SpaceBeforeBlockParameters']
+               cop_config['SpaceBeforeBlockParameters']
               offense(sb, left_brace.begin_pos, args_delimiter.end_pos,
                       'Space between { and | missing.')
             end

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

@@ -37,17 +37,21 @@ module RuboCop
                            style == :space
                          end
           if offense?(t1, t2, expect_space)
-            brace = (t1.text == '{' ? t1 : t2).pos
-            range = expect_space ? brace : space_range(brace)
-            add_offense(range, range, message(brace, is_empty_braces,
-                                              expect_space)) do
-              opposite_style_detected
-            end
+            incorrect_style_detected(t1, t2, expect_space, is_empty_braces)
           else
             correct_style_detected
           end
         end
 
+        def incorrect_style_detected(t1, t2, expect_space, is_empty_braces)
+          brace = (t1.text == '{' ? t1 : t2).pos
+          range = expect_space ? brace : space_range(brace)
+          add_offense(range, range,
+                      message(brace, is_empty_braces, expect_space)) do
+            opposite_style_detected
+          end
+        end
+
         def offense?(t1, t2, expect_space)
           has_space = space_between?(t1, t2)
           expect_space ? !has_space : has_space

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

@@ -6,7 +6,18 @@ module RuboCop
       # Checks if uses of quotes match the configured preference.
       class StringLiterals < Cop
         include ConfigurableEnforcedStyle
-        include StringHelp
+        include StringLiteralsHelp
+
+        def on_dstr(node)
+          # A dstr node with dstr and str children is a concatenated
+          # string. Don't ignore the whole thing.
+          return if node.children.find { |child| child.type == :str }
+
+          # Dynamic strings can not use single quotes, and quotes inside
+          # interpolation expressions are checked by the
+          # StringLiteralsInInterpolation cop, so ignore.
+          ignore_node(node)
+        end
 
         private
 
@@ -21,21 +32,7 @@ module RuboCop
         end
 
         def offense?(node)
-          src = node.loc.expression.source
-          return false if src =~ /^(%[qQ]?|\?|<<-)/i
-          if style == :single_quotes
-            src !~ /'/ && src !~ StringHelp::ESCAPED_CHAR_REGEXP
-          else
-            src !~ /" | \\/x
-          end
-        end
-
-        def autocorrect(node)
-          @corrections << lambda do |corrector|
-            replacement = node.loc.begin.is?('"') ? "'" : '"'
-            corrector.replace(node.loc.begin, replacement)
-            corrector.replace(node.loc.end, replacement)
-          end
+          wrong_quotes?(node, style)
         end
       end
     end