rubocop 0.23.0 → 0.24.0

data/lib/rubocop/cop/lint/end_alignment.rb

@@ -7,18 +7,18 @@ module RuboCop
       #
       # Two modes are supported through the AlignWith configuration
       # parameter. If it's set to `keyword` (which is the default), the `end`
-      # shall be aligned with the start of the keyword (if, def, etc.). If it's
-      # set to `variable` the `end` shall be aligned with the left-hand-side of
-      # the variable assignment, if there is one.
+      # shall be aligned with the start of the keyword (if, class, etc.). If
+      # it's set to `variable` the `end` shall be aligned with the
+      # left-hand-side of the variable assignment, if there is one.
       #
       # @example
       #
       #   variable = if true
       #              end
       class EndAlignment < Cop
-        include CheckMethods
         include CheckAssignment
-        include ConfigurableEnforcedStyle
+        include EndKeywordAlignment
+        include IfNode
 
         MSG = '`end` at %d, %d is not aligned with `%s` at %d, %d'
 
@@ -31,7 +31,7 @@ module RuboCop
         end
 
         def on_if(node)
-          check(node) if node.loc.respond_to?(:end)
+          check(node) unless ternary_op?(node)
         end
 
         def on_while(node)
@@ -42,23 +42,6 @@ module RuboCop
           check(node)
         end
 
-        def on_send(node)
-          super
-
-          receiver, method_name, *args = *node
-          return unless visibility_and_def_on_same_line?(receiver, method_name,
-                                                         args)
-
-          expr = node.loc.expression
-          method_def = args.first
-          range = Parser::Source::Range.new(expr.source_buffer,
-                                            expr.begin_pos,
-                                            method_def.loc.keyword.end_pos)
-          check_offset(method_def, range.source,
-                       method_def.loc.keyword.begin_pos - expr.begin_pos)
-          ignore_node(method_def) # Don't check the same `end` again.
-        end
-
         private
 
         def check_assignment(node, rhs)
@@ -69,52 +52,22 @@ module RuboCop
 
           return unless rhs
 
-          case rhs.type
-          when :if, :while, :until
-            return if rhs.loc.respond_to?(:question) # ternary
-
-            if style == :variable
-              expr = node.loc.expression
-              range = Parser::Source::Range.new(expr.source_buffer,
-                                                expr.begin_pos,
-                                                rhs.loc.keyword.end_pos)
-              offset = rhs.loc.keyword.column - node.loc.expression.column
-            else
-              range = rhs.loc.keyword
-              offset = 0
-            end
-
-            check_offset(rhs, range.source, offset)
-            ignore_node(rhs) # Don't check again.
-          end
-        end
-
-        def check(node, *_)
-          check_offset(node, node.loc.keyword.source, 0)
-        end
-
-        def check_offset(node, alignment_base, offset)
-          return if ignored_node?(node)
+          return unless [:if, :while, :until].include?(rhs.type)
+          return if ternary_op?(rhs)
 
-          end_loc = node.loc.end
-          return unless end_loc # Discard modifier forms of if/while/until.
-
-          kw_loc = node.loc.keyword
-
-          if kw_loc.line != end_loc.line &&
-              kw_loc.column != end_loc.column + offset
-            add_offense(nil, end_loc,
-                        format(MSG, end_loc.line, end_loc.column,
-                               alignment_base, kw_loc.line, kw_loc.column)) do
-              opposite_style_detected
-            end
+          if style == :variable
+            expr = node.loc.expression
+            range = Parser::Source::Range.new(expr.source_buffer,
+                                              expr.begin_pos,
+                                              rhs.loc.keyword.end_pos)
+            offset = rhs.loc.keyword.column - node.loc.expression.column
           else
-            correct_style_detected
+            range = rhs.loc.keyword
+            offset = 0
           end
-        end
 
-        def parameter_name
-          'AlignWith'
+          check_offset(rhs, range.source, offset)
+          ignore_node(rhs) # Don't check again.
         end
       end
     end

data/lib/rubocop/cop/lint/shadowing_outer_local_variable.rb

@@ -15,7 +15,7 @@ module RuboCop
         end
 
         def before_declaring_variable(variable, variable_table)
-          return if variable.name.to_s.start_with?('_')
+          return if variable.should_be_unused?
 
           outer_local_variable = variable_table.find_variable(variable.name)
           return unless outer_local_variable

data/lib/rubocop/cop/lint/syntax.rb

@@ -4,14 +4,25 @@ module RuboCop
   module Cop
     module Lint
       # This is actually not a cop and inspects nothing. It just provides
-      # methods to repack Parser's diagnostics into RuboCop's offenses.
+      # methods to repack Parser's diagnostics/errors into RuboCop's offenses.
       module Syntax
+        PseudoSourceRange = Struct.new(:line, :column, :source_line)
+
         COP_NAME = 'Syntax'.freeze
+        ERROR_SOURCE_RANGE = PseudoSourceRange.new(1, 0, '').freeze
+
+        def self.offenses_from_processed_source(processed_source)
+          offenses = []
 
-        def self.offenses_from_diagnostics(diagnostics)
-          diagnostics.map do |diagnostic|
-            offense_from_diagnostic(diagnostic)
+          if processed_source.parser_error
+            offenses << offense_from_error(processed_source.parser_error)
           end
+
+          processed_source.diagnostics.each do |diagnostic|
+            offenses << offense_from_diagnostic(diagnostic)
+          end
+
+          offenses
         end
 
         def self.offense_from_diagnostic(diagnostic)
@@ -22,6 +33,19 @@ module RuboCop
             COP_NAME
           )
         end
+
+        def self.offense_from_error(error)
+          message = beautify_message(error.message)
+          Offense.new(:fatal, ERROR_SOURCE_RANGE, message, COP_NAME)
+        end
+
+        def self.beautify_message(message)
+          message = message.capitalize
+          message << '.' unless message.end_with?('.')
+          message
+        end
+
+        private_class_method :beautify_message
       end
     end
   end

data/lib/rubocop/cop/lint/underscore_prefixed_variable_name.rb

@@ -19,7 +19,7 @@ module RuboCop
         end
 
         def check_variable(variable)
-          return unless variable.name.to_s.start_with?('_')
+          return unless variable.should_be_unused?
           return if variable.references.empty?
           return if variable.references.none?(&:explicit?)
 

data/lib/rubocop/cop/lint/unused_block_argument.rb

@@ -20,7 +20,11 @@ module RuboCop
         end
 
         def message(variable)
-          message = "Unused block argument - `#{variable.name}`. "
+          message = "Unused #{variable_type(variable)} - `#{variable.name}`."
+
+          return message if variable.explicit_block_local_variable?
+
+          message << ' '
 
           scope = variable.scope
           all_arguments = scope.variables.each_value.select(&:block_argument?)
@@ -34,6 +38,14 @@ module RuboCop
           message
         end
 
+        def variable_type(variable)
+          if variable.explicit_block_local_variable?
+            'block local variable'
+          else
+            'block argument'
+          end
+        end
+
         def message_for_normal_block(variable, all_arguments)
           if all_arguments.none?(&:referenced?)
             if all_arguments.count > 1

data/lib/rubocop/cop/lint/useless_access_modifier.rb

@@ -12,6 +12,8 @@ module RuboCop
       #     end
       #   end
       class UselessAccessModifier < Cop
+        include AccessModifierNode
+
         MSG = 'Useless `%s` access modifier.'
 
         def on_class(node)
@@ -46,8 +48,7 @@ module RuboCop
         end
 
         def check_for_access_modifier(node)
-          return unless Style::AccessModifierIndentation
-            .modifier_node?(node)
+          return unless modifier_node?(node)
 
           add_offense_for_access_modifier
           @access_modifier_node = node

data/lib/rubocop/cop/lint/useless_assignment.rb

@@ -22,12 +22,11 @@ module RuboCop
         def after_leaving_scope(scope, _variable_table)
           scope.variables.each_value do |variable|
             check_for_unused_assignments(variable)
-            check_for_unused_block_local_variable(variable)
           end
         end
 
         def check_for_unused_assignments(variable)
-          return if variable.name.to_s.start_with?('_')
+          return if variable.should_be_unused?
 
           variable.assignments.each do |assignment|
             next if assignment.used?
@@ -73,13 +72,6 @@ module RuboCop
             body_node
           end
         end
-
-        def check_for_unused_block_local_variable(variable)
-          return unless variable.block_local_variable?
-          return unless variable.assignments.empty?
-          message = format(MSG, variable.name)
-          add_offense(variable.declaration_node, :expression, message)
-        end
       end
     end
   end

data/lib/rubocop/cop/lint/useless_setter_call.rb

@@ -17,10 +17,17 @@ module RuboCop
 
         MSG = 'Useless setter call to local variable `%s`.'
         ASSIGNMENT_TYPES = [:lvasgn, :ivasgn, :cvasgn, :gvasgn].freeze
+        LITERAL_TYPES = [
+          :true, :false, :nil,
+          :int, :float,
+          :str, :dstr, :sym, :dsym, :xstr, :regexp,
+          :array, :hash,
+          :irange, :erange
+        ].freeze
 
         private
 
-        def check(_node, _method_name, args, body)
+        def check(_node, _method_name, _args, body)
           return unless body
 
           if body.type == :begin
@@ -33,10 +40,10 @@ module RuboCop
 
           return unless setter_call_to_local_variable?(last_expr)
 
-          tracker = MethodVariableTracker.new(args, body)
+          tracker = MethodVariableTracker.new(body)
           receiver, = *last_expr
-          var_name, = *receiver
-          return if tracker.contain_object_passed_as_argument?(var_name)
+          variable_name, = *receiver
+          return unless tracker.contain_local_object?(variable_name)
 
           add_offense(receiver,
                       :name,
@@ -47,27 +54,21 @@ module RuboCop
           return unless node && node.type == :send
           receiver, method, _args = *node
           return unless receiver && receiver.type == :lvar
-          method =~ /\w=$/
+          method =~ /(?:\w|\[\])=$/
         end
 
         # This class tracks variable assignments in a method body
         # and if a variable contains object passed as argument at the end of
         # the method.
         class MethodVariableTracker
-          def initialize(args_node, body_node)
-            @args_node = args_node
+          def initialize(body_node)
             @body_node = body_node
           end
 
-          def contain_object_passed_as_argument?(variable_name)
-            return @table[variable_name] if @table
+          def contain_local_object?(variable_name)
+            return @local[variable_name] if @table
 
-            @table = {}
-
-            @args_node.children.each do |arg_node|
-              arg_name, = *arg_node
-              @table[arg_name] = true
-            end
+            @local = {}
 
             scan(@body_node) do |node|
               case node.type
@@ -83,7 +84,7 @@ module RuboCop
               end
             end
 
-            @table[variable_name]
+            @local[variable_name]
           end
 
           def scan(node, &block)
@@ -109,7 +110,7 @@ module RuboCop
               if mrhs_node.type == :array && rhs_node
                 process_assignment(lhs_variable_name, rhs_node)
               else
-                @table[lhs_variable_name] = false
+                @local[lhs_variable_name] = true
               end
             end
 
@@ -128,7 +129,7 @@ module RuboCop
             lhs_node, = *op_asgn_node
             return unless ASSIGNMENT_TYPES.include?(lhs_node.type)
             lhs_variable_name, = *lhs_node
-            @table[lhs_variable_name] = false
+            @local[lhs_variable_name] = true
 
             throw :skip_children
           end
@@ -138,11 +139,18 @@ module RuboCop
 
             if [:lvar, :ivar, :cvar, :gvar].include?(rhs_node.type)
               rhs_variable_name, = *rhs_node
-              @table[lhs_variable_name] = @table[rhs_variable_name]
+              @local[lhs_variable_name] = @local[rhs_variable_name]
             else
-              @table[lhs_variable_name] = false
+              @local[lhs_variable_name] = constructor?(rhs_node)
             end
           end
+
+          def constructor?(node)
+            return true if LITERAL_TYPES.include?(node.type)
+            return false unless node.type == :send
+            _receiver, method = *node
+            method == :new
+          end
         end
       end
     end

data/lib/rubocop/cop/mixin/access_modifier_node.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    # Common functionality for checking modifier nodes.
+    module AccessModifierNode
+      extend AST::Sexp
+
+      PRIVATE_NODE = s(:send, nil, :private)
+      PROTECTED_NODE = s(:send, nil, :protected)
+      PUBLIC_NODE = s(:send, nil, :public)
+
+      def modifier_node?(node)
+        [PRIVATE_NODE, PROTECTED_NODE, PUBLIC_NODE].include?(node)
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/autocorrect_unless_changing_ast.rb

@@ -11,13 +11,15 @@ module RuboCop
         new_source = rewrite_node(node)
 
         # Make the correction only if it doesn't change the AST.
-        fail CorrectionNotPossible if node != SourceParser.parse(new_source).ast
+        if node != ProcessedSource.new(new_source).ast
+          fail CorrectionNotPossible
+        end
 
         @corrections << c
       end
 
       def rewrite_node(node)
-        processed_source = SourceParser.parse(node.loc.expression.source)
+        processed_source = ProcessedSource.new(node.loc.expression.source)
         c = correction(processed_source.ast)
         Corrector.new(processed_source.buffer, [c]).rewrite
       end

data/lib/rubocop/cop/mixin/end_keyword_alignment.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    # Functions for checking the alignment of the `end` keyword.
+    module EndKeywordAlignment
+      include ConfigurableEnforcedStyle
+
+      MSG = '`end` at %d, %d is not aligned with `%s` at %d, %d'
+
+      private
+
+      def check(node, *_)
+        check_offset(node, node.loc.keyword.source, 0)
+      end
+
+      def check_offset(node, alignment_base, offset)
+        return if ignored_node?(node)
+
+        end_loc = node.loc.end
+        return unless end_loc # Discard modifier forms of if/while/until.
+
+        kw_loc = node.loc.keyword
+
+        if kw_loc.line != end_loc.line &&
+            kw_loc.column != end_loc.column + offset
+          add_offense(nil, end_loc,
+                      format(MSG, end_loc.line, end_loc.column,
+                             alignment_base, kw_loc.line, kw_loc.column)) do
+            opposite_style_detected
+          end
+        else
+          correct_style_detected
+        end
+      end
+
+      def parameter_name
+        'AlignWith'
+      end
+    end
+  end
+end