rubocop 0.16.0 → 0.17.0

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

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # Checks for uses of while with a negated condition.
+      class FavorUntilOverNegatedWhile < Cop
+        include NegativeConditional
+
+        def on_while(node)
+          check(node)
+        end
+
+        def error_message
+          'Favor until over while for negative conditions.'
+        end
+      end
+    end
+  end
+end

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

@@ -67,7 +67,11 @@ module Rubocop
             if pair.loc.operator && pair.loc.operator.is?(delim)
               add_offence(pair,
                           pair.loc.expression.begin.join(pair.loc.operator),
-                          msg)
+                          msg) do
+                opposite_style_detected
+              end
+            else
+              correct_style_detected
             end
           end
         end

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

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # Checks for if and unless statements that would fit on one line
+      # if written as a modifier if/unless.
+      class IfUnlessModifier < Cop
+        include StatementModifier
+
+        def error_message(keyword)
+          "Favor modifier #{keyword} usage when you have a single-line body." \
+          ' Another good alternative is the usage of control flow &&/||.'
+        end
+
+        def investigate(processed_source)
+          return unless processed_source.ast
+          on_node(:if, processed_source.ast) do |node|
+            # discard ternary ops, if/else and modifier if/unless nodes
+            next if ternary_op?(node)
+            next if modifier_if?(node)
+            next if elsif?(node)
+            next if if_else?(node)
+
+            if check(node, processed_source.comments)
+              add_offence(node, :keyword,
+                          error_message(node.loc.keyword.source))
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -11,7 +11,7 @@ module Rubocop
           node.loc.begin.line if node.loc.begin && node.loc.begin.is?(';')
         end
 
-        def error_message
+        def error_message(_node)
           'Never use if x; Use the ternary operator instead.'
         end
       end

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

@@ -0,0 +1,51 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cops checks for inconsistent indentation.
+      #
+      # @example
+      #
+      # class A
+      #   def test
+      #     puts 'hello'
+      #      puts 'world'
+      #   end
+      # end
+      class IndentationConsistency < Cop
+        MSG = 'Inconsistent indentation detected.'
+
+        def on_begin(node)
+          check(node)
+        end
+
+        def on_kwbegin(node)
+          check(node)
+        end
+
+        private
+
+        def check(node)
+          children_to_check = node.children.reject do |child|
+            # Don't check nodes that have special indentation and will be
+            # checked by the AccessModifierIndentation cop.
+            AccessModifierIndentation.modifier_node?(child)
+          end
+
+          children_to_check.map(&:loc).each_cons(2) do |child1, child2|
+            if child2.line > child1.line && child2.column != child1.column
+              expr = child2.expression
+              indentation = expr.source_line =~ /\S/
+              end_pos = expr.begin_pos
+              begin_pos = end_pos - indentation
+              add_offence(nil,
+                          Parser::Source::Range.new(expr.source_buffer,
+                                                    begin_pos, end_pos))
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -19,13 +19,8 @@ module Rubocop
 
         CORRECT_INDENTATION = 2
 
-        def on_begin(node)
-          check_consistent(node)
-        end
-
         def on_kwbegin(node)
           check_indentation(node.loc.end, node.children.first)
-          check_consistent(node)
         end
 
         def on_block(node)
@@ -155,27 +150,6 @@ module Rubocop
           body_node.type == :begin &&
             AccessModifierIndentation.modifier_node?(body_node.children.first)
         end
-
-        def check_consistent(node)
-          children_to_check = node.children.reject do |child|
-            # Don't check nodes that have special indentation and will be
-            # checked by the AccessModifierIndentation cop.
-            AccessModifierIndentation.modifier_node?(child)
-          end
-
-          children_to_check.map(&:loc).each_cons(2) do |child1, child2|
-            if child2.line > child1.line && child2.column != child1.column
-              expr = child2.expression
-              indentation = expr.source_line =~ /\S/
-              end_pos = expr.begin_pos
-              begin_pos = end_pos - indentation
-              add_offence(nil,
-                          Parser::Source::Range.new(expr.source_buffer,
-                                                    begin_pos, end_pos),
-                          'Inconsistent indentation detected.')
-            end
-          end
-        end
       end
     end
   end

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

@@ -21,14 +21,21 @@ module Rubocop
           # we care only about `call` methods
           return unless selector == :call
 
-          if style == :call && node.loc.selector.nil?
-            # lambda.() does not have a selector
-            add_offence(node, :expression)
-          elsif style == :braces && node.loc.selector
-            add_offence(node, :expression)
+          if offence?(node)
+            add_offence(node, :expression) { opposite_style_detected }
+          else
+            correct_style_detected
           end
         end
 
+        private
+
+        def offence?(node)
+          # lambda.() does not have a selector
+          style == :call && node.loc.selector.nil? ||
+            style == :braces && node.loc.selector
+        end
+
         def autocorrect(node)
           @corrections << lambda do |corrector|
             if style == :call

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

@@ -10,23 +10,31 @@ module Rubocop
         include ConfigurableEnforcedStyle
 
         def check(node, _method_name, args, _body)
-          if style == :require_parentheses &&
-              arguments?(args) &&
-              !parentheses?(args)
-            add_offence(node,
-                        args.loc.expression,
-                        'Use def with parentheses when there are parameters.')
-          elsif style == :require_no_parentheses && parentheses?(args)
-            add_offence(args,
-                        :expression,
-                        'Use def without parentheses.')
+          if style == :require_parentheses
+            if arguments?(args) && !parentheses?(args)
+              add_offence(node,
+                          args.loc.expression,
+                          'Use def with parentheses when there are ' \
+                          'parameters.') do
+                opposite_style_detected
+              end
+            else
+              correct_style_detected
+            end
+          elsif parentheses?(args)
+            add_offence(args, :expression, 'Use def without parentheses.') do
+              opposite_style_detected
+            end
+          else
+            correct_style_detected
           end
         end
 
         def autocorrect(node)
           @corrections << lambda do |corrector|
             if style == :require_parentheses
-              corrector.insert_after(node.children[1].loc.expression, ')')
+
+              corrector.insert_after(args_node(node).loc.expression, ')')
               expression = node.loc.expression
               replacement = expression.source.sub(/(def\s+\S+)\s+/, '\1(')
               corrector.replace(expression, replacement)
@@ -39,6 +47,16 @@ module Rubocop
 
         private
 
+        def args_node(def_node)
+          if def_node.type == :def
+            _method_name, args, _body = *def_node
+            args
+          else
+            _scope, _method_name, args, _body = *def_node
+            args
+          end
+        end
+
         def arguments?(args)
           args.children.size > 0
         end

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

@@ -16,6 +16,7 @@ module Rubocop
       #   elsif cond then b
       #   end
       class MultilineIfThen < Cop
+        include IfNode
         include IfThenElse
 
         def offending_line(node)
@@ -37,17 +38,11 @@ module Rubocop
         end
 
         def end_position(conditional_node)
-          node = if conditional_node.type == :match_current_line
-                   conditional_node.children.first
-                 else
-                   conditional_node
-                 end
-
-          node.loc.expression.end.end_pos
+          conditional_node.loc.expression.end.end_pos
         end
 
-        def error_message
-          'Never use then for multi-line if/unless.'
+        def error_message(node)
+          "Never use then for multi-line #{node.loc.keyword.source}."
         end
       end
     end

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

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for multi-line ternary op expressions.
+      class MultilineTernaryOperator < Cop
+        MSG =
+          'Avoid multi-line ?: (the ternary operator); use if/unless instead.'
+
+        def on_if(node)
+          loc = node.loc
+
+          # discard non-ternary ops
+          return unless loc.respond_to?(:question)
+
+          add_offence(node, :expression) if loc.line != loc.colon.line
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/{ternary_operator.rb → nested_ternary_operator.rb}

@@ -3,21 +3,6 @@
 module Rubocop
   module Cop
     module Style
-      # This cop checks for multi-line ternary op expressions.
-      class MultilineTernaryOperator < Cop
-        MSG =
-          'Avoid multi-line ?: (the ternary operator); use if/unless instead.'
-
-        def on_if(node)
-          loc = node.loc
-
-          # discard non-ternary ops
-          return unless loc.respond_to?(:question)
-
-          add_offence(node, :expression) if loc.line != loc.colon.line
-        end
-      end
-
       # This cop checks for nested ternary op expressions.
       class NestedTernaryOperator < Cop
         MSG = 'Ternary operators must not be nested. Prefer if/else ' +

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

@@ -6,6 +6,11 @@ module Rubocop
       # This cop checks for big numeric literals without _ between groups
       # of digits in them.
       class NumericLiterals < Cop
+        # The parameter is called MinDigits (meaning the minimum number of
+        # digits for which an offence can be registered), but essentially it's
+        # a Max parameter (the maximum number of something that's allowed).
+        include ConfigurableMax
+
         MSG = 'Separate every 3 digits in the integer portion of a number ' \
           'with underscores(_).'
 
@@ -19,6 +24,10 @@ module Rubocop
 
         private
 
+        def parameter_name
+          'MinDigits'
+        end
+
         def check(node)
           int = integer_part(node)
 
@@ -26,12 +35,31 @@ module Rubocop
           return if int.start_with?('0')
 
           if int.size >= min_digits
-            if int =~ /\d{4}/ || int =~ /_\d{1,2}_/
-              add_offence(node, :expression)
+            case int
+            when /^\d+$/
+              add_offence(node, :expression) { self.max = int.size }
+            when /\d{4}/, /_\d{1,2}_/
+              add_offence(node, :expression) do
+                self.config_to_allow_offences = { 'Enabled' => false }
+              end
             end
           end
         end
 
+        def autocorrect(node)
+          @corrections << lambda do |corrector|
+            int = node.loc.expression.source.to_i
+            formatted_int = int
+              .abs
+              .to_s
+              .reverse
+              .gsub(/...(?=.)/, '\&_')
+              .reverse
+            formatted_int.insert(0, '-') if int < 0
+            corrector.replace(node.loc.expression, formatted_int)
+          end
+        end
+
         def integer_part(node)
           node.loc.expression.source.sub(/^[+-]/, '').split('.').first
         end

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

@@ -3,6 +3,7 @@
 module Rubocop
   module Cop
     module Style
+      # TODO: Make configurable.
       # Checks for uses of if/then/else/end on a single line.
       class OneLineConditional < Cop
         include IfThenElse
@@ -11,7 +12,7 @@ module Rubocop
           node.loc.expression.line unless node.loc.expression.source =~ /\n/
         end
 
-        def error_message
+        def error_message(_node)
           'Favor the ternary operator (?:) over if/then/else/end constructs.'
         end
       end

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

@@ -8,12 +8,16 @@ module Rubocop
       # On Ruby 2.0+ keyword arguments can optionally
       # be excluded from the total count.
       class ParameterLists < Cop
+        include ConfigurableMax
+
         MSG = 'Avoid parameter lists longer than %d parameters.'
 
         def on_args(node)
-          if args_count(node) > max_params
-            add_offence(node, :expression,
-                        sprintf(MSG, max_params))
+          count = args_count(node)
+          if count > max_params
+            add_offence(node, :expression, sprintf(MSG, max_params)) do
+              self.max = count
+            end
           end
         end
 

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

@@ -4,13 +4,13 @@ module Rubocop
   module Cop
     module Style
       # This cop checks for the presence of superfluous parentheses around the
-      # condition of if/while/until.
+      # condition of if/unless/while/until.
       class ParenthesesAroundCondition < Cop
-        ASGN_NODES = [:lvasgn, :ivasgn, :cvasgn, :gvasgn, :casgn]
-        MSG = "Don't use parentheses around the condition of an " +
-          'if/unless/while/until'
+        include IfNode
+        include SafeAssignment
 
         def on_if(node)
+          return if ternary_op?(node)
           process_control_op(node)
         end
 
@@ -31,16 +31,14 @@ module Rubocop
             # allow safe assignment
             return if safe_assignment?(cond) && safe_assignment_allowed?
 
-            add_offence(cond, :expression)
+            add_offence(cond, :expression, message(node))
           end
         end
 
-        def safe_assignment?(node)
-          node.children.size == 1 && ASGN_NODES.include?(node.children[0].type)
-        end
-
-        def safe_assignment_allowed?
-          cop_config['AllowSafeAssignment']
+        def message(node)
+          kw = node.loc.keyword.source
+          article = kw == 'while' ? 'a' : 'an'
+          "Don't use parentheses around the condition of #{article} #{kw}."
         end
 
         def autocorrect(node)