rubocop 0.39.0 → 0.40.0

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

@@ -0,0 +1,96 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for case statements with an empty condition.
+      #
+      # @example
+      #
+      #   # bad:
+      #   case
+      #   when x == 0
+      #     puts 'x is 0'
+      #   when y == 0
+      #     puts 'y is 0'
+      #   else
+      #     puts 'neither is 0'
+      #   end
+      #
+      #   # good:
+      #   if x == 0
+      #     puts 'x is 0'
+      #   elsif y == 0
+      #     puts 'y is 0'
+      #   else
+      #     puts 'neither is 0'
+      #   end
+      #
+      #   # good: (the case condition node is not empty)
+      #   case n
+      #   when 0
+      #     puts 'zero'
+      #   when 1
+      #     puts 'one'
+      #   else
+      #     puts 'more'
+      #   end
+      class EmptyCaseCondition < Cop
+        MSG = 'Do not use empty `case` condition, instead use an `if` '\
+              'expression.'.freeze
+
+        def on_case(case_node)
+          condition_node = case_node.children.first
+
+          add_offense(case_node, :keyword, MSG) if condition_node.nil?
+        end
+
+        private
+
+        def autocorrect(case_node)
+          lambda do |corrector|
+            _cond_node, *when_nodes, _else_node = *case_node
+
+            correct_case_whens(corrector, case_node, when_nodes)
+
+            correct_multiple_alternative_whens(corrector, when_nodes)
+          end
+        end
+
+        def correct_case_whens(corrector, case_node, when_nodes)
+          case_to_first_when =
+            case_node.loc.keyword.join(when_nodes.first.loc.keyword)
+
+          corrector.replace(case_to_first_when, 'if')
+
+          when_nodes.drop(1).each do |when_node|
+            corrector.replace(when_node.loc.keyword, 'elsif')
+          end
+        end
+
+        # Since an if condition containing commas is not syntactically valid, we
+        # correct `when x, y` to `if x || y`.
+        def correct_multiple_alternative_whens(corrector, when_nodes)
+          when_nodes.each do |when_node|
+            # In `when a; r` we have two children: [a, r].
+            # In `when a, b, c; r` we have 4.
+            # In `when a, b then r` we have 3.
+            *children, _ = when_node.children
+
+            next unless children.size > 1
+
+            first = children.first
+            last = children.last
+            range =
+              Parser::Source::Range.new(when_node.loc.expression.source_buffer,
+                                        first.loc.expression.begin_pos,
+                                        last.loc.expression.end_pos)
+
+            corrector.replace(range, children.map(&:source).join(' || '))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -5,13 +5,15 @@ module RuboCop
   module Cop
     module Style
       # This cop checks whether the source file has a utf-8 encoding
-      # comment or not. This check makes sense only for code that
-      # should support Ruby 1.9, since in 2.0+ utf-8 is the default
-      # source file encoding. There are two styles:
+      # comment or not.
+      # Setting this check to "always" and "when_needed" makes sense only
+      # for code that should support Ruby 1.9, since in 2.0+ utf-8 is the
+      # default source file encoding. There are three styles:
       #
       # when_needed - only enforce an encoding comment if there are non ASCII
       #               characters, otherwise report an offense
       # always - enforce encoding comment in all files
+      # never - enforce no encoding comment in all files
       class Encoding < Cop
         include ConfigurableEnforcedStyle
 
@@ -56,10 +58,12 @@ module RuboCop
           encoding_present = line =~ ENCODING_PATTERN
           ascii_only = processed_source.buffer.source.ascii_only?
           always_encode = style == :always
+          never_encode = style == :never
+          encoding_omitable = never_encode || (!always_encode && ascii_only)
 
-          if !encoding_present && (always_encode || !ascii_only)
+          if !encoding_present && !encoding_omitable
             MSG_MISSING
-          elsif !always_encode && ascii_only && encoding_present
+          elsif encoding_present && encoding_omitable
             MSG_UNNECESSARY
           end
         end

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

@@ -67,16 +67,31 @@ module RuboCop
         end
 
         def check_assignment(token)
-          # minus 2 is because pos.line is zero-based
-          line = processed_source.lines[token.pos.line - 2]
-          return if aligned_assignment?(token.pos, line)
-
-          preceding  = @asgn_lines.include?(token.pos.line - 1)
-          align_with = preceding ? 'preceding' : 'following'
-          message    = format(MSG_UNALIGNED_ASGN, align_with)
+          assignment_line = ''
+          message = ''
+          if should_aligned_with_preceding_line?(token)
+            assignment_line = preceding_line(token)
+            message = format(MSG_UNALIGNED_ASGN, 'preceding')
+          else
+            assignment_line = following_line(token)
+            message = format(MSG_UNALIGNED_ASGN, 'following')
+          end
+          return if aligned_assignment?(token.pos, assignment_line)
           add_offense(token.pos, token.pos, message)
         end
 
+        def should_aligned_with_preceding_line?(token)
+          @asgn_lines.include?(token.pos.line - 1)
+        end
+
+        def preceding_line(token)
+          processed_source.lines[token.pos.line - 2]
+        end
+
+        def following_line(token)
+          processed_source.lines[token.pos.line]
+        end
+
         def check_other(t1, t2, ast)
           return if t1.pos.line != t2.pos.line
           return if t2.pos.begin_pos - 1 <= t1.pos.end_pos

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

@@ -10,7 +10,8 @@ module RuboCop
       # names. Ruby scripts (i.e. source files with a shebang in the
       # first line) are ignored.
       class FileName < Cop
-        MSG_SNAKE_CASE = 'Use snake_case for source file names.'.freeze
+        MSG_SNAKE_CASE = 'The name of this source file (`%s`) ' \
+                         'should use snake_case.'.freeze
         MSG_NO_DEFINITION = '%s should define a class or module ' \
                             'called `%s`.'.freeze
         MSG_REGEX = '`%s` should match `%s`.'.freeze
@@ -55,7 +56,11 @@ module RuboCop
         end
 
         def other_message(basename)
-          regex ? format(MSG_REGEX, basename, regex) : MSG_SNAKE_CASE
+          if regex
+            format(MSG_REGEX, basename, regex)
+          else
+            format(MSG_SNAKE_CASE, basename)
+          end
         end
 
         def shebang?(line)

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

@@ -61,15 +61,8 @@ module RuboCop
         end
 
         def on_if(node)
-          cond, body, else_body = *node
-
-          return unless body && else_body
-          # discard modifier ifs and ternary_ops
-          return if modifier_if?(node) || ternary_op?(node) || elsif?(node)
-
-          return unless single_line_control_flow_exit?(body) ||
-                        single_line_control_flow_exit?(else_body)
-          return if cond.multiline?
+          return if accept_form?(node)
+          return unless any_single_line_control_flow_exit?(node)
           return if line_too_long_when_corrected?(node)
 
           add_offense(node, :keyword, MSG)
@@ -77,6 +70,21 @@ module RuboCop
 
         private
 
+        def accept_form?(node)
+          cond, body, else_body = *node
+          return true unless body && else_body
+          return true if modifier_if?(node) || ternary?(node) || elsif?(node)
+
+          cond.multiline?
+        end
+
+        def any_single_line_control_flow_exit?(node)
+          _cond, body, else_body = *node
+
+          single_line_control_flow_exit?(body) ||
+            single_line_control_flow_exit?(else_body)
+        end
+
         def if?(node)
           node && node.if_type?
         end
@@ -92,7 +100,7 @@ module RuboCop
 
           return if body && else_body
           # discard modifier ifs and ternary_ops
-          return if modifier_if?(node) || ternary_op?(node)
+          return if modifier_if?(node) || ternary?(node)
           return if cond.multiline?
           # discard short ifs
           return unless min_body_length?(node)

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

@@ -37,7 +37,7 @@ module RuboCop
           _cond, _if_branch, else_branch = *node
           return unless else_branch
           return unless else_branch.if_type?
-          return if ternary_op?(node) || ternary_op?(else_branch)
+          return if ternary?(node) || ternary?(else_branch)
           return unless else_branch.loc.keyword.is?('if')
           return if node.loc.keyword.is?('unless')
 

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

@@ -8,6 +8,7 @@ module RuboCop
       # if written as a modifier if/unless.
       # The maximum line length is configurable.
       class IfUnlessModifier < Cop
+        include IfNode
         include StatementModifier
 
         ASSIGNMENT_TYPES = [:lvasgn, :casgn, :cvasgn,
@@ -20,7 +21,7 @@ module RuboCop
 
         def on_if(node)
           # discard ternary ops, if/else and modifier if/unless nodes
-          return if ternary_op?(node)
+          return if ternary?(node)
           return if modifier_if?(node)
           return if elsif?(node)
           return if if_else?(node)

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

@@ -152,7 +152,7 @@ module RuboCop
 
         def on_if(node, base = node)
           return if ignored_node?(node)
-          return if ternary_op?(node)
+          return if ternary?(node)
           return if modifier_if?(node)
 
           _condition, body, else_clause = if_node_parts(node)
@@ -183,7 +183,7 @@ module RuboCop
         end
 
         def check_if(node, body, else_clause, base_loc)
-          return if ternary_op?(node)
+          return if ternary?(node)
 
           check_indentation(base_loc, body)
           return unless else_clause
@@ -202,10 +202,13 @@ module RuboCop
           @column_delta = configured_indentation_width - indentation
           return if @column_delta == 0
 
+          offense(body_node, indentation, style)
+        end
+
+        def offense(body_node, indentation, style)
           # This cop only auto-corrects the first statement in a def body, for
           # example.
-          if body_node.type == :begin && !(body_node.loc.begin &&
-                                           body_node.loc.begin.is?('('))
+          if body_node.type == :begin && !parentheses?(body_node)
             body_node = body_node.children.first
           end
 

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

@@ -4,15 +4,72 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for uses of the pre 1.9 lambda syntax for one-line
-      # anonymous functions and uses of the 1.9 lambda syntax for multi-line
-      # anonymous functions.
+      # This cop (by default) checks for uses of the lambda literal syntax for
+      # single line lambdas, and the method call syntax for multiline lambdas.
+      # It is configurable to enforce one of the styles for both single line
+      # and multiline lambdas as well.
+      #
+      # @example
+      #
+      #   # EnforcedStyle: line_count_dependent (default)
+      #
+      #   # bad
+      #   f = lambda { |x| x }
+      #   f = ->(x) do
+      #         x
+      #       end
+      #
+      #   # good
+      #   f = ->(x) { x }
+      #   f = lambda do |x|
+      #         x
+      #       end
+      #
+      # @example
+      #
+      #   # EnforcedStyle: lambda
+      #
+      #   # bad
+      #   f = ->(x) { x }
+      #   f = ->(x) do
+      #         x
+      #       end
+      #
+      #   # good
+      #   f = lambda { |x| x }
+      #   f = lambda do |x|
+      #         x
+      #       end
+      #
+      # @example
+      #
+      #   # EnforcedStyle: literal
+      #
+      #   # bad
+      #   f = lambda { |x| x }
+      #   f = lambda do |x|
+      #         x
+      #       end
+      #
+      #   # good
+      #   f = ->(x) { x }
+      #   f = ->(x) do
+      #         x
+      #       end
       class Lambda < Cop
-        SINGLE_MSG = 'Use the new lambda literal syntax ' \
-                     '`->(params) {...}`.'.freeze
-        SINGLE_NO_ARG_MSG = 'Use the new lambda literal syntax ' \
-                            '`-> {...}`.'.freeze
-        MULTI_MSG = 'Use the `lambda` method for multi-line lambdas.'.freeze
+        include ConfigurableEnforcedStyle
+
+        LITERAL_MESSAGE = 'Use the `-> { ... }` lambda literal syntax for ' \
+                          '%s lambdas.'.freeze
+        METHOD_MESSAGE = 'Use the `lambda` method for %s lambdas.'.freeze
+
+        OFFENDING_SELECTORS = {
+          style: {
+            lambda: { single_line: '->', multiline: '->' },
+            literal: { single_line: 'lambda', multiline: 'lambda' },
+            line_count_dependent: { single_line: 'lambda', multiline: '->' }
+          }
+        }.freeze
 
         TARGET = s(:send, nil, :lambda)
 
@@ -21,34 +78,45 @@ module RuboCop
           # (block
           #   (send nil :lambda)
           #   ...)
-          block_method, args, = *node
+          block_method, _args, = *node
 
           return unless block_method == TARGET
-          selector = block_method.source
-          length = lambda_length(node)
 
-          if selector != '->' && length == 1
-            add_offense_for_single_line(node, block_method.source_range, args)
-          elsif selector == '->' && length > 1
-            add_offense(node, block_method.source_range, MULTI_MSG)
-          end
+          check(node)
         end
 
         private
 
-        def add_offense_for_single_line(block_node, location, args)
-          if args.children.empty?
-            add_offense(block_node, location, SINGLE_NO_ARG_MSG)
-          else
-            add_offense(block_node, location, SINGLE_MSG)
+        def check(node)
+          block_method, _args, = *node
+
+          selector = block_method.source
+
+          if offending_selector?(node, selector)
+            add_offense(node, block_method.source_range,
+                        message(node, selector))
           end
         end
 
-        def lambda_length(block_node)
-          start_line = block_node.loc.begin.line
-          end_line = block_node.loc.end.line
+        def offending_selector?(node, selector)
+          lines = node.multiline? ? :multiline : :single_line
 
-          end_line - start_line + 1
+          selector == OFFENDING_SELECTORS[:style][style][lines]
+        end
+
+        def message(node, selector)
+          message = (selector == '->') ? METHOD_MESSAGE : LITERAL_MESSAGE
+
+          format(message, message_line_modifier(node))
+        end
+
+        def message_line_modifier(node)
+          case style
+          when :line_count_dependent
+            node.multiline? ? 'multiline' : 'single line'
+          else
+            'all'
+          end
         end
 
         def autocorrect(node)
@@ -59,15 +127,15 @@ module RuboCop
           return if selector == '->' && arg_to_unparenthesized_call?(node)
 
           lambda do |corrector|
-            if block_method.source == 'lambda'
-              autocorrect_old_to_new(corrector, node)
+            if selector == 'lambda'
+              autocorrect_method_to_literal(corrector, node)
             else
-              autocorrect_new_to_old(corrector, node)
+              autocorrect_literal_to_method(corrector, node)
             end
           end
         end
 
-        def autocorrect_new_to_old(corrector, node)
+        def autocorrect_literal_to_method(corrector, node)
           block_method, args = *node
           # Avoid correcting to `lambdado` by inserting whitespace
           # if none exists before or after the lambda arguments.
@@ -81,7 +149,7 @@ module RuboCop
           corrector.insert_after(node.loc.begin, arg_str)
         end
 
-        def autocorrect_old_to_new(corrector, node)
+        def autocorrect_method_to_literal(corrector, node)
           block_method, args = *node
           corrector.replace(block_method.source_range, '->')
           return if args.children.empty?