rubocop 0.29.1 → 0.30.0

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

@@ -3,81 +3,112 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for regexp literals and reports offenses based
-      # on how many escaped slashes there are in the regexp and on the
-      # value of the configuration parameter MaxSlashes.
+      # This cop enforces using // or %r around regular expressions.
+      #
+      # @example
+      #   # Good if EnforcedStyle is slashes or mixed, bad if percent_r.
+      #   snake_case = /^[\dA-Z_]+$/
+      #
+      #   # Good if EnforcedStyle is percent_r, bad if slashes or mixed.
+      #   snake_case = %r{^[\dA-Z_]+$}
+      #
+      #   # Good if EnforcedStyle is slashes, bad if percent_r or mixed.
+      #   regex = /
+      #     foo
+      #     (bar)
+      #     (baz)
+      #   /x
+      #
+      #   # Good if EnforcedStyle is percent_r or mixed, bad if slashes.
+      #   regex = %r{
+      #     foo
+      #     (bar)
+      #     (baz)
+      #   }x
+      #
+      #   # Bad unless AllowInnerSlashes is true.
+      #   x =~ /home\//
       class RegexpLiteral < Cop
-        class << self
-          attr_accessor :slash_count
-        end
+        include ConfigurableEnforcedStyle
+
+        MSG_USE_SLASHES = 'Use `//` around regular expression.'
+        MSG_USE_PERCENT_R = 'Use `%r` around regular expression.'
 
         def on_regexp(node)
-          string_parts = node.children.select { |child| child.type == :str }
-          total_string = string_parts.map { |s| s.loc.expression.source }.join
-          slashes = total_string.count('/')
-          delimiter_start = node.loc.begin.source[0]
-
-          if delimiter_start == '/'
-            if slashes > max_slashes
-              add_offense(node, :expression, error_message(''))
-            end
-          elsif slashes <= max_slashes
-            add_offense(node, :expression, error_message('only '))
+          if slash_literal?(node)
+            check_slash_literal(node)
+          else
+            check_percent_r_literal(node)
           end
-
-          configure_max(delimiter_start, slashes) if @options[:auto_gen_config]
         end
 
         private
 
-        def max_slashes
-          m = cop_config['MaxSlashes']
-          unless m.is_a?(Fixnum) && m >= 0
-            fail "Illegal value for MaxSlashes: #{m}"
-          end
-          m
+        def check_slash_literal(node)
+          return if style == :slashes && !contains_disallowed_slash?(node)
+          return if style == :mixed &&
+                    single_line?(node) &&
+                    !contains_disallowed_slash?(node)
+
+          add_offense(node, :expression, MSG_USE_PERCENT_R)
         end
 
-        def configure_max(delimiter_start, value)
-          self.class.slash_count ||= {
-            '/' => Set.new([0]),
-            '%' => Set.new([100_000])
-          }
+        def check_percent_r_literal(node)
+          return if style == :slashes && contains_disallowed_slash?(node)
+          return if style == :percent_r
+          return if style == :mixed && multi_line?(node)
+          return if style == :mixed && contains_disallowed_slash?(node)
 
-          self.class.slash_count[delimiter_start].add(value)
+          add_offense(node, :expression, MSG_USE_SLASHES)
+        end
 
-          # To avoid reports, MaxSlashes must be set equal to the highest
-          # number of slashes used within //, and also one less than the
-          # highest number of slashes used within %r{}. If no value can satisfy
-          # both requirements, just disable.
-          max = self.class.slash_count['/'].max
-          min = self.class.slash_count['%'].min
+        def contains_disallowed_slash?(node)
+          !allow_inner_slashes? && contains_slash?(node)
+        end
 
-          self.config_to_allow_offenses = calculate_config(max, min)
+        def contains_slash?(node)
+          node_body(node).include?('/')
         end
 
-        def calculate_config(max, min)
-          if max > max_slashes
-            if max < min
-              { 'MaxSlashes' => max }
-            else
-              { 'Enabled' => false }
-            end
-          elsif min < max_slashes + 1
-            if max < min
-              { 'MaxSlashes' => min - 1 }
-            else
-              { 'Enabled' => false }
-            end
-          end
+        def allow_inner_slashes?
+          cop_config['AllowInnerSlashes']
+        end
+
+        def node_body(node)
+          string_parts = node.children.select { |child| child.type == :str }
+          string_parts.map { |s| s.loc.expression.source }.join
         end
 
-        def error_message(word)
-          format('Use %%r %sfor regular expressions matching more ' \
-                 "than %d '/' character%s.",
-                 word,
-                 max_slashes,
-                 max_slashes == 1 ? '' : 's')
+        def slash_literal?(node)
+          node.loc.begin.source == '/'
+        end
+
+        def single_line?(node)
+          !multi_line?(node)
+        end
+
+        def multi_line?(node)
+          block_length(node) > 1
+        end
+
+        def preferred_delimiters
+          config.for_cop('Style/PercentLiteralDelimiters') \
+            ['PreferredDelimiters']['%r'].split(//)
+        end
+
+        def autocorrect(node)
+          fail CorrectionNotPossible if contains_slash?(node)
+
+          if slash_literal?(node)
+            replacement = ['%r', ''].zip(preferred_delimiters).map(&:join)
+          else
+            replacement = %w(/ /)
+          end
+
+          @corrections << lambda do |corrector|
+            corrector.replace(node.loc.begin, replacement.first)
+            corrector.replace(node.loc.end, replacement.last)
+          end
         end
       end
     end

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

@@ -58,12 +58,23 @@ module RuboCop
           with_space = range_with_surrounding_space(op)
           if op.is?('**')
             unless with_space.is?('**')
-              add_offense(with_space, op, 'Space around operator ** detected.')
+              add_offense(with_space, op,
+                          'Space around operator `**` detected.')
             end
           elsif with_space.source !~ /^\s.*\s$/
             add_offense(with_space, op,
                         'Surrounding space missing for operator' \
-                        " '#{op.source}'.")
+                        " `#{op.source}`.")
+          elsif with_space.source =~ /(^  |  $)/ && !multi_space_operator?(op)
+            add_offense(with_space, op,
+                        "Operator `#{op.source}` should be surrounded" \
+                        ' with a single space.')
+          end
+        end
+
+        def multi_space_operator?(op)
+          cop_config['MultiSpaceAllowedForOperators'].any? do |multi_space_op|
+            op.is?(multi_space_op)
           end
         end
 

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

@@ -11,11 +11,11 @@ module RuboCop
         def on_block(node)
           return if node.loc.begin.is?('do') # No braces.
 
-          # If braces are on separate lines, and the Blocks cop is enabled,
-          # those braces will be changed to do..end by the user or by
+          # If braces are on separate lines, and the BlockDelimiters cop is
+          # enabled, those braces will be changed to do..end by the user or by
           # auto-correct, so reporting space issues is not useful, and it
           # creates auto-correct conflicts.
-          if config.for_cop('Style/Blocks')['Enabled'] &&
+          if config.for_cop('Style/BlockDelimiters')['Enabled'] &&
              Util.block_length(node) > 0
             return
           end

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

@@ -14,11 +14,11 @@ module RuboCop
         def on_block(node)
           return if node.loc.begin.is?('do') # No braces.
 
-          # If braces are on separate lines, and the Blocks cop is enabled,
-          # those braces will be changed to do..end by the user or by
+          # If braces are on separate lines, and the BlockDelimiters cop is
+          # enabled, those braces will be changed to do..end by the user or by
           # auto-correct, so reporting space issues is not useful, and it
           # creates auto-correct conflicts.
-          if config.for_cop('Style/Blocks')['Enabled'] &&
+          if config.for_cop('Style/BlockDelimiters')['Enabled'] &&
              Util.block_length(node) > 0
             return
           end
@@ -80,7 +80,9 @@ module RuboCop
             if left_brace.end_pos == args_delimiter.begin_pos &&
                cop_config['SpaceBeforeBlockParameters']
               offense(sb, left_brace.begin_pos, args_delimiter.end_pos,
-                      'Space between { and | missing.')
+                      'Space between { and | missing.') do
+                opposite_style_detected
+              end
             end
           else
             # We indicate the position after the left brace. Otherwise it's
@@ -95,7 +97,9 @@ module RuboCop
           if pipe?(args_delimiter)
             unless cop_config['SpaceBeforeBlockParameters']
               offense(sb, left_brace.end_pos, args_delimiter.begin_pos,
-                      'Space between { and | detected.')
+                      'Space between { and | detected.') do
+                opposite_style_detected
+              end
             end
           else
             brace_with_space = range_with_surrounding_space(left_brace, :right)

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

@@ -0,0 +1,36 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks symbol literal syntax.
+      #
+      # @example
+      #
+      #   # bad
+      #   :"symbol"
+      #
+      #   # good
+      #   :symbol
+      class SymbolLiteral < Cop
+        MSG = 'Do not use strings for word-like symbol literals.'
+
+        def on_sym(node)
+          sym_name = node.loc.expression.source
+
+          return unless sym_name =~ /\A:["'][A-Za-z_]\w*["']\z/
+
+          add_offense(node, :expression)
+        end
+
+        def autocorrect(node)
+          @corrections << lambda do |corrector|
+            current_name = node.loc.expression.source
+            corrector.replace(node.loc.expression,
+                              current_name.gsub(/["']/, ''))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -12,6 +12,13 @@ module RuboCop
           sb = processed_source.buffer
           return if sb.source.empty?
 
+          # The extra text that comes after the last token could be __END__
+          # followed by some data to read. If so, we don't check it because
+          # there could be good reasons why it needs to end with a certain
+          # number of newlines.
+          extra = sb.source[processed_source.tokens.last.pos.end_pos..-1]
+          return if extra.strip.start_with?('__END__')
+
           whitespace_at_end = sb.source[/\s*\Z/]
           blank_lines = whitespace_at_end.count("\n") - 1
           wanted_blank_lines = style == :final_newline ? 0 : 1

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

@@ -8,12 +8,14 @@ module RuboCop
       # @example
       #   # always bad
       #   a = [1, 2,]
-      #   b = [
+      #
+      #   # good if EnforcedStyleForMultiline is consistent_comma
+      #   a = [
       #     1, 2,
       #     3,
       #   ]
       #
-      #   # good if EnforcedStyleForMultiline is comma
+      #   # good if EnforcedStyleForMultiline is comma or consistent_comma
       #   a = [
       #     1,
       #     2,
@@ -66,6 +68,7 @@ module RuboCop
                 node.loc.end.begin_pos)
         end
 
+        # rubocop:disable Metrics/MethodLength
         def check(node, items, kind, begin_pos, end_pos)
           sb = items.first.loc.expression.source_buffer
           after_last_item = Parser::Source::Range.new(sb, begin_pos, end_pos)
@@ -73,11 +76,17 @@ module RuboCop
           return if heredoc?(after_last_item.source)
 
           comma_offset = after_last_item.source =~ /,/
-          should_have_comma = style == :comma && multiline?(node)
+          should_have_comma =
+            [:comma, :consistent_comma].include?(style) && multiline?(node)
           if comma_offset
             unless should_have_comma
-              extra_info = if style == :comma
+              extra_info = case style
+                           when :comma
                              ', unless each item is on its own line'
+                           when :consistent_comma
+                             ', unless items are split onto multiple lines'
+                           else
+                             ''
                            end
               avoid_comma(kind, after_last_item.begin_pos + comma_offset, sb,
                           extra_info)
@@ -86,6 +95,7 @@ module RuboCop
             put_comma(items, kind, sb)
           end
         end
+        # rubocop:enable Metrics/MethodLength
 
         def heredoc?(source_after_last_item)
           source_after_last_item =~ /\w/
@@ -106,9 +116,13 @@ module RuboCop
                      else
                        node.children
                      end
-          items = [*elements.map { |e| e.loc.expression }, node.loc.end]
-          items.each_cons(2) { |a, b| return false if on_same_line?(a, b) }
-          true
+          items = elements.map { |e| e.loc.expression }
+          if style == :consistent_comma
+            items.each_cons(2).any? { |a, b| !on_same_line?(a, b) }
+          else
+            items << node.loc.end
+            items.each_cons(2).all? { |a, b| !on_same_line?(a, b) }
+          end
         end
 
         def on_same_line?(a, b)

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

@@ -6,10 +6,19 @@ module RuboCop
       # This cop looks for trivial reader/writer methods, that could
       # have been created with the attr_* family of functions automatically.
       class TrivialAccessors < Cop
-        include OnMethodDef
-
         MSG = 'Use `attr_%s` to define trivial %s methods.'
 
+        def on_def(node)
+          method_name, args, body = *node
+          on_method_def(node, method_name, args, body)
+        end
+
+        def on_defs(node)
+          return if ignore_class_methods?
+          _scope, method_name, args, body = *node
+          on_method_def(node, method_name, args, body)
+        end
+
         private
 
         def on_method_def(node, method_name, args, body)
@@ -35,6 +44,10 @@ module RuboCop
           cop_config['AllowDSLWriters']
         end
 
+        def ignore_class_methods?
+          cop_config['IgnoreClassMethods']
+        end
+
         def whitelist
           whitelist = cop_config['Whitelist']
           Array(whitelist).map(&:to_sym) + [:initialize]
@@ -65,7 +78,8 @@ module RuboCop
         end
 
         def looks_like_trivial_writer?(args, body)
-          args.children.size == 1 && args.children[0].type != :restarg &&
+          args.children.size == 1 &&
+            ![:restarg, :blockarg].include?(args.children[0].type) &&
             body && body.type == :ivasgn &&
             body.children[1] && body.children[1].type == :lvar
         end

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

@@ -17,13 +17,11 @@ module RuboCop
         private
 
         def on_percent_literal(node)
-          node.children.each do |string|
-            if string.type == :dstr ||
-               string.loc.expression.source =~ StringHelp::ESCAPED_CHAR_REGEXP
-              return
-            end
+          requires_interpolation = node.children.any? do |string|
+            string.type == :dstr ||
+            string.loc.expression.source =~ StringHelp::ESCAPED_CHAR_REGEXP
           end
-          add_offense(node, :expression)
+          add_offense(node, :expression) unless requires_interpolation
         end
 
         def autocorrect(node)

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

@@ -17,6 +17,16 @@ module RuboCop
           check(node)
         end
 
+        def autocorrect(node)
+          cond, body = *node
+          @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
+
         private
 
         def check(node)