rubbycop 0.49.0

data/lib/rubbycop/cop/lint/percent_symbol_array.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Lint
+      # This cop checks for colons and commas in %i, e.g. `%i(:foo, :bar)`
+      #
+      # It is more likely that the additional characters are unintended (for
+      # example, mistranslating an array of literals to percent string notation)
+      # rather than meant to be part of the resulting symbols.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   %i(:foo, :bar)
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   %i(foo bar)
+      class PercentSymbolArray < Cop
+        include PercentLiteral
+
+        MSG = "Within `%i`/`%I`, ':' and ',' are unnecessary and may be " \
+          'unwanted in the resulting symbols.'.freeze
+
+        def on_array(node)
+          process(node, '%i', '%I')
+        end
+
+        def on_percent_literal(node)
+          return unless contains_colons_or_commas?(node)
+
+          add_offense(node, :expression, MSG)
+        end
+
+        private
+
+        def contains_colons_or_commas?(node)
+          patterns = [/^:/, /,$/]
+          node.children.any? do |child|
+            literal = child.children.first
+
+            # To avoid likely false positives (e.g. a single ' or ")
+            next if literal.to_s.gsub(/[^\p{Alnum}]/, '').empty?
+
+            patterns.any? { |pat| literal =~ pat }
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            node.children.each do |child|
+              range = child.loc.expression
+
+              corrector.remove_trailing(range, 1) if /,$/ =~ range.source
+              corrector.remove_leading(range, 1) if /^:/ =~ range.source
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/lint/rand_one.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Lint
+      # This cop checks for `rand(1)` calls.
+      # Such calls always return `0`.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   rand 1
+      #   Kernel.rand(-1)
+      #   rand 1.0
+      #   rand(-1.0)
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   0 # just use 0 instead
+      class RandOne < Cop
+        MSG = '`%s` always returns `0`. ' \
+              'Perhaps you meant `rand(2)` or `rand`?'.freeze
+
+        def_node_matcher :rand_one?, <<-PATTERN
+          (send {(const nil :Kernel) nil} :rand {(int {-1 1}) (float {-1.0 1.0})})
+        PATTERN
+
+        def on_send(node)
+          return unless rand_one?(node)
+
+          add_offense(node, :expression, format(MSG, node.source))
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/lint/require_parentheses.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Lint
+      # This cop checks for expressions where there is a call to a predicate
+      # method with at least one argument, where no parentheses are used around
+      # the parameter list, and a boolean operator, && or ||, is used in the
+      # last argument.
+      #
+      # The idea behind warning for these constructs is that the user might
+      # be under the impression that the return value from the method call is
+      # an operand of &&/||.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   if day.is? :tuesday && month == :jan
+      #     ...
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   if day.is?(:tuesday) && month == :jan
+      class RequireParentheses < Cop
+        MSG = 'Use parentheses in the method call to avoid confusion about ' \
+              'precedence.'.freeze
+
+        def on_send(node)
+          return if !node.arguments? || node.parenthesized?
+
+          if node.first_argument.if_type? && node.first_argument.ternary?
+            check_ternary(node.first_argument, node)
+          elsif node.predicate_method?
+            check_predicate(node.last_argument, node)
+          end
+        end
+
+        private
+
+        def check_ternary(ternary, node)
+          return unless ternary.condition.operator_keyword?
+
+          range = range_between(node.source_range.begin_pos,
+                                ternary.condition.source_range.end_pos)
+
+          add_offense(range, range)
+        end
+
+        def check_predicate(predicate, node)
+          return unless predicate.operator_keyword?
+
+          add_offense(node, :expression)
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/lint/rescue_exception.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Lint
+      # This cop checks for *rescue* blocks targeting the Exception class.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   begin
+      #     do_something
+      #   rescue Exception
+      #     handle_exception
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   begin
+      #     do_something
+      #   rescue ArgumentError
+      #     handle_exception
+      #   end
+      class RescueException < Cop
+        MSG = 'Avoid rescuing the `Exception` class. ' \
+              'Perhaps you meant to rescue `StandardError`?'.freeze
+
+        def on_resbody(node)
+          return unless node.children.first
+          rescue_args = node.children.first.children
+          return unless rescue_args.any? { |a| targets_exception?(a) }
+
+          add_offense(node, :expression)
+        end
+
+        def targets_exception?(rescue_arg_node)
+          rescue_arg_node.const_name == 'Exception'
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/lint/safe_navigation_chain.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Lint
+      # The safe navigation operator returns nil if the receiver is
+      # nil.  If you chain an ordinary method call after a safe
+      # navigation operator, it raises NoMethodError.  We should use a
+      # safe navigation operator after a safe navigation operator.
+      # This cop checks for the problem outlined above.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   x&.foo.bar
+      #   x&.foo + bar
+      #   x&.foo[bar]
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   x&.foo&.bar
+      #   x&.foo || bar
+      class SafeNavigationChain < Cop
+        extend TargetRubyVersion
+
+        MSG = 'Do not chain ordinary method call' \
+              ' after safe navigation operator.'.freeze
+
+        def_node_matcher :bad_method?, <<-PATTERN
+          (send (csend ...) $_ ...)
+        PATTERN
+
+        minimum_target_ruby_version 2.3
+
+        def on_send(node)
+          bad_method?(node) do |method|
+            return if nil_methods.include?(method)
+
+            loc = node.loc.dot || :selector
+
+            add_offense(node, loc)
+          end
+        end
+
+        def autocorrect(node)
+          dot = node.loc.dot
+
+          return unless dot
+
+          lambda do |corrector|
+            corrector.insert_before(dot, '&')
+          end
+        end
+
+        private
+
+        def nil_methods
+          nil.methods + whitelist
+        end
+
+        def whitelist
+          cop_config['Whitelist'].map(&:to_sym)
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/lint/shadowed_exception.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Lint
+      # This cop checks for a rescued exception that get shadowed by a
+      # less specific exception being rescued before a more specific
+      # exception is rescued.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   begin
+      #     something
+      #   rescue Exception
+      #     handle_exception
+      #   rescue StandardError
+      #     handle_standard_error
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   begin
+      #     something
+      #   rescue StandardError
+      #     handle_standard_error
+      #   rescue Exception
+      #     handle_exception
+      #   end
+      class ShadowedException < Cop
+        include RescueNode
+
+        MSG = 'Do not shadow rescued Exceptions.'.freeze
+
+        def on_rescue(node)
+          return if rescue_modifier?(node)
+          _body, *rescues, _else = *node
+          rescued_groups = rescues.each_with_object([]) do |group, exceptions|
+            rescue_group, = *group
+
+            exceptions << evaluate_exceptions(rescue_group)
+          end
+
+          rescue_group_rescues_multiple_levels = rescued_groups.any? do |group|
+            contains_multiple_levels_of_exceptions?(group)
+          end
+
+          return if !rescue_group_rescues_multiple_levels &&
+                    sorted?(rescued_groups)
+
+          add_offense(node, offense_range(rescues))
+        end
+
+        private
+
+        def offense_range(rescues)
+          first_rescue = rescues.first
+          last_rescue = rescues.last
+          last_exceptions, = *last_rescue
+          # last_rescue clause may not specify exception class
+          end_pos = if last_exceptions
+                      last_exceptions.loc.expression.end_pos
+                    else
+                      last_rescue.loc.keyword.end_pos
+                    end
+
+          range_between(first_rescue.loc.expression.begin_pos, end_pos)
+        end
+
+        def contains_multiple_levels_of_exceptions?(group)
+          if group.size > 1 && group.include?(Exception)
+            # Treat `Exception` as the highest level exception unless `nil` was
+            # also rescued
+            return !(group.size == 2 && group.include?(NilClass))
+          end
+
+          group.combination(2).any? { |a, b| a && b && a <=> b }
+        end
+
+        def evaluate_exceptions(rescue_group)
+          if rescue_group
+            rescued_exceptions = rescued_exceptions(rescue_group)
+            rescued_exceptions.each_with_object([]) do |exception, converted|
+              begin
+                converted << Kernel.const_get(exception)
+              rescue NameError
+                converted << nil
+              end
+            end
+          else
+            # treat an empty `rescue` as `rescue StandardError`
+            [StandardError]
+          end
+        end
+
+        def sorted?(rescued_groups)
+          rescued_groups.each_cons(2).all? do |x, y|
+            if x.include?(Exception)
+              false
+            elsif y.include?(Exception)
+              true
+            elsif x.none? || y.none?
+              # consider sorted if a group is empty or only contains
+              # `nil`s
+              true
+            else
+              (x <=> y || 0) <= 0
+            end
+          end
+        end
+
+        # @param [RubbyCop::AST::Node] rescue_group is a node of array_type
+        def rescued_exceptions(rescue_group)
+          klasses = *rescue_group
+          klasses.map do |klass|
+            # `rescue nil` is valid syntax in all versions of Ruby. In Ruby
+            # 1.9.3, it effectively disables the `rescue`. In versions
+            # after 1.9.3, a `TypeError` is thrown when the statement is
+            # rescued. In order to account for this, we convert `nil` to
+            # `NilClass`.
+            next 'NilClass' if klass.nil_type?
+            next unless klass.const_type?
+            klass.source
+          end.compact
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/lint/shadowing_outer_local_variable.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Lint
+      # This cop looks for use of the same name as outer local variables
+      # for block arguments or block local variables.
+      # This is a mimic of the warning
+      # "shadowing outer local variable - foo" from `ruby -cw`.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   def some_method
+      #     foo = 1
+      #
+      #     2.times do |foo| # shadowing outer `foo`
+      #       do_something(foo)
+      #     end
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def some_method
+      #     foo = 1
+      #
+      #     2.times do |bar|
+      #       do_something(bar)
+      #     end
+      #   end
+      class ShadowingOuterLocalVariable < Cop
+        MSG = 'Shadowing outer local variable - `%s`.'.freeze
+
+        def join_force?(force_class)
+          force_class == VariableForce
+        end
+
+        def before_declaring_variable(variable, variable_table)
+          return if variable.should_be_unused?
+
+          outer_local_variable = variable_table.find_variable(variable.name)
+          return unless outer_local_variable
+
+          message = format(MSG, variable.name)
+          add_offense(variable.declaration_node, :expression, message)
+        end
+      end
+    end
+  end
+end