rubocop 0.87.1

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

@@ -0,0 +1,137 @@
+# 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 < Cop
+        include RangeHelp
+
+        MSG = 'Use `%<constant>s.%<method>s(%<replacement_args>s)`' \
+          ' instead of `%<original>s`.'
+
+        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? }
+
+          add_offense(node) if algorithm_const(node)
+        end
+
+        def autocorrect(node)
+          algorithm_constant, = algorithm_const(node)
+
+          lambda do |corrector|
+            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
+        end
+
+        private
+
+        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'
+            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)
+          else
+            (["'#{algorithm_name}'"] + node.arguments.map(&:source)).join(', ')
+          end
+        end
+
+        def build_cipher_arguments(node, algorithm_name)
+          algorithm_parts = algorithm_name.downcase.split('-')
+          size_and_mode = sanitize_arguments(node.arguments).map(&:downcase)
+          "'#{(algorithm_parts + size_and_mode + ['cbc']).take(3).join('-')}'"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+# 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 < Cop
+        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
+          add_offense(node, location: :operator) if lhs.ivasgn_type?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks that there are no repeated conditions
+      # used in case 'when' expressions.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   case x
+      #   when 'first'
+      #     do_something
+      #   when 'first'
+      #     do_something_else
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   case x
+      #   when 'first'
+      #     do_something
+      #   when 'second'
+      #     do_something_else
+      #   end
+      class DuplicateCaseCondition < Cop
+        MSG = 'Duplicate `when` condition detected.'
+
+        def on_case(case_node)
+          case_node.when_branches.each_with_object([]) do |when_node, previous|
+            when_node.each_condition do |condition|
+              next unless repeated_condition?(previous, condition)
+
+              add_offense(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
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for duplicated keys in hash literals.
+      #
+      # This cop mirrors a warning in Ruby 2.2.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   hash = { food: 'apple', food: 'orange' }
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   hash = { food: 'apple', other_food: 'orange' }
+      class DuplicateHashKey < Cop
+        include Duplication
+
+        MSG = 'Duplicated key in hash literal.'
+
+        def on_hash(node)
+          keys = node.keys.select(&:recursive_basic_literal?)
+
+          return unless duplicates?(keys)
+
+          consecutive_duplicates(keys).each do |key|
+            add_offense(key)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for duplicated instance (or singleton) method
+      # definitions.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   def foo
+      #     1
+      #   end
+      #
+      #   def foo
+      #     2
+      #   end
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   def foo
+      #     1
+      #   end
+      #
+      #   alias foo bar
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def foo
+      #     1
+      #   end
+      #
+      #   def bar
+      #     2
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def foo
+      #     1
+      #   end
+      #
+      #   alias bar foo
+      class DuplicateMethods < Cop
+        MSG = 'Method `%<method>s` is defined at both %<defined>s and ' \
+              '%<current>s.'
+
+        def initialize(config = nil, options = nil)
+          super
+          @definitions = {}
+        end
+
+        def on_def(node)
+          # if a method definition is inside an if, it is very likely
+          # that a different definition is used depending on platform, etc.
+          return if node.ancestors.any?(&:if_type?)
+          return if possible_dsl?(node)
+
+          found_instance_method(node, node.method_name)
+        end
+
+        def on_defs(node)
+          return if node.ancestors.any?(&:if_type?)
+          return if possible_dsl?(node)
+
+          if node.receiver.const_type?
+            _, const_name = *node.receiver
+            check_const_receiver(node, node.method_name, const_name)
+          elsif node.receiver.self_type?
+            check_self_receiver(node, node.method_name)
+          end
+        end
+
+        def_node_matcher :method_alias?, <<~PATTERN
+          (alias (sym $_name) sym)
+        PATTERN
+
+        def on_alias(node)
+          return unless (name = method_alias?(node))
+          return if node.ancestors.any?(&:if_type?)
+          return if possible_dsl?(node)
+
+          found_instance_method(node, name)
+        end
+
+        def_node_matcher :alias_method?, <<~PATTERN
+          (send nil? :alias_method (sym $_name) _)
+        PATTERN
+
+        def_node_matcher :sym_name, '(sym $_name)'
+
+        def on_send(node)
+          if (name = alias_method?(node))
+            return unless name
+            return if node.ancestors.any?(&:if_type?)
+            return if possible_dsl?(node)
+
+            found_instance_method(node, name)
+          elsif (attr = node.attribute_accessor?)
+            on_attr(node, *attr)
+          end
+        end
+
+        private
+
+        def check_const_receiver(node, name, const_name)
+          qualified = lookup_constant(node, const_name)
+          return unless qualified
+
+          found_method(node, "#{qualified}.#{name}")
+        end
+
+        def check_self_receiver(node, name)
+          enclosing = node.parent_module_name
+          return unless enclosing
+
+          found_method(node, "#{enclosing}.#{name}")
+        end
+
+        def message_for_dup(node, method_name)
+          format(MSG, method: method_name, defined: @definitions[method_name],
+                      current: source_location(node))
+        end
+
+        def found_instance_method(node, name)
+          return unless (scope = node.parent_module_name)
+
+          if scope =~ /\A#<Class:(.*)>\Z/
+            found_method(node, "#{Regexp.last_match(1)}.#{name}")
+          else
+            found_method(node, "#{scope}##{name}")
+          end
+        end
+
+        def found_method(node, method_name)
+          if @definitions.key?(method_name)
+            loc = case node.type
+                  when :def, :defs
+                    node.loc.keyword.join(node.loc.name)
+                  else
+                    node.loc.expression
+                  end
+            message = message_for_dup(node, method_name)
+
+            add_offense(node, location: loc, message: message)
+          else
+            @definitions[method_name] = source_location(node)
+          end
+        end
+
+        def on_attr(node, attr_name, args)
+          case attr_name
+          when :attr
+            writable = args.size == 2 && args.last.true_type?
+            found_attr(node, [args.first], readable: true, writable: writable)
+          when :attr_reader
+            found_attr(node, args, readable: true)
+          when :attr_writer
+            found_attr(node, args, writable: true)
+          when :attr_accessor
+            found_attr(node, args, readable: true, writable: true)
+          end
+        end
+
+        def found_attr(node, args, readable: false, writable: false)
+          args.each do |arg|
+            name = sym_name(arg)
+            next unless name
+
+            found_instance_method(node, name) if readable
+            found_instance_method(node, "#{name}=") if writable
+          end
+        end
+
+        def lookup_constant(node, const_name)
+          # this method is quite imperfect and can be fooled
+          # to do much better, we would need to do global analysis of the whole
+          # codebase
+          node.each_ancestor(:class, :module, :casgn) do |ancestor|
+            namespace, mod_name = *ancestor.defined_module
+            loop do
+              if mod_name == const_name
+                return qualified_name(ancestor.parent_module_name,
+                                      namespace,
+                                      mod_name)
+              end
+
+              break if namespace.nil?
+
+              namespace, mod_name = *namespace
+            end
+          end
+        end
+
+        def qualified_name(enclosing, namespace, mod_name)
+          if enclosing != 'Object'
+            if namespace
+              "#{enclosing}::#{namespace.const_name}::#{mod_name}"
+            else
+              "#{enclosing}::#{mod_name}"
+            end
+          elsif namespace
+            "#{namespace.const_name}::#{mod_name}"
+          else
+            mod_name
+          end
+        end
+
+        def possible_dsl?(node)
+          # DSL methods may evaluate a block in the context of a newly created
+          # class or module
+          # Assume that if a method definition is inside any block call which
+          # we can't identify, it could be a DSL
+          node.each_ancestor(:block).any? do |ancestor|
+            ancestor.method_name != :class_eval && !ancestor.class_constructor?
+          end
+        end
+
+        def source_location(node)
+          range = node.location.expression
+          path = smart_path(range.source_buffer.name)
+          "#{path}:#{range.line}"
+        end
+      end
+    end
+  end
+end