rubocop 0.42.0 → 0.43.0

data/lib/rubocop/cop/lint/unified_integer.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for using Fixnum or Bignum constant.
+      #
+      # @example
+      #   # bad
+      #   1.is_a?(Fixnum)
+      #   1.is_a?(Bignum)
+      #
+      #   # good
+      #   1.is_a?(Integer)
+      class UnifiedInteger < Cop
+        MSG = 'Use `Integer` instead of `%s`.'.freeze
+
+        def_node_matcher :fixnum_or_bignum_const?, <<-PATTERN
+          (:const {nil (:cbase)} ${:Fixnum :Bignum})
+        PATTERN
+
+        def on_const(node)
+          klass = fixnum_or_bignum_const?(node)
+          return unless klass
+
+          add_offense(node, :expression, format(MSG, klass))
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.loc.name, 'Integer')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/unneeded_disable.rb

@@ -33,30 +33,11 @@ module RuboCop
           lambda do |corrector|
             ranges, range = *args # Ranges are sorted by position.
 
-            if range.source.start_with?('#')
-              # Eat the entire comment, the preceding space, and the preceding
-              # newline if there is one.
-              original_begin = range.begin_pos
-              range = range_with_surrounding_space(range, :left, true)
-              range = range_with_surrounding_space(range, :right,
-                                                   # Special for a comment that
-                                                   # begins the file: remove
-                                                   # the newline at the end.
-                                                   original_begin.zero?)
-            else
-              # Is there any cop between this one and the end of the line, which
-              # is NOT being removed?
-
-              if ends_its_line?(ranges.last) && trailing_range?(ranges, range)
-                # Eat the comma on the left.
-                range = range_with_surrounding_space(range, :left)
-                range = range_with_surrounding_comma(range, :left)
-              end
-
-              range = range_with_surrounding_comma(range, :right)
-              # Eat following spaces up to EOL, but not the newline itself.
-              range = range_with_surrounding_space(range, :right, false)
-            end
+            range = if range.source.start_with?('#')
+                      comment_range_with_surrounding_space(range)
+                    else
+                      directive_range_in_list(range, ranges)
+                    end
 
             corrector.remove(range)
           end
@@ -64,6 +45,32 @@ module RuboCop
 
         private
 
+        def comment_range_with_surrounding_space(range)
+          # Eat the entire comment, the preceding space, and the preceding
+          # newline if there is one.
+          original_begin = range.begin_pos
+          range = range_with_surrounding_space(range, :left, true)
+          range_with_surrounding_space(range, :right,
+                                       # Special for a comment that
+                                       # begins the file: remove
+                                       # the newline at the end.
+                                       original_begin.zero?)
+        end
+
+        def directive_range_in_list(range, ranges)
+          # Is there any cop between this one and the end of the line, which
+          # is NOT being removed?
+          if ends_its_line?(ranges.last) && trailing_range?(ranges, range)
+            # Eat the comma on the left.
+            range = range_with_surrounding_space(range, :left)
+            range = range_with_surrounding_comma(range, :left)
+          end
+
+          range = range_with_surrounding_comma(range, :right)
+          # Eat following spaces up to EOL, but not the newline itself.
+          range_with_surrounding_space(range, :right, false)
+        end
+
         def each_unneeded_disable(cop_disabled_line_ranges, offenses, comments)
           disabled_ranges = cop_disabled_line_ranges[COP_NAME] || [0..0]
 
@@ -124,27 +131,33 @@ module RuboCop
 
         def add_offenses(unneeded_cops)
           unneeded_cops.each do |comment, cops|
-            # Is the entire rubocop:disable line useless, or should just
-            # some of the mentioned cops be removed?
             if all_disabled?(comment) ||
                directive_count(comment) == cops.size
-              location = comment.loc.expression
-              cop_list = cops.sort.map { |c| describe(c) }
-              add_offense([[location], location], location,
-                          "Unnecessary disabling of #{cop_list.join(', ')}.")
+              add_offense_for_entire_comment(comment, cops)
             else
-              cop_ranges = cops.map { |c| [c, cop_range(comment, c)] }
-              cop_ranges.sort_by! { |_, r| r.begin_pos }
-              ranges = cop_ranges.map { |_, r| r }
-
-              cop_ranges.each do |cop, range|
-                add_offense([ranges, range], range,
-                            "Unnecessary disabling of #{describe(cop)}.")
-              end
+              add_offense_for_some_cops(comment, cops)
             end
           end
         end
 
+        def add_offense_for_entire_comment(comment, cops)
+          location = comment.loc.expression
+          cop_list = cops.sort.map { |c| describe(c) }
+          add_offense([[location], location], location,
+                      "Unnecessary disabling of #{cop_list.join(', ')}.")
+        end
+
+        def add_offense_for_some_cops(comment, cops)
+          cop_ranges = cops.map { |c| [c, cop_range(comment, c)] }
+          cop_ranges.sort_by! { |_, r| r.begin_pos }
+          ranges = cop_ranges.map { |_, r| r }
+
+          cop_ranges.each do |cop, range|
+            add_offense([ranges, range], range,
+                        "Unnecessary disabling of #{describe(cop)}.")
+          end
+        end
+
         def cop_range(comment, cop)
           matching_range(comment.loc.expression, cop) ||
             matching_range(comment.loc.expression, cop.split('/').last) ||

data/lib/rubocop/cop/lint/unneeded_splat_expansion.rb

@@ -0,0 +1,114 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for unneeded usages of splat expansion
+      #
+      # @example
+      #   # bad
+      #   a = *[1, 2, 3]
+      #   a = *'a'
+      #   a = *1
+      #
+      #   begin
+      #     foo
+      #   rescue *[StandardError, ApplicationError]
+      #     bar
+      #   end
+      #
+      #   case foo
+      #   when *[1, 2, 3]
+      #     bar
+      #   else
+      #     baz
+      #   end
+      #
+      #   # good
+      #   c = [1, 2, 3]
+      #   a = *c
+      #   a, b = *c
+      #   a, *b = *c
+      #   a = *1..10
+      #   a = ['a']
+      #
+      #   begin
+      #     foo
+      #   rescue StandardError, ApplicationError
+      #     bar
+      #   end
+      #
+      #   case foo
+      #   when *[1, 2, 3]
+      #     bar
+      #   else
+      #     baz
+      #   end
+      class UnneededSplatExpansion < Cop
+        MSG = 'Unnecessary splat expansion.'.freeze
+        PERCENT_W = '%w'.freeze
+        PERCENT_CAPITAL_W = '%W'.freeze
+        PERCENT_I = '%i'.freeze
+        PERCENT_CAPITAL_I = '%I'.freeze
+        ARRAY_NEW_PATTERN = '$(send (const nil :Array) :new ...)'.freeze
+        ASSIGNMENT_TYPES = [:lvasgn, :ivasgn, :cvasgn, :gvasgn].freeze
+
+        def_node_matcher :literal_expansion?, <<-PATTERN
+          (splat {$({str dstr int float array} ...) (block #{ARRAY_NEW_PATTERN} ...) #{ARRAY_NEW_PATTERN}} ...)
+        PATTERN
+
+        def on_splat(node)
+          literal_expansion?(node) do |object|
+            if object.send_type?
+              return unless ASSIGNMENT_TYPES.include?(node.parent.parent.type)
+            end
+            add_offense(node, :expression)
+          end
+        end
+
+        private
+
+        def autocorrect(node)
+          variable, = *node
+          parent = node.parent
+          loc = node.loc
+
+          lambda do |corrector|
+            if !variable.array_type?
+              corrector.replace(loc.expression, "[#{variable.source}]")
+            elsif unneeded_brackets?(parent)
+              corrector.replace(loc.expression, remove_brackets(variable))
+            else
+              corrector.remove(loc.operator)
+            end
+          end
+        end
+
+        def unneeded_brackets?(node)
+          parent = node.parent
+
+          node.when_type? || node.send_type? || (parent && parent.resbody_type?)
+        end
+
+        def remove_brackets(array)
+          array_start = array.loc.begin.source
+          elements = *array
+          elements = elements.map(&:source)
+
+          if array_start.start_with?(PERCENT_W)
+            "'#{elements.join("', '")}'"
+          elsif array_start.start_with?(PERCENT_CAPITAL_W)
+            %("#{elements.join('", "')}")
+          elsif array_start.start_with?(PERCENT_I)
+            ":#{elements.join(', :')}"
+          elsif array_start.start_with?(PERCENT_CAPITAL_I)
+            %(:"#{elements.join('", :"')}")
+          else
+            elements.join(', ')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/useless_assignment.rb

@@ -48,30 +48,43 @@ module RuboCop
         def message_for_useless_assignment(assignment)
           variable = assignment.variable
 
-          message = format(MSG, variable.name)
+          format(MSG, variable.name) +
+            message_specification(assignment, variable).to_s
+        end
 
+        def message_specification(assignment, variable)
           if assignment.multiple_assignment?
-            message << " Use `_` or `_#{variable.name}` as a variable name " \
-                       "to indicate that it won't be used."
+            multiple_assignment_message(variable.name)
           elsif assignment.operator_assignment?
-            return_value_node = return_value_node_of_scope(variable.scope)
-            if assignment.meta_assignment_node.equal?(return_value_node)
-              non_assignment_operator = assignment.operator.sub(/=$/, '')
-              message << " Use just operator `#{non_assignment_operator}`."
-            end
+            operator_assignment_message(variable.scope, assignment)
           else
-            similar_name = find_similar_name(variable.name, variable.scope)
-            message << " Did you mean `#{similar_name}`?" if similar_name
+            similar_name_message(variable)
           end
+        end
+
+        def multiple_assignment_message(variable_name)
+          " Use `_` or `_#{variable_name}` as a variable name to indicate " \
+            "that it won't be used."
+        end
+
+        def operator_assignment_message(scope, assignment)
+          return_value_node = return_value_node_of_scope(scope)
+          return unless assignment.meta_assignment_node
+                                  .equal?(return_value_node)
+
+          " Use just operator `#{assignment.operator.sub(/=$/, '')}`."
+        end
 
-          message
+        def similar_name_message(variable)
+          similar_name = find_similar_name(variable.name, variable.scope)
+          " Did you mean `#{similar_name}`?" if similar_name
         end
 
         # TODO: More precise handling (rescue, ensure, nested begin, etc.)
         def return_value_node_of_scope(scope)
           body_node = scope.body_node
 
-          if body_node.type == :begin
+          if body_node.begin_type?
             body_node.children.last
           else
             body_node

data/lib/rubocop/cop/lint/useless_setter_call.rb

@@ -24,14 +24,7 @@ module RuboCop
         def on_method_def(_node, _method_name, _args, body)
           return unless body
 
-          expression = if body.type == :begin
-                         body.children
-                       else
-                         body
-                       end
-
-          last_expr = expression.is_a?(Array) ? expression.last : expression
-
+          last_expr = last_expression(body)
           return unless setter_call_to_local_variable?(last_expr)
 
           tracker = MethodVariableTracker.new(body)
@@ -39,15 +32,19 @@ module RuboCop
           variable_name, = *receiver
           return unless tracker.contain_local_object?(variable_name)
 
-          add_offense(receiver,
-                      :name,
-                      format(MSG, receiver.loc.name.source))
+          add_offense(receiver, :name, format(MSG, receiver.loc.name.source))
+        end
+
+        def last_expression(body)
+          expression = body.begin_type? ? body.children : body
+
+          expression.is_a?(Array) ? expression.last : expression
         end
 
         def setter_call_to_local_variable?(node)
-          return unless node && node.type == :send
+          return unless node && node.send_type?
           receiver, method, _args = *node
-          return unless receiver && receiver.type == :lvar
+          return unless receiver && receiver.lvar_type?
           method =~ /(?:\w|\[\])=$/
         end
 
@@ -64,19 +61,7 @@ module RuboCop
 
             @local = {}
 
-            scan(@body_node) do |node|
-              case node.type
-              when :masgn
-                process_multiple_assignment(node)
-              when :or_asgn, :and_asgn
-                process_logical_operator_assignment(node)
-              when :op_asgn
-                process_binary_operator_assignment(node)
-              when *ASSIGNMENT_TYPES
-                _, rhs_node = *node
-                process_assignment(node, rhs_node) if rhs_node
-              end
-            end
+            scan(@body_node) { |node| process_assignment_node(node) }
 
             @local[variable_name]
           end
@@ -91,6 +76,20 @@ module RuboCop
             end
           end
 
+          def process_assignment_node(node)
+            case node.type
+            when :masgn
+              process_multiple_assignment(node)
+            when :or_asgn, :and_asgn
+              process_logical_operator_assignment(node)
+            when :op_asgn
+              process_binary_operator_assignment(node)
+            when *ASSIGNMENT_TYPES
+              _, rhs_node = *node
+              process_assignment(node, rhs_node) if rhs_node
+            end
+          end
+
           def process_multiple_assignment(masgn_node)
             mlhs_node, mrhs_node = *masgn_node
 
@@ -100,7 +99,7 @@ module RuboCop
               lhs_variable_name, = *lhs_node
               rhs_node = mrhs_node.children[index]
 
-              if mrhs_node.type == :array && rhs_node
+              if mrhs_node.array_type? && rhs_node
                 process_assignment(lhs_variable_name, rhs_node)
               else
                 @local[lhs_variable_name] = true
@@ -140,7 +139,7 @@ module RuboCop
 
           def constructor?(node)
             return true if node.literal?
-            return false unless node.type == :send
+            return false unless node.send_type?
             _receiver, method = *node
             method == :new
           end

data/lib/rubocop/cop/lint/void.rb

@@ -34,8 +34,7 @@ module RuboCop
         end
 
         def check_for_void_op(node)
-          return unless node.type == :send
-          return unless node.loc.selector
+          return unless node.send_type? && node.loc.selector
 
           op = node.loc.selector.source
 
@@ -48,8 +47,7 @@ module RuboCop
         end
 
         def check_for_literal(node)
-          return unless node.literal?
-          return if node.xstr_type?
+          return if !node.literal? || node.xstr_type?
 
           add_offense(node, :expression, format(LIT_MSG, node.source))
         end

data/lib/rubocop/cop/mixin/access_modifier_node.rb

@@ -29,11 +29,11 @@ module RuboCop
       # is a Class or Module. Filters out simple method calls to similarly
       # named private, protected or public.
       def class_or_module_parent?(node)
-        node.each_ancestor do |a|
-          if a.type == :block
-            return true if a.class_constructor?
-          elsif a.type != :begin
-            return [:casgn, :sclass, :class, :module].include?(a.type)
+        node.each_ancestor do |ancestor|
+          if ancestor.block_type?
+            return true if ancestor.class_constructor?
+          elsif !ancestor.begin_type?
+            return [:casgn, :sclass, :class, :module].include?(ancestor.type)
           end
         end
       end