rubocop 0.29.1 → 0.30.0

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

@@ -16,6 +16,7 @@ module RuboCop
 
         MSG_MISSING = 'Missing utf-8 encoding comment.'
         MSG_UNNECESSARY = 'Unnecessary utf-8 encoding comment.'
+        ENCODING_PATTERN = /#.*coding\s?[:=]\s?(?:UTF|utf)-8/
 
         def investigate(processed_source)
           return if processed_source.buffer.source.empty?
@@ -26,14 +27,25 @@ module RuboCop
           return unless message
 
           range = source_range(processed_source.buffer, line_number + 1, 0)
-          add_offense(nil, range, message)
+          add_offense(processed_source.tokens.first, range, message)
+        end
+
+        def autocorrect(node)
+          encoding = cop_config['AutoCorrectEncodingComment']
+          if encoding && encoding =~ ENCODING_PATTERN
+            @corrections << lambda do |corrector|
+              corrector.replace(node.pos, "#{encoding}\n#{node.pos.source}")
+            end
+          else
+            fail "#{encoding} does not match #{ENCODING_PATTERN}"
+          end
         end
 
         private
 
         def offense(processed_source, line_number)
           line = processed_source[line_number]
-          encoding_present = line =~ /#.*coding\s?[:=]\s?(UTF|utf)-8/
+          encoding_present = line =~ ENCODING_PATTERN
           ascii_only = processed_source.buffer.source.ascii_only?
           always_encode = style == :always
 

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

@@ -8,7 +8,12 @@ module RuboCop
         MSG = 'Carriage return character detected.'
 
         def investigate(processed_source)
+          last_token = processed_source.tokens.last
+          last_line =
+            last_token ? last_token.pos.line : processed_source.lines.length
+
           processed_source.raw_source.each_line.with_index do |line, index|
+            break if index >= last_line
             next unless line =~ /\r$/
 
             range =

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

@@ -13,18 +13,30 @@ module RuboCop
         include ConfigurableEnforcedStyle
 
         MSG_19 = 'Use the new Ruby 1.9 hash syntax.'
-        MSG_HASH_ROCKETS = 'Always use hash rockets in hashes.'
+        MSG_RUBY19_NO_MIXED_KEYS = "Don't mix styles in the same hash."
+        MSG_HASH_ROCKETS = 'Use hash rockets syntax.'
+
+        @force_hash_rockets = false
 
         def on_hash(node)
-          style == :ruby19 ? ruby19_check(node) : hash_rockets_check(node)
+          if cop_config['UseHashRocketsWithSymbolValues']
+            pairs = *node
+            @force_hash_rockets = pairs.any? { |p| symbol_value?(p) }
+          end
+
+          if style == :hash_rockets || @force_hash_rockets
+            hash_rockets_check(node)
+          elsif style == :ruby19_no_mixed_keys
+            ruby19_no_mixed_keys_check(node)
+          else
+            ruby19_check(node)
+          end
         end
 
         def ruby19_check(node)
           pairs = *node
 
-          sym_indices = pairs.all? { |p| word_symbol_pair?(p) }
-
-          check(pairs, '=>', MSG_19) if sym_indices
+          check(pairs, '=>', MSG_19) if sym_indices?(pairs)
         end
 
         def hash_rockets_check(node)
@@ -33,27 +45,60 @@ module RuboCop
           check(pairs, ':', MSG_HASH_ROCKETS)
         end
 
-        def autocorrect(node)
-          key = node.children.first.loc.expression
-          op = node.loc.operator
+        def ruby19_no_mixed_keys_check(node)
+          pairs = *node
 
+          if @force_hash_rockets
+            check(pairs, ':', MSG_HASH_ROCKETS)
+          elsif sym_indices?(pairs)
+            check(pairs, '=>', MSG_19)
+          else
+            check(pairs, ':', MSG_RUBY19_NO_MIXED_KEYS)
+          end
+        end
+
+        def autocorrect(node)
           @corrections << lambda do |corrector|
-            if style == :ruby19
-              range = Parser::Source::Range.new(key.source_buffer,
-                                                key.begin_pos, op.end_pos)
-              range = range_with_surrounding_space(range, :right)
-              corrector.replace(range,
-                                range.source.sub(/^:(.*\S)\s*=>\s*$/, '\1: '))
+            if style == :hash_rockets || @force_hash_rockets
+              autocorrect_hash_rockets(corrector, node)
+            elsif style == :ruby19_no_mixed_keys
+              autocorrect_ruby19_no_mixed_keys(corrector, node)
             else
-              corrector.insert_after(key, ' => ')
-              corrector.insert_before(key, ':')
-              corrector.remove(range_with_surrounding_space(op))
+              autocorrect_ruby19(corrector, node)
             end
           end
         end
 
+        def alternative_style
+          case style
+          when :hash_rockets then
+            :ruby19
+          when :ruby19, :ruby19_no_mixed_keys then
+            :hash_rockets
+          end
+        end
+
         private
 
+        def symbol_value?(pair)
+          _key, value = *pair
+
+          value.sym_type?
+        end
+
+        def sym_indices?(pairs)
+          pairs.all? { |p| word_symbol_pair?(p) }
+        end
+
+        def word_symbol_pair?(pair)
+          key, _value = *pair
+
+          return false unless key.sym_type?
+
+          sym_name = key.loc.expression.source
+          sym_name !~ /\A:["']|=\z/
+        end
+
         def check(pairs, delim, msg)
           pairs.each do |pair|
             if pair.loc.operator && pair.loc.operator.is?(delim)
@@ -68,15 +113,33 @@ module RuboCop
           end
         end
 
-        def word_symbol_pair?(pair)
-          key, _value = *pair
+        def autocorrect_ruby19(corrector, node)
+          key = node.children.first.loc.expression
+          op = node.loc.operator
+
+          range = Parser::Source::Range.new(key.source_buffer,
+                                            key.begin_pos, op.end_pos)
+          range = range_with_surrounding_space(range, :right)
+          corrector.replace(range,
+                            range.source.sub(/^:(.*\S)\s*=>\s*$/, '\1: '))
+        end
+
+        def autocorrect_hash_rockets(corrector, node)
+          key = node.children.first.loc.expression
+          op = node.loc.operator
 
-          if key.type == :sym
-            sym_name = key.to_a[0]
+          corrector.insert_after(key, ' => ')
+          corrector.insert_before(key, ':')
+          corrector.remove(range_with_surrounding_space(op))
+        end
+
+        def autocorrect_ruby19_no_mixed_keys(corrector, node)
+          op = node.loc.operator
 
-            sym_name =~ /\A[A-Za-z_]\w*\z/
+          if op.is?(':')
+            autocorrect_hash_rockets(corrector, node)
           else
-            false
+            autocorrect_ruby19(corrector, node)
           end
         end
       end

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

@@ -23,6 +23,21 @@ module RuboCop
           return unless fit_within_line_as_modifier_form?(node)
           add_offense(node, :keyword, message(node.loc.keyword.source))
         end
+
+        def autocorrect(node)
+          if node.loc.keyword.source == 'if'
+            cond, body = *node
+          else
+            cond, _else, body = *node
+          end
+
+          @corrections << lambda do |corrector|
+            oneline = "#{body.loc.expression.source} " \
+                      "#{node.loc.keyword.source} " +
+                      cond.loc.expression.source
+            corrector.replace(node.loc.expression, oneline)
+          end
+        end
       end
     end
   end

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

@@ -16,6 +16,7 @@ module RuboCop
       class IndentationConsistency < Cop
         include AutocorrectAlignment
         include AccessModifierNode
+        include ConfigurableEnforcedStyle
 
         MSG = 'Inconsistent indentation detected.'
 
@@ -30,13 +31,19 @@ module RuboCop
         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.
-            modifier_node?(child)
+          children_to_check = [[]]
+          node.children.each do |child|
+            # Modifier nodes have special indentation and will be checked by
+            # the AccessModifierIndentation cop. This cop uses them as dividers
+            # in rails mode. Then consistency is checked only within each
+            # section delimited by a modifier node.
+            if modifier_node?(child)
+              children_to_check << [] if style == :rails
+            else
+              children_to_check.last << child
+            end
           end
-
-          check_alignment(children_to_check)
+          children_to_check.each { |group| check_alignment(group) }
         end
       end
     end

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

@@ -51,12 +51,32 @@ module RuboCop
 
         def on_module(node)
           _module_name, *members = *node
-          members.each { |m| check_indentation(node.loc.keyword, m) }
+          check_members(node, members)
         end
 
         def on_class(node)
           _class_name, _base_class, *members = *node
-          members.each { |m| check_indentation(node.loc.keyword, m) }
+          check_members(node, members)
+        end
+
+        def check_members(node, members)
+          check_indentation(node.loc.keyword, members.first)
+
+          return unless members.any? && members.first.begin_type?
+          style =
+            config.for_cop('Style/IndentationConsistency')['EnforcedStyle']
+          return unless style == 'rails'
+
+          special = %w(protected private) # Extra indentation step after these.
+          previous_modifier = nil
+          members.first.children.each do |m|
+            if modifier_node?(m) && special.include?(m.loc.expression.source)
+              previous_modifier = m
+            elsif previous_modifier
+              check_indentation(previous_modifier.loc.expression, m, style)
+              previous_modifier = nil
+            end
+          end
         end
 
         def on_send(node)
@@ -171,7 +191,7 @@ module RuboCop
           check_indentation(node.loc.else, else_clause)
         end
 
-        def check_indentation(base_loc, body_node)
+        def check_indentation(base_loc, body_node, style = 'normal')
           return unless indentation_to_check?(base_loc, body_node)
 
           indentation = body_node.loc.column - base_loc.column
@@ -185,14 +205,11 @@ module RuboCop
             body_node = body_node.children.first
           end
 
-          expr = body_node.loc.expression
-          begin_pos, ind = expr.begin_pos, expr.begin_pos - indentation
-          pos = indentation >= 0 ? ind..begin_pos : begin_pos..ind
-
-          r = Parser::Source::Range.new(expr.source_buffer, pos.begin, pos.end)
-          add_offense(body_node, r,
+          indentation_name = style == 'normal' ? '' : "#{style} "
+          add_offense(body_node, offending_range(body_node, indentation),
                       format("Use #{configured_indentation_width} (not %d) " \
-                             'spaces for indentation.', indentation))
+                             "spaces for #{indentation_name}indentation.",
+                             indentation))
         end
 
         def indentation_to_check?(base_loc, body_node)
@@ -211,6 +228,13 @@ module RuboCop
           true
         end
 
+        def offending_range(body_node, indentation)
+          expr = body_node.loc.expression
+          begin_pos, ind = expr.begin_pos, expr.begin_pos - indentation
+          pos = indentation >= 0 ? ind..begin_pos : begin_pos..ind
+          Parser::Source::Range.new(expr.source_buffer, pos.begin, pos.end)
+        end
+
         def starts_with_access_modifier?(body_node)
           body_node.type == :begin && modifier_node?(body_node.children.first)
         end

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

@@ -7,6 +7,8 @@ module RuboCop
       # anonymous functions and uses of the 1.9 lambda syntax for multi-line
       # anonymous functions.
       class Lambda < Cop
+        include AutocorrectUnlessChangingAST
+
         SINGLE_MSG = 'Use the new lambda literal syntax `->(params) {...}`.'
         SINGLE_NO_ARG_MSG = 'Use the new lambda literal syntax `-> {...}`.'
         MULTI_MSG = 'Use the `lambda` method for multi-line lambdas.'
@@ -22,22 +24,22 @@ module RuboCop
 
           return unless block_method == TARGET
           selector = block_method.loc.selector.source
-          lambda_length = lambda_length(node)
+          length = lambda_length(node)
 
-          if selector != '->' && lambda_length == 0
-            add_offense_for_single_line(block_method, args)
-          elsif selector == '->' && lambda_length > 0
-            add_offense(block_method, :expression, MULTI_MSG)
+          if selector != '->' && length == 1
+            add_offense_for_single_line(node, block_method.loc.expression, args)
+          elsif selector == '->' && length > 1
+            add_offense(node, block_method.loc.expression, MULTI_MSG)
           end
         end
 
         private
 
-        def add_offense_for_single_line(block_method, args)
+        def add_offense_for_single_line(block_node, location, args)
           if args.children.empty?
-            add_offense(block_method, :expression, SINGLE_NO_ARG_MSG)
+            add_offense(block_node, location, SINGLE_NO_ARG_MSG)
           else
-            add_offense(block_method, :expression, SINGLE_MSG)
+            add_offense(block_node, location, SINGLE_MSG)
           end
         end
 
@@ -45,28 +47,32 @@ module RuboCop
           start_line = block_node.loc.begin.line
           end_line = block_node.loc.end.line
 
-          end_line - start_line
+          end_line - start_line + 1
         end
 
-        def autocorrect(node)
-          ancestor = node.ancestors.first
+        def correction(node)
+          lambda do |corrector|
+            block_method, _args = *node
 
-          @corrections << lambda do |corrector|
-            if node.loc.expression.source == 'lambda'
-              autocorrect_old_to_new(corrector, ancestor)
+            if block_method.loc.expression.source == 'lambda'
+              autocorrect_old_to_new(corrector, node)
             else
-              autocorrect_new_to_old(corrector, ancestor)
+              autocorrect_new_to_old(corrector, node)
             end
           end
         end
 
         def autocorrect_new_to_old(corrector, node)
           block_method, args = *node
+          # Avoid correcting to `lambdado` by inserting whitespace
+          # if none exists before or after the lambda arguments.
+          if needs_whitespace?(block_method, args, node)
+            corrector.insert_before(node.loc.begin, ' ')
+          end
           corrector.replace(block_method.loc.expression, 'lambda')
+          corrector.remove(args.loc.expression) if args.loc.expression
           return if args.children.empty?
-
           arg_str = " |#{lambda_arg_string(args)}|"
-          corrector.remove(args.loc.expression)
           corrector.insert_after(node.loc.begin, arg_str)
         end
 
@@ -81,6 +87,15 @@ module RuboCop
           corrector.remove(whitespace_and_old_args)
         end
 
+        def needs_whitespace?(block_method, args, node)
+          selector_end = block_method.loc.selector.end.end_pos
+          args_begin   = args.loc.begin && args.loc.begin.begin_pos
+          args_end     = args.loc.end && args.loc.end.end_pos
+          block_begin  = node.loc.begin.begin_pos
+          (block_begin == args_end && selector_end == args_begin) ||
+            (block_begin == selector_end)
+        end
+
         def lambda_arg_string(args)
           args.children.map { |a| a.loc.expression.source }.join(', ')
         end

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

@@ -36,6 +36,10 @@ module RuboCop
 
         def autocorrect(operator_range)
           @corrections << lambda do |corrector|
+            # Include any trailing whitespace so we don't create a syntax error.
+            operator_range = range_with_surrounding_space(operator_range,
+                                                          :right, nil,
+                                                          !:with_newline)
             corrector.replace(operator_range, '\\')
           end
         end

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

@@ -0,0 +1,72 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for `if` expressions that do not have an `else` branch.
+      # SupportedStyles
+      #
+      # if
+      # @example
+      #   # bad
+      #   if condition
+      #     statement
+      #   end
+      #
+      # case
+      # @example
+      #   # bad
+      #   case var
+      #   when condition
+      #     statement
+      #   end
+      #
+      # @example
+      #   # good
+      #   if condition
+      #     statement
+      #   else
+      #   # the content of the else branch will be determined by Style/EmptyElse
+      #   end
+      class MissingElse < Cop
+        include OnNormalIfUnless
+        include ConfigurableEnforcedStyle
+
+        MSG = '`%s` condition requires an `else`-clause.'
+        MSG_NIL = '`%s` condition requires an `else`-clause with `nil` in it.'
+        MSG_EMPTY = '`%s` condition requires an empty `else`-clause.'
+
+        def on_normal_if_unless(node)
+          unless_else_cop = config.for_cop('Style/UnlessElse')
+          unless_else_enabled = unless_else_cop['Enabled'] if unless_else_cop
+          return if unless_else_enabled &&
+                    node.loc.keyword &&
+                    node.loc.keyword.is?('unless')
+          check(node, if_else_clause(node)) unless style == :case
+        end
+
+        def on_case(node)
+          check(node, case_else_clause(node)) unless style == :if
+        end
+
+        private
+
+        def check(node, _else_clause)
+          return if node.loc.else
+          empty_else = config.for_cop('Style/EmptyElse')
+
+          if empty_else && empty_else['Enabled']
+            case empty_else['EnforcedStyle']
+            when 'empty'
+              add_offense(node, :expression, format(MSG_NIL, node.type))
+            when 'nil'
+              add_offense(node, :expression, format(MSG_EMPTY, node.type))
+            end
+          end
+
+          add_offense(node, :expression, format(MSG, node.type))
+        end
+      end
+    end
+  end
+end