rubocop 0.35.1 → 0.36.0

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -14,13 +15,13 @@ module RuboCop
       class RedundantFreeze < Cop
         MSG = 'Freezing immutable objects is pointless.'.freeze
 
-        TARGET_NODES = [:int, :float, :sym].freeze
-
         def on_send(node)
           receiver, method_name, *args = *node
 
-          return unless receiver && TARGET_NODES.include?(receiver.type)
-          return unless method_name == :freeze && args.empty?
+          return unless receiver &&
+                        method_name == :freeze &&
+                        args.empty? &&
+                        receiver.immutable_literal?
 
           add_offense(node, :expression)
         end

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

@@ -0,0 +1,80 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for redundant parentheses.
+      #
+      # @example
+      #
+      #   # bad
+      #   (x) if ((y.z).nil?)
+      #
+      #   # good
+      #   x if y.z.nil?
+      #
+      class RedundantParentheses < Cop
+        include Parentheses
+
+        ALLOWED_LITERALS = [:irange, :erange].freeze
+
+        def_node_matcher :square_brackets?, '(send (send _recv _msg) :[] ...)'
+        def_node_matcher :range_end?, '^^{irange erange}'
+        def_node_matcher :method_node_and_args, '$(send _recv _msg $...)'
+
+        def on_begin(node)
+          return unless parentheses?(node)
+
+          child_node = node.children.first
+          return if keyword_ancestor?(node) && parens_required?(node)
+
+          if keyword_with_redundant_parentheses?(child_node)
+            return offense(node, 'a keyword')
+          end
+          return offense(node, 'a literal') if disallowed_literal?(child_node)
+          return offense(node, 'a variable') if child_node.variable?
+          return offense(node, 'a constant') if child_node.const_type?
+          return unless method_call_with_redundant_parentheses?(child_node)
+
+          offense(node, 'a method call')
+        end
+
+        def offense(node, msg)
+          add_offense(node, :expression, "Don't use parentheses around #{msg}.")
+        end
+
+        def keyword_ancestor?(node)
+          node.ancestors.first && node.ancestors.first.keyword?
+        end
+
+        def disallowed_literal?(node)
+          node.literal? && !ALLOWED_LITERALS.include?(node.type)
+        end
+
+        def keyword_with_redundant_parentheses?(node)
+          return false unless node.keyword?
+          return true if node.special_keyword?
+
+          args = *node
+
+          if args.size == 1 && args.first && args.first.begin_type?
+            parentheses?(args.first)
+          else
+            args.empty? || parentheses?(node)
+          end
+        end
+
+        def method_call_with_redundant_parentheses?(node)
+          return false unless node.send_type?
+          return false if node.keyword_not?
+          return false if range_end?(node)
+
+          send_node, args = method_node_and_args(node)
+
+          args.empty? || parentheses?(send_node) || square_brackets?(send_node)
+        end
+      end
+    end
+  end
+end

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -23,14 +24,14 @@ module RuboCop
       class RedundantReturn < Cop
         include OnMethodDef
 
-        MSG = 'Redundant `return` detected.'
+        MSG = 'Redundant `return` detected.'.freeze
 
         private
 
         def autocorrect(node)
           lambda do |corrector|
             unless arguments?(node.children)
-              corrector.replace(node.loc.expression, 'nil')
+              corrector.replace(node.source_range, 'nil')
               next
             end
 
@@ -50,13 +51,13 @@ module RuboCop
         end
 
         def add_brackets(corrector, node)
-          kids = node.children.map { |child| child.loc.expression }
+          kids = node.children.map(&:source_range)
           corrector.insert_before(kids.first, '[')
           corrector.insert_after(kids.last, ']')
         end
 
         def add_braces(corrector, node)
-          kids = node.children.map { |child| child.loc.expression }
+          kids = node.children.map(&:source_range)
           corrector.insert_before(kids.first, '{')
           corrector.insert_after(kids.last, '}')
         end

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -43,7 +44,7 @@ module RuboCop
       # We allow uses of `self` with operators because it would be awkward
       # otherwise.
       class RedundantSelf < Cop
-        MSG = 'Redundant `self` detected.'
+        MSG = 'Redundant `self` detected.'.freeze
 
         def initialize(config = nil, options = nil)
           super
@@ -58,7 +59,7 @@ module RuboCop
           allow_self(lhs)
         end
 
-        alias_method :on_and_asgn, :on_or_asgn
+        alias on_and_asgn on_or_asgn
 
         def on_op_asgn(node)
           lhs, _op, _rhs = *node
@@ -93,8 +94,10 @@ module RuboCop
         def on_send(node)
           receiver, method_name, *_args = *node
           return unless receiver && receiver.type == :self
-          return if operator?(method_name) || keyword?(method_name) ||
+          return if operator?(method_name) ||
+                    keyword?(method_name) ||
                     constant_name?(method_name) ||
+                    node.asgn_method_call? ||
                     @allowed_send_nodes.include?(node) ||
                     @local_variables.include?(method_name)
 
@@ -104,7 +107,7 @@ module RuboCop
         def autocorrect(node)
           receiver, _method_name, *_args = *node
           lambda do |corrector|
-            corrector.remove(receiver.loc.expression)
+            corrector.remove(receiver.source_range)
             corrector.remove(node.loc.dot)
           end
         end
@@ -116,10 +119,6 @@ module RuboCop
           @local_variables << name
         end
 
-        def operator?(method_name)
-          method_name.to_s =~ /\W/
-        end
-
         def keyword?(method_name)
           [:alias, :and, :begin, :break, :case, :class, :def, :defined, :do,
            :else, :elsif, :end, :ensure, :false, :for, :if, :in, :module,

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -31,8 +32,8 @@ module RuboCop
       class RegexpLiteral < Cop
         include ConfigurableEnforcedStyle
 
-        MSG_USE_SLASHES = 'Use `//` around regular expression.'
-        MSG_USE_PERCENT_R = 'Use `%r` around regular expression.'
+        MSG_USE_SLASHES = 'Use `//` around regular expression.'.freeze
+        MSG_USE_PERCENT_R = 'Use `%r` around regular expression.'.freeze
 
         def on_regexp(node)
           if slash_literal?(node)
@@ -76,7 +77,7 @@ module RuboCop
 
         def node_body(node)
           string_parts = node.children.select { |child| child.type == :str }
-          string_parts.map { |s| s.loc.expression.source }.join
+          string_parts.map(&:source).join
         end
 
         def slash_literal?(node)
@@ -91,11 +92,11 @@ module RuboCop
         def autocorrect(node)
           return if contains_slash?(node)
 
-          if slash_literal?(node)
-            replacement = ['%r', ''].zip(preferred_delimiters).map(&:join)
-          else
-            replacement = %w(/ /)
-          end
+          replacement = if slash_literal?(node)
+                          ['%r', ''].zip(preferred_delimiters).map(&:join)
+                        else
+                          %w(/ /)
+                        end
 
           lambda do |corrector|
             corrector.replace(node.loc.begin, replacement.first)

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -22,7 +23,7 @@ module RuboCop
       #     puts 'error'
       #   end
       class RescueEnsureAlignment < Cop
-        MSG = '`%s` at %d, %d is not aligned with `end` at %d, %d.'
+        MSG = '`%s` at %d, %d is not aligned with `end` at %d, %d.'.freeze
 
         def on_resbody(node)
           check(node) unless modifier?(node)
@@ -73,7 +74,7 @@ module RuboCop
         end
 
         def ancestor_node(node)
-          node.each_ancestor(:kwbegin, :def, :defs).first
+          node.each_ancestor(:kwbegin, :def, :defs, :class, :module).first
         end
       end
     end

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -7,10 +8,11 @@ module RuboCop
       class RescueModifier < Cop
         include AutocorrectAlignment
 
-        MSG = 'Avoid using `rescue` in its modifier form.'
+        MSG = 'Avoid using `rescue` in its modifier form.'.freeze
 
         def investigate(processed_source)
-          @modifier_locations = processed_source.tokens
+          @modifier_locations = processed_source
+                                .tokens
                                 .select { |t| t.type == :kRESCUE_MOD }
                                 .map(&:pos)
         end
@@ -25,14 +27,14 @@ module RuboCop
           *_, rescue_args = *rescue_modifier
 
           correction =
-            "begin\n" <<
-            indentation(node) << operation.loc.expression.source <<
-            "\n#{offset(node)}rescue\n" <<
-            indentation(node) << rescue_args.loc.expression.source <<
+            "begin\n" \
+            "#{indentation(node)}#{operation.source}" \
+            "\n#{offset(node)}rescue\n" \
+            "#{indentation(node)}#{rescue_args.source}" \
             "\n#{offset(node)}end"
-          range = Parser::Source::Range.new(node.loc.expression.source_buffer,
-                                            node.loc.expression.begin_pos,
-                                            node.loc.expression.end_pos)
+          range = Parser::Source::Range.new(node.source_range.source_buffer,
+                                            node.source_range.begin_pos,
+                                            node.source_range.end_pos)
 
           lambda do |corrector|
             corrector.replace(range, correction)

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -13,10 +14,8 @@ module RuboCop
       #   # good
       #   x += 1
       class SelfAssignment < Cop
-        include AST::Sexp
-
-        MSG = 'Use self-assignment shorthand `%s=`.'
-        OPS = [:+, :-, :*, :**, :/, :|, :&]
+        MSG = 'Use self-assignment shorthand `%s=`.'.freeze
+        OPS = [:+, :-, :*, :**, :/, :|, :&].freeze
 
         def on_lvasgn(node)
           check(node, :lvar)
@@ -86,7 +85,7 @@ module RuboCop
         def apply_autocorrect(node, rhs, operator, new_rhs)
           lambda do |corrector|
             corrector.insert_before(node.loc.operator, operator)
-            corrector.replace(rhs.loc.expression, new_rhs.loc.expression.source)
+            corrector.replace(rhs.source_range, new_rhs.source)
           end
         end
       end

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -6,7 +7,7 @@ module RuboCop
       # This cop checks for multiple expressions placed on the same line.
       # It also checks for lines terminated with a semicolon.
       class Semicolon < Cop
-        MSG = 'Do not use semicolons to terminate expressions.'
+        MSG = 'Do not use semicolons to terminate expressions.'.freeze
 
         def investigate(processed_source)
           return unless processed_source.ast
@@ -22,7 +23,7 @@ module RuboCop
           return if exprs.size < 2
 
           # create a map matching lines to the number of expressions on them
-          exprs_lines = exprs.map { |e| e.loc.expression.line }
+          exprs_lines = exprs.map { |e| e.source_range.line }
           lines = exprs_lines.group_by { |i| i }
 
           # every line with more than 1 expression on it is an offense

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

@@ -1,11 +1,13 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Style
       # This cop checks for the use of the send method.
       class Send < Cop
-        MSG = 'Prefer `Object#__send__` or `Object#public_send` to `send`.'
+        MSG = 'Prefer `Object#__send__` or `Object#public_send` to ' \
+              '`send`.'.freeze
 
         def on_send(node)
           _receiver, method_name, *args = *node

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -7,8 +8,9 @@ module RuboCop
       class SignalException < Cop
         include ConfigurableEnforcedStyle
 
-        FAIL_MSG = 'Use `fail` instead of `raise` to signal exceptions.'
-        RAISE_MSG = 'Use `raise` instead of `fail` to rethrow exceptions.'
+        FAIL_MSG = 'Use `fail` instead of `raise` to signal exceptions.'.freeze
+        RAISE_MSG = 'Use `raise` instead of `fail` to ' \
+                    'rethrow exceptions.'.freeze
 
         def on_rescue(node)
           return unless style == :semantic
@@ -77,7 +79,7 @@ module RuboCop
         end
 
         def command_or_kernel_call?(name, node)
-          command?(name, node) || kernel_call?(name, node)
+          node.command?(name) || kernel_call?(name, node)
         end
 
         def kernel_call?(name, node)

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -11,7 +12,7 @@ module RuboCop
       class SingleLineBlockParams < Cop
         def on_block(node)
           # we care only for single line blocks
-          return unless Util.block_length(node) == 0
+          return unless block_length(node) == 0
 
           method_node, args_node, _body_node = *node
           receiver, method_name, _method_args = *method_node

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -9,7 +10,7 @@ module RuboCop
         include AutocorrectAlignment
         include OnMethodDef
 
-        MSG = 'Avoid single-line method definitions.'
+        MSG = 'Avoid single-line method definitions.'.freeze
 
         def allow_empty?
           cop_config['AllowIfMethodIsEmpty']
@@ -31,16 +32,16 @@ module RuboCop
         def autocorrect(node)
           body = @body
           eol_comment = processed_source.comments.find do |c|
-            c.loc.line == node.loc.expression.line
+            c.loc.line == node.source_range.line
           end
           lambda do |corrector|
             if body
               if body.type == :begin
                 body.children.each do |part|
-                  break_line_before(part.loc.expression, node, corrector, 1)
+                  break_line_before(part.source_range, node, corrector, 1)
                 end
               else
-                break_line_before(body.loc.expression, node, corrector, 1)
+                break_line_before(body.source_range, node, corrector, 1)
               end
             end
 
@@ -60,9 +61,8 @@ module RuboCop
 
         def move_comment(eol_comment, node, corrector)
           text = eol_comment.loc.expression.source
-          corrector.insert_before(node.loc.expression,
-                                  text + "\n" +
-                                  ' ' * node.loc.keyword.column)
+          corrector.insert_before(node.source_range,
+                                  text + "\n" + (' ' * node.loc.keyword.column))
           corrector.remove(eol_comment.loc.expression)
         end
       end