rubocop 0.48.1 → 1.16.0

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

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Algorithmic constants for `OpenSSL::Cipher` and `OpenSSL::Digest`
+      # deprecated since OpenSSL version 2.2.0. Prefer passing a string
+      # instead.
+      #
+      # @example
+      #
+      #   # Example for OpenSSL::Cipher instantiation.
+      #
+      #   # bad
+      #   OpenSSL::Cipher::AES.new(128, :GCM)
+      #
+      #   # good
+      #   OpenSSL::Cipher.new('aes-128-gcm')
+      #
+      # @example
+      #
+      #   # Example for OpenSSL::Digest instantiation.
+      #
+      #   # bad
+      #   OpenSSL::Digest::SHA256.new
+      #
+      #   # good
+      #   OpenSSL::Digest.new('SHA256')
+      #
+      # @example
+      #
+      #   # Example for ::Digest inherited class methods.
+      #
+      #   # bad
+      #   OpenSSL::Digest::SHA256.digest('foo')
+      #
+      #   # good
+      #   OpenSSL::Digest.digest('SHA256', 'foo')
+      #
+      class DeprecatedOpenSSLConstant < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Use `%<constant>s.%<method>s(%<replacement_args>s)` instead of `%<original>s`.'
+
+        NO_ARG_ALGORITHM = %w[BF DES IDEA RC4].freeze
+
+        # @!method algorithm_const(node)
+        def_node_matcher :algorithm_const, <<~PATTERN
+          (send
+            $(const
+              (const
+                (const {nil? cbase} :OpenSSL) {:Cipher :Digest})
+              _)
+            ...)
+        PATTERN
+
+        def on_send(node)
+          return if node.arguments.any? { |arg| arg.variable? || arg.send_type? || arg.const_type? }
+          return unless algorithm_const(node)
+
+          message = message(node)
+
+          add_offense(node, message: message) { |corrector| autocorrect(corrector, node) }
+        end
+
+        private
+
+        def autocorrect(corrector, node)
+          algorithm_constant, = algorithm_const(node)
+
+          corrector.remove(algorithm_constant.loc.double_colon)
+          corrector.remove(algorithm_constant.loc.name)
+
+          corrector.replace(
+            correction_range(node),
+            "#{node.loc.selector.source}(#{replacement_args(node)})"
+          )
+        end
+
+        def message(node)
+          algorithm_constant, = algorithm_const(node)
+          parent_constant = openssl_class(algorithm_constant)
+          replacement_args = replacement_args(node)
+          method = node.loc.selector.source
+
+          format(
+            MSG,
+            constant: parent_constant,
+            method: method,
+            replacement_args: replacement_args,
+            original: node.source
+          )
+        end
+
+        def correction_range(node)
+          range_between(node.loc.dot.end_pos, node.loc.expression.end_pos)
+        end
+
+        def openssl_class(node)
+          node.children.first.source
+        end
+
+        def algorithm_name(node)
+          name = node.loc.name.source
+
+          if openssl_class(node) == 'OpenSSL::Cipher' && !NO_ARG_ALGORITHM.include?(name)
+            name.scan(/.{3}/).join('-')
+          else
+            name
+          end
+        end
+
+        def sanitize_arguments(arguments)
+          arguments.flat_map do |arg|
+            argument = arg.str_type? ? arg.value : arg.source
+
+            argument.tr(":'", '').split('-')
+          end
+        end
+
+        def replacement_args(node)
+          algorithm_constant, = algorithm_const(node)
+          algorithm_name = algorithm_name(algorithm_constant)
+
+          if openssl_class(algorithm_constant) == 'OpenSSL::Cipher'
+            build_cipher_arguments(node, algorithm_name, node.arguments.empty?)
+          else
+            (["'#{algorithm_name}'"] + node.arguments.map(&:source)).join(', ')
+          end
+        end
+
+        def build_cipher_arguments(node, algorithm_name, no_arguments)
+          algorithm_parts = algorithm_name.downcase.split('-')
+          size_and_mode = sanitize_arguments(node.arguments).map(&:downcase)
+
+          if NO_ARG_ALGORITHM.include?(algorithm_parts.first.upcase) && no_arguments
+            "'#{algorithm_parts.first}'"
+          else
+            mode = 'cbc' unless size_and_mode == ['cbc']
+
+            "'#{(algorithm_parts + size_and_mode + [mode]).compact.take(3).join('-')}'"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks constructors for disjunctive assignments that should
+      # be plain assignments.
+      #
+      # So far, this cop is only concerned with disjunctive assignment of
+      # instance variables.
+      #
+      # In ruby, an instance variable is nil until a value is assigned, so the
+      # disjunction is unnecessary. A plain assignment has the same effect.
+      #
+      # @example
+      #   # bad
+      #   def initialize
+      #     @x ||= 1
+      #   end
+      #
+      #   # good
+      #   def initialize
+      #     @x = 1
+      #   end
+      class DisjunctiveAssignmentInConstructor < Base
+        extend AutoCorrector
+
+        MSG = 'Unnecessary disjunctive assignment. Use plain assignment.'
+
+        def on_def(node)
+          check(node)
+        end
+
+        private
+
+        # @param [DefNode] node a constructor definition
+        def check(node)
+          return unless node.method?(:initialize)
+
+          check_body(node.body)
+        end
+
+        def check_body(body)
+          return if body.nil?
+
+          case body.type
+          when :begin
+            check_body_lines(body.child_nodes)
+          else
+            check_body_lines([body])
+          end
+        end
+
+        # @param [Array] lines the logical lines of the constructor
+        def check_body_lines(lines)
+          lines.each do |line|
+            case line.type
+            when :or_asgn
+              check_disjunctive_assignment(line)
+            else
+              # Once we encounter something other than a disjunctive
+              # assignment, we cease our investigation, because we can't be
+              # certain that any future disjunctive assignments are offensive.
+              # You're off the case, detective!
+              break
+            end
+          end
+        end
+
+        # Add an offense if the LHS of the given disjunctive assignment is
+        # an instance variable.
+        #
+        # For now, we only care about assignments to instance variables.
+        #
+        # @param [Node] node a disjunctive assignment
+        def check_disjunctive_assignment(node)
+          lhs = node.child_nodes.first
+          return unless lhs.ivasgn_type?
+
+          add_offense(node.loc.operator) do |corrector|
+            corrector.replace(node.loc.operator, '=')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks that there are no repeated bodies
+      # within `if/unless`, `case-when` and `rescue` constructs.
+      #
+      # With `IgnoreLiteralBranches: true`, branches are not registered
+      # as offenses if they return a basic literal value (string, symbol,
+      # integer, float, rational, complex, `true`, `false`, or `nil`), or
+      # return an array, hash, regexp or range that only contains one of
+      # the above basic literal values.
+      #
+      # With `IgnoreConstantBranches: true`, branches are not registered
+      # as offenses if they return a constant value.
+      #
+      # @example
+      #   # bad
+      #   if foo
+      #     do_foo
+      #     do_something_else
+      #   elsif bar
+      #     do_foo
+      #     do_something_else
+      #   end
+      #
+      #   # good
+      #   if foo || bar
+      #     do_foo
+      #     do_something_else
+      #   end
+      #
+      #   # bad
+      #   case x
+      #   when foo
+      #     do_foo
+      #   when bar
+      #     do_foo
+      #   else
+      #     do_something_else
+      #   end
+      #
+      #   # good
+      #   case x
+      #   when foo, bar
+      #     do_foo
+      #   else
+      #     do_something_else
+      #   end
+      #
+      #   # bad
+      #   begin
+      #     do_something
+      #   rescue FooError
+      #     handle_error
+      #   rescue BarError
+      #     handle_error
+      #   end
+      #
+      #   # good
+      #   begin
+      #     do_something
+      #   rescue FooError, BarError
+      #     handle_error
+      #   end
+      #
+      # @example IgnoreLiteralBranches: true
+      #   # good
+      #   case size
+      #   when "small" then 100
+      #   when "medium" then 250
+      #   when "large" then 1000
+      #   else 250
+      #   end
+      #
+      # @example IgnoreConstantBranches: true
+      #   # good
+      #   case size
+      #   when "small" then SMALL_SIZE
+      #   when "medium" then MEDIUM_SIZE
+      #   when "large" then LARGE_SIZE
+      #   else MEDIUM_SIZE
+      #   end
+      #
+      class DuplicateBranch < Base
+        include RescueNode
+
+        MSG = 'Duplicate branch body detected.'
+
+        def on_branching_statement(node)
+          branches(node).each_with_object(Set.new) do |branch, previous|
+            next unless consider_branch?(branch)
+
+            add_offense(offense_range(branch)) unless previous.add?(branch)
+          end
+        end
+        alias on_if on_branching_statement
+        alias on_case on_branching_statement
+        alias on_rescue on_branching_statement
+
+        private
+
+        def offense_range(duplicate_branch)
+          parent = duplicate_branch.parent
+
+          if parent.respond_to?(:else_branch) && parent.else_branch.equal?(duplicate_branch)
+            if parent.if_type? && parent.ternary?
+              duplicate_branch.source_range
+            else
+              parent.loc.else
+            end
+          else
+            parent.source_range
+          end
+        end
+
+        def branches(node)
+          node.branches.compact
+        end
+
+        def consider_branch?(branch)
+          return false if ignore_literal_branches? && literal_branch?(branch)
+          return false if ignore_constant_branches? && const_branch?(branch)
+
+          true
+        end
+
+        def ignore_literal_branches?
+          cop_config.fetch('IgnoreLiteralBranches', false)
+        end
+
+        def ignore_constant_branches?
+          cop_config.fetch('IgnoreConstantBranches', false)
+        end
+
+        def literal_branch?(branch) # rubocop:disable Metrics/CyclomaticComplexity
+          return false if !branch.literal? || branch.xstr_type?
+          return true if branch.basic_literal?
+
+          branch.each_descendant.all? do |node|
+            node.basic_literal? ||
+              node.pair_type? || # hash keys and values are contained within a `pair` node
+              (node.const_type? && ignore_constant_branches?)
+          end
+        end
+
+        def const_branch?(branch)
+          branch.const_type?
+        end
+      end
+    end
+  end
+end

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

@@ -27,26 +27,16 @@ module RuboCop
       #   when 'second'
       #     do_something_else
       #   end
-      class DuplicateCaseCondition < Cop
-        MSG = 'Duplicate `when` condition detected.'.freeze
+      class DuplicateCaseCondition < Base
+        MSG = 'Duplicate `when` condition detected.'
 
         def on_case(case_node)
-          case_node.when_branches.each_with_object([]) do |when_node, previous|
+          case_node.when_branches.each_with_object(Set.new) do |when_node, previous|
             when_node.each_condition do |condition|
-              if repeated_condition?(previous, condition)
-                add_offense(condition, :expression, MSG)
-              end
+              add_offense(condition) unless previous.add?(condition)
             end
-
-            previous.push(when_node.conditions)
           end
         end
-
-        private
-
-        def repeated_condition?(previous, condition)
-          previous.any? { |c| c.include?(condition) }
-        end
       end
     end
   end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks that there are no repeated conditions used in if 'elsif'.
+      #
+      # @example
+      #   # bad
+      #   if x == 1
+      #     do_something
+      #   elsif x == 1
+      #     do_something_else
+      #   end
+      #
+      #   # good
+      #   if x == 1
+      #     do_something
+      #   elsif x == 2
+      #     do_something_else
+      #   end
+      #
+      class DuplicateElsifCondition < Base
+        MSG = 'Duplicate `elsif` condition detected.'
+
+        def on_if(node)
+          previous = []
+          while node.if? || node.elsif?
+            condition = node.condition
+            add_offense(condition) if previous.include?(condition)
+            previous << condition
+            node = node.else_branch
+            break unless node&.if_type?
+          end
+        end
+      end
+    end
+  end
+end