rubocop 0.21.0 → 0.22.0

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

@@ -16,11 +16,11 @@ module Rubocop
 
       def check(node, *_)
         length = code_length(node)
-        if length > max_length
-          add_offense(node, :keyword, format(message, length,
-                                             max_length)) do
-            self.max = length
-          end
+        return unless length > max_length
+
+        add_offense(node, :keyword, format(message, length,
+                                           max_length)) do
+          self.max = length
         end
       end
 

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

@@ -11,13 +11,13 @@ module Rubocop
         # Look at last expression of contents if there's a parenthesis
         # around condition.
         condition = condition.children.last while condition.type == :begin
+        return unless condition.type == :send
 
-        if condition.type == :send
-          _object, method = *condition
-          if method == :! && !(node.loc.respond_to?(:else) && node.loc.else)
-            add_offense(node, :expression)
-          end
-        end
+        _object, method = *condition
+        return unless method == :! && !(node.loc.respond_to?(:else) &&
+                                        node.loc.else)
+
+        add_offense(node, :expression)
       end
     end
   end

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

@@ -5,9 +5,8 @@ module Rubocop
     # Common functionality for handling percent literals.
     module PercentLiteral
       def percent_literal?(node)
-        if (begin_source = begin_source(node))
-          begin_source.start_with?('%')
-        end
+        return unless (begin_source = begin_source(node))
+        begin_source.start_with?('%')
       end
 
       def process(node, *types)

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

@@ -9,11 +9,11 @@ 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 &&
-              ![:tRPAREN, :tRBRACK].include?(t2.type)
-            add_offense(t1, t1.pos, format(MSG, kind(t1)))
-          end
+          next unless kind(t1) && t1.pos.line == t2.pos.line &&
+            t2.pos.column == t1.pos.column + offset &&
+            ![:tRPAREN, :tRBRACK].include?(t2.type)
+
+          add_offense(t1, t1.pos, format(MSG, kind(t1)))
         end
       end
 

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

@@ -12,18 +12,17 @@ module Rubocop
         @processed_source = processed_source
         left, right, kind = specifics
         processed_source.tokens.each_cons(2) do |t1, t2|
-          if t1.type == left || t2.type == right
-            # If the second token is a comment, that means that a line break
-            # follows, and that the rules for space inside don't apply.
-            next if t2.type == :tCOMMENT
+          next unless t1.type == left || t2.type == right
 
-            if t2.pos.line == t1.pos.line && space_between?(t1, t2)
-              range = Parser::Source::Range.new(processed_source.buffer,
-                                                t1.pos.end_pos,
-                                                t2.pos.begin_pos)
-              add_offense(range, range, format(MSG, kind))
-            end
-          end
+          # If the second token is a comment, that means that a line break
+          # follows, and that the rules for space inside don't apply.
+          next if t2.type == :tCOMMENT
+          next unless t2.pos.line == t1.pos.line && space_between?(t1, t2)
+
+          range = Parser::Source::Range.new(processed_source.buffer,
+                                            t1.pos.end_pos,
+                                            t2.pos.begin_pos)
+          add_offense(range, range, format(MSG, kind))
         end
       end
 

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

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Lint
+      # Common functionality for cops handling unused arguments.
+      module UnusedArgument
+        def join_force?(force_class)
+          force_class == VariableForce
+        end
+
+        def autocorrect(node)
+          new_name = node.loc.expression.source.sub(/(\W?)(\w+)/, '\\1_\\2')
+          @corrections << lambda do |corrector|
+            corrector.replace(node.loc.expression, new_name)
+          end
+        end
+
+        def after_leaving_scope(scope, _variable_table)
+          scope.variables.each_value do |variable|
+            check_argument(variable)
+          end
+        end
+
+        def check_argument(variable)
+          return if variable.name.to_s.start_with?('_')
+          return if variable.referenced?
+
+          message = message(variable)
+          add_offense(variable.declaration_node, :name, message)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/offense.rb

@@ -32,7 +32,7 @@ module Rubocop
       #   human-readable message
       #
       # @example
-      #   'Line is too long. [90/79]'
+      #   'Line is too long. [90/80]'
       attr_reader :message
 
       # @api public

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

@@ -41,15 +41,13 @@ module Rubocop
 
         def check_method_node(node)
           _receiver, method_name, *_args = *node
+          return unless offending_method?(method_name)
 
-          if offending_method?(method_name)
-            add_offense(
-              node, :selector,
-              format(MSG,
-                     preferred_method(method_name),
-                     method_name)
-            )
-          end
+          add_offense(node, :selector,
+                      format(MSG,
+                             preferred_method(method_name),
+                             method_name)
+                     )
         end
 
         def offending_method?(method_name)

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

@@ -20,14 +20,12 @@ module Rubocop
           return unless command?(:default_scope, node)
 
           _receiver, _method_name, *args = *node
-
           return unless args.size == 1
 
           first_arg = args[0]
+          return unless first_arg.type != :block || lambda_or_proc?(first_arg)
 
-          if first_arg.type != :block || lambda_or_proc?(first_arg)
-            add_offense(first_arg, :expression)
-          end
+          add_offense(first_arg, :expression)
         end
       end
     end

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

@@ -65,6 +65,8 @@ module Rubocop
 
         def delegate?(body)
           receiver, * = *body
+          return false unless receiver.is_a? Parser::AST::Node
+          return false unless receiver.type == :send
           receiver.children.none? { |n| n.is_a? Parser::AST::Node }
         end
 

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

@@ -8,9 +8,8 @@ module Rubocop
         MSG = 'Prefer `has_many :through` to `has_and_belongs_to_many`.'
 
         def on_send(node)
-          if command?(:has_and_belongs_to_many, node)
-            add_offense(node, :selector)
-          end
+          return unless command?(:has_and_belongs_to_many, node)
+          add_offense(node, :selector)
         end
       end
     end

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

@@ -15,10 +15,9 @@ module Rubocop
 
         def on_send(node)
           receiver, method_name, *_args = *node
+          return unless receiver.nil? && BLACKLIST.include?(method_name)
 
-          if receiver.nil? && BLACKLIST.include?(method_name)
-            add_offense(node, :selector)
-          end
+          add_offense(node, :selector)
         end
       end
     end

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

@@ -20,12 +20,11 @@ module Rubocop
 
         def on_send(node)
           receiver, method_name, *_args = *node
-
           return if receiver
+          return unless [:read_attribute,
+                         :write_attribute].include?(method_name)
 
-          if [:read_attribute, :write_attribute].include?(method_name)
-            add_offense(node, :selector)
-          end
+          add_offense(node, :selector)
         end
 
         def message(node)

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

@@ -20,10 +20,9 @@ module Rubocop
 
         def on_send(node)
           receiver, method_name, *_args = *node
+          return unless receiver.nil? && BLACKLIST.include?(method_name)
 
-          if receiver.nil? && BLACKLIST.include?(method_name)
-            add_offense(node, :selector)
-          end
+          add_offense(node, :selector)
         end
       end
     end

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

@@ -14,9 +14,9 @@ module Rubocop
 
           # using alias is the only option in certain scenarios
           # in such scenarios we don't want to report an offense
-          if method_name == :instance_exec
-            on_node(:alias, body) { |n| ignore_node(n) }
-          end
+          return unless method_name == :instance_exec
+
+          on_node(:alias, body) { |n| ignore_node(n) }
         end
 
         def on_alias(node)

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

@@ -147,10 +147,10 @@ module Rubocop
               'one line.'
 
         def on_send(node)
-          if (last_child = node.children.last) && hash?(last_child) &&
-              ignore_last_argument_hash?(last_child)
-            ignore_node(last_child)
-          end
+          return unless (last_child = node.children.last) &&
+            hash?(last_child) && ignore_last_argument_hash?(last_child)
+
+          ignore_node(last_child)
         end
 
         def on_hash(node)

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

@@ -28,11 +28,23 @@ module Rubocop
 
         def base_column(node, args)
           if fixed_indentation?
-            node.loc.column + 2
+            lineno = target_method_lineno(node)
+            line = node.loc.expression.source_buffer.source_line(lineno)
+            indentation_of_line = /\S.*/.match(line).begin(0)
+            indentation_of_line + 2
           else
             args.first.loc.column
           end
         end
+
+        def target_method_lineno(node)
+          if node.loc.selector
+            node.loc.selector.line
+          else
+            # l.(1) has no selector, so we use the opening parenthesis instead
+            node.loc.begin.line
+          end
+        end
       end
     end
   end

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

@@ -24,12 +24,9 @@ module Rubocop
         def process_logical_op(node)
           op = node.loc.operator.source
           op_type = node.type.to_s
+          return unless op == op_type
 
-          if op == op_type
-            add_offense(node,
-                        :operator,
-                        format(MSG, OPS[op], op))
-          end
+          add_offense(node, :operator, format(MSG, OPS[op], op))
         end
 
         def correction(node)

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

@@ -13,11 +13,10 @@ module Rubocop
 
         def on_send(node)
           receiver_node, method_name, *arg_nodes = *node
+          return unless receiver_node && receiver_node.type == :array &&
+            method_name == :* && arg_nodes[0].type == :str
 
-          if receiver_node && receiver_node.type == :array &&
-              method_name == :* && arg_nodes[0].type == :str
-            add_offense(node, :selector)
-          end
+          add_offense(node, :selector)
         end
       end
     end

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

@@ -9,9 +9,8 @@ module Rubocop
 
         def investigate(processed_source)
           processed_source.tokens.each do |t|
-            if t.type == :tIDENTIFIER && !t.text.ascii_only?
-              add_offense(nil, t.pos)
-            end
+            next unless t.type == :tIDENTIFIER && !t.text.ascii_only?
+            add_offense(nil, t.pos)
           end
         end
       end

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

@@ -9,9 +9,8 @@ module Rubocop
 
         def investigate(processed_source)
           processed_source.comments.each do |comment|
-            if comment.text.start_with?('=begin')
-              add_offense(comment, :expression)
-            end
+            next unless comment.text.start_with?('=begin')
+            add_offense(comment, :expression)
           end
         end
       end

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

@@ -40,9 +40,8 @@ module Rubocop
             end
           end
           node.children.each do |child|
-            if child.is_a?(Parser::AST::Node)
-              check_nesting_level(child, max, current_level)
-            end
+            next unless child.is_a?(Parser::AST::Node)
+            check_nesting_level(child, max, current_level)
           end
         end
 

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

@@ -13,15 +13,15 @@ module Rubocop
 
         def on_send(node)
           _receiver, method_name, *args = *node
-          if args.any?
-            block = get_block(args.last)
-            if block && !parentheses?(node) && !operator?(method_name)
-              # If there are no parentheses around the arguments, then braces
-              # and do-end have different meaning due to how they bind, so we
-              # allow either.
-              ignore_node(block)
-            end
-          end
+          return unless args.any?
+
+          block = get_block(args.last)
+          return unless block && !parentheses?(node) && !operator?(method_name)
+
+          # If there are no parentheses around the arguments, then braces and
+          # do-end have different meaning due to how they bind, so we allow
+          # either.
+          ignore_node(block)
         end
 
         def on_block(node)

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

@@ -63,11 +63,11 @@ module Rubocop
             Parser::Source::Range.new(sb, pos_after_last_pair,
                                       node.loc.end.begin_pos)
           trailing_comma_offset = range_after_last_pair.source =~ /,/
-          if trailing_comma_offset
-            comma_begin = pos_after_last_pair + trailing_comma_offset
-            corrector.remove(Parser::Source::Range.new(sb, comma_begin,
-                                                       comma_begin + 1))
-          end
+          return unless trailing_comma_offset
+
+          comma_begin = pos_after_last_pair + trailing_comma_offset
+          corrector.remove(Parser::Source::Range.new(sb, comma_begin,
+                                                     comma_begin + 1))
         end
 
         def non_empty_hash?(arg)

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

@@ -57,7 +57,7 @@ module Rubocop
         end
 
         def one_child?(body)
-          body && body.type != :begin
+          body && [:module, :class].include?(body.type)
         end
 
         def compact_node_name?(node)

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

@@ -33,12 +33,10 @@ module Rubocop
 
         def check_defs(node)
           definee, method_name, _args, _body = *node
+          return unless definee.type == :const
 
-          if definee.type == :const
-            _, class_name = *definee
-            add_offense(definee, :name,
-                        message(class_name, method_name))
-          end
+          _, class_name = *definee
+          add_offense(definee, :name, message(class_name, method_name))
         end
 
         def message(class_name, method_name)