rubocop 0.18.1 → 0.19.0

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

@@ -0,0 +1,143 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop enforces the consitent useage of `%`-literal delimiters.
+      class PercentLiteralDelimiters < Cop
+        def on_array(node)
+          process(node, '%w', '%W', '%i')
+        end
+
+        def on_regexp(node)
+          process(node, '%r')
+        end
+
+        def on_str(node)
+          process(node, '%', '%Q', '%q')
+        end
+        alias_method :on_dstr, :on_str
+
+        def on_sym(node)
+          process(node, '%s')
+        end
+
+        def on_xstr(node)
+          process(node, '%x')
+        end
+
+        def message(node)
+          type = type(node)
+          delimiters = preferred_delimiters(type)
+
+          "`#{type}`-literals should be delimited by " \
+          "`#{delimiters[0]}` and `#{delimiters[1]}`"
+        end
+
+        private
+
+        def autocorrect(node)
+          type = type(node)
+
+          opening_delimiter, closing_delimiter = preferred_delimiters(type)
+          opening_newline = new_line(node.loc.begin, node.children.first)
+          closing_newline = new_line(node.loc.end, node.children.last)
+
+          expression, reg_opt =
+              if node.type == :regexp
+                [contents(node.children.first), contents(node.children.last)]
+              else
+                [contents(node), '']
+              end
+
+          corrected_source =
+            type + opening_delimiter + opening_newline +
+            expression +
+            closing_newline + closing_delimiter + reg_opt
+
+          @corrections << lambda do |corrector|
+            corrector.replace(
+              node.loc.expression,
+              corrected_source
+            )
+          end
+        end
+
+        def process(node, *types)
+          on_percent_literal(node, types) if percent_literal?(node)
+        end
+
+        def percent_literal?(node)
+          if (begin_source = begin_source(node))
+            begin_source.start_with?('%')
+          end
+        end
+
+        def on_percent_literal(node, types)
+          type = type(node)
+          if types.include?(type) &&
+              !uses_preferred_delimiter?(node, type) &&
+              !contains_preferred_delimiter?(node, type)
+            add_offense(node, :expression)
+          end
+        end
+
+        def type(node)
+          node.loc.begin.source[0..-2]
+        end
+
+        def preferred_delimiters(type)
+          cop_config['PreferredDelimiters'][type].split(//)
+        end
+
+        def contents(node)
+          if node.children.empty?
+            ''
+          elsif node.children.first.is_a?(Parser::AST::Node)
+            Parser::Source::Range.new(
+              node.loc.expression.source_buffer,
+              node.children.first.loc.expression.begin_pos,
+              node.children.last.loc.expression.end_pos
+            ).source
+          else
+            node.children.first.to_s
+          end
+        end
+
+        def uses_preferred_delimiter?(node, type)
+          preferred_delimiters(type)[0] == begin_source(node)[-1]
+        end
+
+        def contains_preferred_delimiter?(node, type)
+          preferred_delimiters = preferred_delimiters(type)
+          node
+            .children.map { |n| string_source(n) }.compact
+            .any? { |s| preferred_delimiters.any? { |d| s.include?(d) } }
+        end
+
+        def begin_source(node)
+          if node.loc.respond_to?(:begin) && node.loc.begin
+            node.loc.begin.source
+          end
+        end
+
+        def string_source(node)
+          if node.is_a?(String)
+            node
+          elsif node.respond_to?(:type) && node.type == :str
+            node.loc.expression.source
+          end
+        end
+
+        def new_line(range, child_node)
+          same_line?(range, child_node) ? '' : "\n"
+        end
+
+        def same_line?(range, child_node)
+          !child_node.is_a?(Parser::AST::Node) ||
+            range.begin.line == child_node.loc.line
+        end
+      end
+    end
+  end
+end

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

@@ -9,7 +9,7 @@ module Rubocop
         MSG = 'Avoid the use of Perl-style backrefs.'
 
         def on_nth_ref(node)
-          add_offence(node, :expression)
+          add_offense(node, :expression)
         end
 
         def autocorrect(node)

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

@@ -25,7 +25,7 @@ module Rubocop
         def check(node, method_name, args, _body)
           prefix_blacklist.each do |prefix|
             if method_name.to_s.start_with?(prefix)
-              add_offence(node, :name,
+              add_offense(node, :name,
                           message(method_name.to_s, prefix))
             end
           end

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

@@ -18,7 +18,7 @@ module Rubocop
           #   ...)
           block_method, = *node
 
-          add_offence(block_method, :expression) if block_method == TARGET
+          add_offense(block_method, :expression) if block_method == TARGET
         end
 
         def autocorrect(node)

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

@@ -24,7 +24,7 @@ module Rubocop
           _receiver, selector, *args = *node
 
           if args.size > 1
-            add_offence(node, :expression, message(selector)) do
+            add_offense(node, :expression, message(selector)) do
               opposite_style_detected
             end
           else
@@ -43,7 +43,7 @@ module Rubocop
 
               # Allow code like `raise Ex.new(arg1, arg2)`.
               if constructor_args.size <= 1
-                add_offence(node, :expression, message(selector)) do
+                add_offense(node, :expression, message(selector)) do
                   opposite_style_detected
                 end
               end

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

@@ -27,7 +27,7 @@ module Rubocop
         def check(_node, _method_name, _args, body)
           return unless body && body.type == :kwbegin
 
-          add_offence(body, :begin)
+          add_offense(body, :begin)
         end
       end
     end

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

@@ -24,7 +24,7 @@ module Rubocop
 
           first_arg, = *args
 
-          add_offence(first_arg, :expression) if first_arg == TARGET_NODE
+          add_offense(first_arg, :expression) if first_arg == TARGET_NODE
         end
       end
     end

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

@@ -58,7 +58,7 @@ module Rubocop
           return if cop_config['AllowMultipleReturnValues'] &&
             node.children.size > 1
 
-          add_offence(node, :keyword)
+          add_offense(node, :keyword)
         end
       end
     end

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

@@ -88,7 +88,7 @@ module Rubocop
           @local_variables << lhs
         end
 
-        # Detect offences
+        # Detect offenses
 
         def on_send(node)
           receiver, method_name, *_args = *node
@@ -97,7 +97,7 @@ module Rubocop
                 constant_name?(method_name) ||
                 @allowed_send_nodes.include?(node) ||
                 @local_variables.include?(method_name)
-              add_offence(node, :expression)
+              add_offense(node, :expression)
             end
           end
         end

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

@@ -3,47 +3,73 @@
 module Rubocop
   module Cop
     module Style
-      # This cop checks for regexp literals and reports offences based
+      # 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.
       class RegexpLiteral < Cop
-        include ConfigurableMax
-
         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('/')
           if node.loc.begin.is?('/')
             if slashes > max_slashes
-              msg = error_message('')
-              safe_setting = slashes
+              add_offense(node, :expression, error_message('')) do
+                self.slash_count_in_slashes_regexp = slashes
+              end
             end
           elsif slashes <= max_slashes
-            msg = error_message('only ')
-            safe_setting = slashes + 1
+            add_offense(node, :expression, error_message('only ')) do
+              self.slash_count_in_percent_r_regexp = slashes
+            end
           end
+        end
 
-          if msg
-            add_offence(node, :expression, msg) { self.max = safe_setting }
+        private
+
+        def max_slashes
+          m = cop_config['MaxSlashes']
+          unless m.is_a?(Fixnum) && m >= 0
+            fail "Illegal value for MaxSlashes: #{m}"
           end
+          m
         end
 
-        def max_slashes
-          cop_config['MaxSlashes']
+        # MaxSlashes must be set equal to the highest number of slashes used
+        # within // to avoid reports.
+        def slash_count_in_slashes_regexp=(value)
+          configure_slashes(value) { |current| [current, value].max }
         end
 
-        private
+        # MaxSlashes must be set one less than the highest number of slashes
+        # used within %r{} to avoid reports.
+        def slash_count_in_percent_r_regexp=(value)
+          configure_slashes(value - 1) { |current| [current, value - 1].min }
+        end
+
+        def configure_slashes(value)
+          cfg = self.config_to_allow_offenses ||= {}
+          return if cfg.key?('Enabled')
+
+          if cfg['MaxSlashes']
+            value = yield cfg['MaxSlashes']
+            if cfg['MaxSlashes'] > max_slashes && value < max_slashes ||
+                cfg['MaxSlashes'] < max_slashes && value > max_slashes
+              # We can't both increase and decrease MaxSlashes to avoid
+              # reports. This means that the only option is to disable the cop.
+              cfg = self.config_to_allow_offenses = { 'Enabled' => false }
+              return
+            end
+          end
 
-        def parameter_name
-          'MaxSlashes'
+          cfg['MaxSlashes'] = value
         end
 
         def error_message(word)
-          sprintf('Use %%r %sfor regular expressions matching more ' \
-                  "than %d '/' character%s.",
-                  word,
-                  max_slashes,
-                  max_slashes == 1 ? '' : 's')
+          format('Use %%r %sfor regular expressions matching more ' \
+                 "than %d '/' character%s.",
+                 word,
+                 max_slashes,
+                 max_slashes == 1 ? '' : 's')
         end
       end
     end

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

@@ -12,7 +12,7 @@ module Rubocop
         def on_rescue(node)
           return if ignored_node?(node)
 
-          add_offence(node, :expression)
+          add_offense(node, :expression)
         end
 
         def on_kwbegin(node)

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

@@ -0,0 +1,73 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop enforces the use the shorthand for self-assignment.
+      #
+      # @example
+      #
+      #   # bad
+      #   x = x + 1
+      #
+      #   # good
+      #   x += 1
+      class SelfAssignment < Cop
+        include AST::Sexp
+
+        OPS = [:+, :-, :*, :**, :/, :|, :&]
+
+        def on_lvasgn(node)
+          check(node, :lvar)
+        end
+
+        def on_ivasgn(node)
+          check(node, :ivar)
+        end
+
+        def on_cvasgn(node)
+          check(node, :cvar)
+        end
+
+        def check(node, var_type)
+          var_name, rhs = *node
+
+          return unless rhs
+
+          if rhs.type == :send
+            check_send_node(node, rhs, var_name, var_type)
+          elsif [:and, :or].include?(rhs.type)
+            check_boolean_node(node, rhs, var_name, var_type)
+          end
+        end
+
+        def check_send_node(node, rhs, var_name, var_type)
+          receiver, method_name, *_args = *rhs
+
+          return unless OPS.include?(method_name)
+
+          target_node = s(var_type, var_name)
+
+          if receiver == target_node
+            add_offense(node,
+                        :expression,
+                        "Use self-assignment shorthand #{method_name}=.")
+          end
+        end
+
+        def check_boolean_node(node, rhs, var_name, var_type)
+          first_operand, _second_operand = *rhs
+
+          target_node = s(var_type, var_name)
+
+          if first_operand == target_node
+            operator = rhs.loc.operator.source
+            add_offense(node,
+                        :expression,
+                        "Use self-assignment shorthand #{operator}=.")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -25,14 +25,14 @@ module Rubocop
             exprs_lines = exprs.map { |e| e.loc.expression.line }
             lines = exprs_lines.group_by { |i| i }
 
-            # every line with more than 1 expression on it is an offence
+            # every line with more than 1 expression on it is an offense
             lines.each do |line, expr_on_line|
               if expr_on_line.size > 1
                 # TODO: Find the correct position of the semicolon. We don't
                 # know if the first semicolon on the line is a separator of
                 # expressions. It's just a guess.
                 column = @processed_source[line - 1].index(';')
-                convention_on(line, column)
+                convention_on(line, column, !:last_on_line)
               end
             end
           end
@@ -47,16 +47,20 @@ module Rubocop
 
           tokens_for_lines.each do |line, tokens|
             if tokens.last.type == :tSEMI
-              convention_on(line, tokens.last.pos.column)
+              convention_on(line, tokens.last.pos.column, :last_on_line)
             end
           end
         end
 
-        def convention_on(line, column)
-          add_offence(nil,
-                      source_range(@processed_source.buffer,
-                                   @processed_source[0...(line - 1)], column,
-                                   1))
+        def convention_on(line, column, last_on_line)
+          range = source_range(@processed_source.buffer,
+                               @processed_source[0...(line - 1)], column,
+                               1)
+          add_offense(last_on_line ? range : nil, range)
+        end
+
+        def autocorrect(range)
+          @corrections << ->(corrector) { corrector.remove(range) } if range
         end
       end
     end