rubocop 0.20.1 → 0.21.0

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

@@ -0,0 +1,81 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Lint
+      # This cop checks for unused block arguments.
+      #
+      # @example
+      #
+      #   do_something do |used, unused, _unused_but_allowed|
+      #     puts used
+      #   end
+      class UnusedBlockArgument < Cop
+        include Util
+
+        def join_force?(force_class)
+          force_class == VariableForce
+        end
+
+        def after_leaving_scope(scope, _variable_table)
+          scope.variables.each_value do |variable|
+            check_argument(variable)
+          end
+        end
+
+        def check_argument(variable)
+          return unless variable.block_argument?
+          return if variable.name.to_s.start_with?('_')
+          return if variable.referenced?
+
+          message = message(variable)
+          add_offense(variable.declaration_node, :name, message)
+        end
+
+        def message(variable)
+          message = "Unused block argument - `#{variable.name}`. "
+
+          scope = variable.scope
+          all_arguments = scope.variables.each_value.select(&:block_argument?)
+
+          if lambda?(scope.node)
+            message << message_for_lambda(variable, all_arguments)
+          else
+            message << message_for_normal_block(variable, all_arguments)
+          end
+
+          message
+        end
+
+        def message_for_normal_block(variable, all_arguments)
+          if all_arguments.none?(&:referenced?)
+            if all_arguments.count > 1
+              "You can omit all the arguments if you don't care about them."
+            else
+              "You can omit the argument if you don't care about it."
+            end
+          else
+            message_for_underscore_prefix(variable)
+          end
+        end
+
+        def message_for_lambda(variable, all_arguments)
+          message = message_for_underscore_prefix(variable)
+
+          if all_arguments.none?(&:referenced?)
+            message << ' Also consider using a proc without arguments ' \
+                       'instead of a lambda if you want it ' \
+                        "to accept any arguments but don't care about them."
+          end
+
+          message
+        end
+
+        def message_for_underscore_prefix(variable)
+          "If it's necessary, use `_` or `_#{variable.name}` " \
+          "as an argument name to indicate that it won't be used."
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Lint
+      # This cop checks for unused method arguments.
+      #
+      # @example
+      #
+      #   def some_method(used, unused, _unused_but_allowed)
+      #     puts used
+      #   end
+      class UnusedMethodArgument < Cop
+        def join_force?(force_class)
+          force_class == VariableForce
+        end
+
+        def after_leaving_scope(scope, _variable_table)
+          scope.variables.each_value do |variable|
+            check_argument(variable)
+          end
+        end
+
+        def check_argument(variable)
+          return unless variable.method_argument?
+          return if variable.name.to_s.start_with?('_')
+          return if variable.referenced?
+
+          message = message(variable)
+          add_offense(variable.declaration_node, :name, message)
+        end
+
+        def message(variable)
+          message = "Unused method argument - `#{variable.name}`. " \
+                    "If it's necessary, use `_` or `_#{variable.name}` " \
+                    "as an argument name to indicate that it won't be used."
+
+          scope = variable.scope
+          all_arguments = scope.variables.each_value.select(&:method_argument?)
+
+          if all_arguments.none?(&:referenced?)
+            message << " You can also write as `#{scope.name}(*)` " \
+                       'if you want the method to accept any arguments ' \
+                       "but don't care about them."
+          end
+
+          message
+        end
+      end
+    end
+  end
+end

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

@@ -13,15 +13,13 @@ module Rubocop
       # reassignments and properly handles varied cases such as branch, loop,
       # rescue, ensure, etc.
       class UselessAssignment < Cop
-        include VariableInspector
+        MSG = 'Useless assignment to variable - `%s`.'
 
-        MSG = 'Useless assignment to variable - %s'
-
-        def investigate(processed_source)
-          inspect_variables(processed_source.ast)
+        def join_force?(force_class)
+          force_class == VariableForce
         end
 
-        def after_leaving_scope(scope)
+        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)
@@ -52,13 +50,13 @@ module Rubocop
           message = format(MSG, variable.name)
 
           if assignment.multiple_assignment?
-            message << ". Use _ or _#{variable.name} as a variable name " \
+            message << " Use `_` or `_#{variable.name}` as a variable name " \
                        "to indicate that it won't be used."
           elsif assignment.operator_assignment?
             return_value_node = return_value_node_of_scope(variable.scope)
             if assignment.meta_assignment_node.equal?(return_value_node)
               non_assignment_operator = assignment.operator.sub(/=$/, '')
-              message << ". Use just operator #{non_assignment_operator}."
+              message << " Use just operator `#{non_assignment_operator}`."
             end
           end
 

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

@@ -14,11 +14,17 @@ module Rubocop
       class UselessElseWithoutRescue < Cop
         include ParserDiagnostic
 
+        MSG = '`else` without `rescue` is useless.'
+
         private
 
         def relevant_diagnostic?(diagnostic)
           diagnostic.reason == :useless_else
         end
+
+        def alternative_message(_diagnostic)
+          MSG
+        end
       end
     end
   end

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

@@ -15,7 +15,7 @@ module Rubocop
       class UselessSetterCall < Cop
         include CheckMethods
 
-        MSG = 'Useless setter call to local variable %s.'
+        MSG = 'Useless setter call to local variable `%s`.'
         ASSIGNMENT_TYPES = [:lvasgn, :ivasgn, :cvasgn, :gvasgn].freeze
 
         private

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

@@ -8,7 +8,7 @@ module Rubocop
       class Void < Cop
         OP_MSG = 'Operator `%s` used in void context.'
         VAR_MSG = 'Variable `%s` used in void context.'
-        LIT_MSG = 'Literal `%s` used in void context'
+        LIT_MSG = 'Literal `%s` used in void context.'
 
         OPS = %w(* / % + - == === != < > <= >= <=>)
         VARS = [:ivar, :lvar, :cvar, :const]

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

@@ -29,7 +29,7 @@ module Rubocop
 
         @corrections << lambda do |corrector|
           expr = node.loc.expression
-          each_line(expr) do |line_begin_pos, line|
+          each_line(expr) do |line_begin_pos|
             range = calculate_range(expr, line_begin_pos, column_delta)
             if column_delta > 0
               unless range.source == "\n"
@@ -70,7 +70,7 @@ module Rubocop
         offset = 0
         expr.source.each_line do |line|
           line_begin_pos = expr.begin_pos + offset
-          yield line_begin_pos, line
+          yield line_begin_pos
           offset += line.length
         end
       end

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

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

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

@@ -21,6 +21,17 @@ module Rubocop
         _lhs, _op, rhs = *node
         check_assignment(node, rhs)
       end
+
+      def on_send(node)
+        _receiver, method_name, *_, rhs = *node
+
+        # we only want to indent relative to the receiver
+        # when the method called looks like a setter
+        return unless method_name.to_s.end_with?('=')
+
+        # This will match if, case, begin, blocks, etc.
+        check_assignment(node, rhs) if rhs.is_a?(AST::Node)
+      end
     end
   end
 end

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

@@ -13,6 +13,18 @@ module Rubocop
         _scope, method_name, args, body = *node
         check(node, method_name, args, body)
       end
+
+      private
+
+      # Returns true for constructs such as
+      # private def my_method
+      # which are allowed in Ruby 2.1 and later.
+      def visibility_and_def_on_same_line?(receiver, method_name, args)
+        !receiver &&
+          [:public, :protected, :private,
+           :module_function].include?(method_name) &&
+          args.size == 1 && [:def, :defs].include?(args.first.type)
+      end
     end
   end
 end

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

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    # Common functionality for handling percent literals.
+    module PercentLiteral
+      def percent_literal?(node)
+        if (begin_source = begin_source(node))
+          begin_source.start_with?('%')
+        end
+      end
+
+      def process(node, *types)
+        on_percent_literal(node, types) if percent_literal?(node)
+      end
+
+      def begin_source(node)
+        node.loc.begin.source if node.loc.respond_to?(:begin) && node.loc.begin
+      end
+
+      def type(node)
+        node.loc.begin.source[0..-2]
+      end
+    end
+  end
+end

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

@@ -10,7 +10,7 @@ module Rubocop
       def investigate(processed_source)
         processed_source.tokens.each_cons(2) do |t1, t2|
           if kind(t1) && t1.pos.line == t2.pos.line &&
-              t2.pos.column == t1.pos.column + offset(t1) &&
+              t2.pos.column == t1.pos.column + offset &&
               ![:tRPAREN, :tRBRACK].include?(t2.type)
             add_offense(t1, t1.pos, format(MSG, kind(t1)))
           end
@@ -19,7 +19,7 @@ module Rubocop
 
       # The normal offset, i.e., the distance from the punctuation
       # token where a space should be, is 1.
-      def offset(token)
+      def offset
         1
       end
 

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

@@ -20,10 +20,6 @@ module Rubocop
         end
       end
 
-      def on_dstr(node)
-        ignore_node(node)
-      end
-
       def on_regexp(node)
         ignore_node(node)
       end

data/lib/rubocop/cop/rails/delegate.rb

@@ -0,0 +1,109 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Rails
+      # This cop looks for delegations, that could have been created
+      # automatically with delegate method.
+      #
+      # @example
+      #   # bad
+      #   def bar
+      #     foo.bar
+      #   end
+      #
+      #   # good
+      #   delegate :bar, to: :foo
+      #
+      #   # bad
+      #   def foo_bar
+      #     foo.bar
+      #   end
+      #
+      #   # good
+      #   delegate :bar, to: :foo, prefix: true
+      #
+      #   # good
+      #   private
+      #   def bar
+      #     foo.bar
+      #   end
+      class Delegate < Cop
+        include CheckMethods
+
+        MSG = 'Use `delegate` to define delegations.'
+
+        private
+
+        def check(node, method_name, args, body)
+          return unless trivial_delegate?(method_name, args, body)
+          return if private_or_protected_delegation(node)
+          add_offense(node, :keyword, MSG)
+        end
+
+        def autocorrect(node)
+          method_name, args, body = *node
+          return unless trivial_delegate?(method_name, args, body)
+          return if private_or_protected_delegation(node)
+
+          delegation = ["delegate :#{body.children[1]}",
+                        "to: :#{body.children[0].children[1]}"]
+          if method_name == prefixed_method_name(body)
+            delegation << ['prefix: true']
+          end
+
+          @corrections << lambda do |corrector|
+            corrector.replace(node.loc.expression, delegation.join(', '))
+          end
+        end
+
+        def trivial_delegate?(method_name, args, body)
+          body && delegate?(body) &&
+            method_name_matches?(method_name, body) &&
+            arguments_match?(args, body)
+        end
+
+        def delegate?(body)
+          receiver, * = *body
+          receiver.children.none? { |n| n.is_a? Parser::AST::Node }
+        end
+
+        def arguments_match?(args, body)
+          _receiver, _method_name, *arguments = *body
+          arg_array = Array(args)
+          argument_array = Array(arguments)
+          arg_array.size == argument_array.size && (
+            arg_array == argument_array ||
+            arg_array.map(&:children) == argument_array.map(&:children)
+          )
+        end
+
+        def method_name_matches?(method_name, body)
+          _receiver, property_name, *_args = *body
+          method_name == property_name ||
+            method_name == prefixed_method_name(body)
+        end
+
+        def prefixed_method_name(body)
+          receiver, property_name, *_args = *body
+          _receiver, target, *_args = *receiver
+          [target, property_name].join('_').to_sym
+        end
+
+        def private_or_protected_delegation(node)
+          line = node.loc.line
+          private_or_protected_before(line) ||
+            private_or_protected_inline(line)
+        end
+
+        def private_or_protected_before(line)
+          (processed_source[0..line].map(&:strip) & %w(private protected)).any?
+        end
+
+        def private_or_protected_inline(line)
+          processed_source[line - 1].strip =~ /\A(private )|(protected )/
+        end
+      end
+    end
+  end
+end