rubocop 0.24.1 → 0.25.0

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

@@ -18,11 +18,11 @@ module RuboCop
       #   # good
       #   def attribute ...
       class AccessorMethodName < Cop
-        include CheckMethods
+        include OnMethod
 
         private
 
-        def check(node, method_name, args, _body)
+        def on_method(node, method_name, args, _body)
           if bad_reader_name?(method_name.to_s, args)
             add_offense(node, :name,
                         'Do not prefix reader method names with `get_`.')

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

@@ -199,8 +199,16 @@ module RuboCop
           node.loc.begin
         end
 
+        # Returns true if the hash spans multiple lines, and each key-value
+        # pair following the first is on a new line.
         def multiline?(node)
-          node.loc.expression.source.include?("\n")
+          return false unless node.loc.expression.source.include?("\n")
+
+          return false if node.children[1..-1].find do |child|
+            !begins_its_line?(child.loc.expression)
+          end
+
+          true
         end
 
         def alignment_for(pair)

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

@@ -6,21 +6,40 @@ module RuboCop
       # This cop checks for uses of *and* and *or*.
       class AndOr < Cop
         include AutocorrectUnlessChangingAST
+        include ConfigurableEnforcedStyle
 
         MSG = 'Use `%s` instead of `%s`.'
 
         OPS = { 'and' => '&&', 'or' => '||' }
 
         def on_and(node)
-          process_logical_op(node)
+          process_logical_op(node) if style == :always
         end
 
         def on_or(node)
-          process_logical_op(node)
+          process_logical_op(node) if style == :always
+        end
+
+        def on_if(node)
+          on_conditionals(node) if style == :conditionals
+        end
+
+        def on_while(node)
+          on_conditionals(node) if style == :conditionals
+        end
+
+        def on_until(node)
+          on_conditionals(node) if style == :conditionals
         end
 
         private
 
+        def on_conditionals(node)
+          on_node([:and, :or], node) do |my_node|
+            process_logical_op(my_node)
+          end
+        end
+
         def process_logical_op(node)
           op = node.loc.operator.source
           op_type = node.type.to_s
@@ -30,8 +49,23 @@ module RuboCop
         end
 
         def correction(node)
+          expr1, expr2 = *node
+          replacement = (node.type == :and ? '&&' : '||')
           lambda do |corrector|
-            replacement = (node.type == :and ? '&&' : '||')
+            [expr1, expr2].each do |expr|
+              next unless expr.type == :send
+              _receiver, method_name, *args = *expr
+              # don't clobber if we already have a starting paren
+              next unless !expr.loc.begin || expr.loc.begin.source != '('
+              # don't touch anything unless we are sure it is a method call.
+              next unless args.last && method_name.to_s =~ /[a-z]/
+              sb = expr.loc.expression.source_buffer
+              begin_paren = expr.loc.selector.end_pos
+              end_paren = begin_paren + 1
+              range = Parser::Source::Range.new(sb, begin_paren, end_paren)
+              corrector.replace(range, '(')
+              corrector.insert_after(args.last.loc.expression, ')')
+            end
             corrector.replace(node.loc.operator, replacement)
           end
         end

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

@@ -0,0 +1,46 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks if usage of %() or %Q() matches configuration.
+      class BarePercentLiterals < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Use `%%%s` instead of `%%%s`.'
+
+        def on_dstr(node)
+          check(node)
+        end
+
+        def on_str(node)
+          check(node)
+        end
+
+        private
+
+        def check(node)
+          return if node.loc.respond_to?(:heredoc_body)
+          return unless node.loc.respond_to?(:begin)
+          return unless node.loc.begin
+
+          msg = case node.loc.begin.source
+                when /^%[^\w]/
+                  format(MSG, 'Q', '') if style == :percent_q
+                when /^%Q/
+                  format(MSG, '', 'Q') if style == :bare_percent
+                end
+          add_offense(node, :begin, msg) if msg
+        end
+
+        def autocorrect(node)
+          src = node.loc.begin.source
+          replacement = src.start_with?('%Q') ? '%' : '%Q'
+          @corrections << lambda do |corrector|
+            corrector.replace(node.loc.begin, src.sub(/%Q?/, replacement))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks whether the end statement of a do end blocks
+      # is on its own line.
+      #
+      # @example
+      #   # bad
+      #   blah do |i|
+      #     foo(i) end
+      #
+      #   # good
+      #   blah do |i|
+      #     foo(i)
+      #   end
+      #
+      #   # bad
+      #   blah { |i|
+      #     foo(i) }
+      #
+      #   # good
+      #   blah { |i|
+      #     foo(i)
+      #   }
+      class BlockEndNewline < Cop
+        MSG = 'Expression at %d, %d should be on its own line.'
+
+        def on_block(node)
+          end_loc = node.loc.end
+          do_loc = node.loc.begin # Actually it's either do or {.
+          return if do_loc.line == end_loc.line # Ignore one-liners.
+
+          # If the end is on its own line, there is no offense
+          return if /^\s*#{end_loc.source}/.match(end_loc.source_line)
+
+          msg = format(MSG, end_loc.line, end_loc.column + 1)
+          add_offense(node, end_loc, msg)
+        end
+
+        def autocorrect(node)
+          @corrections << lambda do |corrector|
+            indentation = indentation_of_block_start_line(node)
+            corrector.insert_before(node.loc.end, "\n" + (' ' * indentation))
+          end
+        end
+
+        def indentation_of_block_start_line(node)
+          match = /\S.*/.match(node.loc.begin.source_line)
+          match.begin(0)
+        end
+      end
+    end
+  end
+end

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

@@ -22,7 +22,7 @@ module RuboCop
             if string.length == 1 # normal character
               corrector.replace(node.loc.expression, "'#{string}'")
             elsif string.length == 2 # special character like \n
-              corrector.replace(node.loc.expression, %Q("#{string}"))
+              corrector.replace(node.loc.expression, %("#{string}"))
             end
           end
         end

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

@@ -7,12 +7,12 @@ module RuboCop
       # that does not take any arguments. Both instance and
       # class/singleton methods are checked.
       class DefWithParentheses < Cop
-        include CheckMethods
+        include OnMethod
 
         MSG = "Omit the parentheses in defs when the method doesn't accept " \
               'any arguments.'
 
-        def check(node, _method_name, args, _body)
+        def on_method(node, _method_name, args, _body)
           start_line = node.loc.keyword.line
           end_line = node.loc.end.line
 

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

@@ -17,16 +17,44 @@ module RuboCop
           add_offense(node, :expression)
         end
 
+        def autocorrect(node)
+          @corrections << lambda do |corrector|
+            send_line = node.loc.line
+            previous_line = processed_source[send_line - 2]
+            next_line = processed_source[send_line]
+
+            line = Parser::Source::Range.new(
+              processed_source.buffer,
+              node.loc.expression.begin_pos - node.loc.column,
+              node.loc.expression.end_pos
+            )
+
+            unless previous_line_empty?(previous_line)
+              corrector.insert_before(line, "\n")
+            end
+
+            unless next_line_empty?(next_line)
+              corrector.insert_after(line, "\n")
+            end
+          end
+        end
+
         private
 
+        def previous_line_empty?(previous_line)
+          class_def?(previous_line.lstrip) || previous_line.blank?
+        end
+
+        def next_line_empty?(next_line)
+          next_line.blank?
+        end
+
         def empty_lines_around?(node)
           send_line = node.loc.line
           previous_line = processed_source[send_line - 2]
           next_line = processed_source[send_line]
 
-          (class_def?(previous_line.lstrip) ||
-           previous_line.blank?) &&
-            next_line.blank?
+          previous_line_empty?(previous_line) && next_line_empty?(next_line)
         end
 
         def class_def?(line)

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

@@ -22,7 +22,7 @@ module RuboCop
       #   end
       #
       class EmptyLinesAroundBody < Cop
-        include CheckMethods
+        include OnMethod
 
         MSG_BEG = 'Extra empty line detected at body beginning.'
         MSG_END = 'Extra empty line detected at body end.'
@@ -45,7 +45,11 @@ module RuboCop
 
         private
 
-        def check(node, *_)
+        def on_method(node, _method_name, _args, _body)
+          check(node)
+        end
+
+        def check(node)
           start_line = node.loc.keyword.line
           end_line = node.loc.end.line
 

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

@@ -8,28 +8,17 @@ module RuboCop
         MSG = 'Carriage return character detected.'
 
         def investigate(processed_source)
-          buffer = processed_source.buffer
-          original_source = IO.read(buffer.name, encoding: 'ascii-8bit')
-          change_encoding(original_source)
-
-          original_source.lines.each_with_index do |line, index|
+          processed_source.raw_source.each_line.with_index do |line, index|
             next unless line =~ /\r$/
 
-            range = source_range(buffer, index + 1, 0, line.length)
+            range =
+              source_range(processed_source.buffer, index + 1, 0, line.length)
             add_offense(nil, range, MSG)
             # Usually there will be carriage return characters on all or none
             # of the lines in a file, so we report only one offense.
             break
           end
         end
-
-        private
-
-        def change_encoding(string)
-          recognized_encoding =
-            Parser::Source::Buffer.recognize_encoding(string)
-          string.force_encoding(recognized_encoding) if recognized_encoding
-        end
       end
     end
   end

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

@@ -9,7 +9,7 @@ module RuboCop
       class IfUnlessModifier < Cop
         include StatementModifier
 
-        def error_message(keyword)
+        def message(keyword)
           "Favor modifier `#{keyword}` usage when having a single-line body." \
           ' Another good alternative is the usage of control flow `&&`/`||`.'
         end
@@ -22,11 +22,8 @@ module RuboCop
             next if modifier_if?(node)
             next if elsif?(node)
             next if if_else?(node)
-
-            if check(node, processed_source.comments)
-              add_offense(node, :keyword,
-                          error_message(node.loc.keyword.source))
-            end
+            next unless fit_within_line_as_modifier_form?(node)
+            add_offense(node, :keyword, message(node.loc.keyword.source))
           end
         end
       end

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

@@ -5,15 +5,14 @@ module RuboCop
     module Style
       # Checks for uses of semicolon in if statements.
       class IfWithSemicolon < Cop
-        include IfThenElse
+        include OnNormalIfUnless
 
-        def offending_line(node)
-          b = node.loc.begin
-          b.line if b && b.is?(';')
-        end
+        MSG = 'Never use if x; Use the ternary operator instead.'
 
-        def error_message(_node)
-          'Never use if x; Use the ternary operator instead.'
+        def on_normal_if_unless(node)
+          beginning = node.loc.begin
+          return unless beginning && beginning.is?(';')
+          add_offense(node, :expression, MSG)
         end
       end
     end

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

@@ -12,9 +12,9 @@ module RuboCop
       #   puts 'hello'
       #  end
       # end
-      class IndentationWidth < Cop # rubocop:disable Style/ClassLength
+      class IndentationWidth < Cop # rubocop:disable Metrics/ClassLength
         include AutocorrectAlignment
-        include CheckMethods
+        include OnMethod
         include CheckAssignment
         include IfNode
         include AccessModifierNode
@@ -72,7 +72,7 @@ module RuboCop
           ignore_node(args.first)
         end
 
-        def check(node, _method_name, _args, body)
+        def on_method(node, _method_name, _args, body)
           check_indentation(node.loc.keyword, body) unless ignored_node?(node)
         end
 
@@ -140,11 +140,6 @@ module RuboCop
 
         private
 
-        def begins_its_line?(range)
-          source_before_end = range.source_buffer.source[0...range.begin_pos]
-          source_before_end =~ /\n\s*\Z/
-        end
-
         def check_assignment(node, rhs)
           # If there are method calls chained to the right hand side of the
           # assignment, we let rhs be the receiver of those method calls before

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

@@ -6,10 +6,10 @@ module RuboCop
       # This cops checks for parentheses around the arguments in method
       # definitions. Both instance and class/singleton methods are checked.
       class MethodDefParentheses < Cop
-        include CheckMethods
+        include OnMethod
         include ConfigurableEnforcedStyle
 
-        def check(node, _method_name, args, _body)
+        def on_method(node, _method_name, args, _body)
           if style == :require_parentheses
             if arguments?(args) && !parentheses?(args)
               add_offense(node,

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

@@ -10,27 +10,13 @@ module RuboCop
         include ConfigurableNaming
 
         def on_def(node)
-          check(node, name_of_instance_method(node))
+          name, = *node
+          check_name(node, name, node.loc.name)
         end
 
         def on_defs(node)
-          check(node, name_of_singleton_method(node))
-        end
-
-        def name_of_instance_method(def_node)
-          expr = def_node.loc.expression
-          match = /^def(\s+)([\w]+[!?=]?\b)/.match(expr.source)
-          return unless match
-          space, method_name = match.captures
-          begin_pos = expr.begin_pos + 'def'.length + space.length
-          Parser::Source::Range.new(expr.source_buffer, begin_pos,
-                                    begin_pos + method_name.length)
-        end
-
-        def name_of_singleton_method(defs_node)
-          scope, method_name, _args, _body = *defs_node
-          after_dot(defs_node, method_name.length,
-                    "def\s+" + Regexp.escape(scope.loc.expression.source))
+          _object, name, = *node
+          check_name(node, name, node.loc.name)
         end
 
         def message(style)