rbhint 0.8.5.rc1

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

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks if each_with_object is called with an immutable
+      # argument. Since the argument is the object that the given block shall
+      # make calls on to build something based on the enumerable that
+      # each_with_object iterates over, an immutable argument makes no sense.
+      # It's definitely a bug.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   sum = numbers.each_with_object(0) { |e, a| a += e }
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   num = 0
+      #   sum = numbers.each_with_object(num) { |e, a| a += e }
+      class EachWithObjectArgument < Cop
+        MSG = 'The argument to each_with_object cannot be immutable.'
+
+        def_node_matcher :each_with_object?, <<~PATTERN
+          ({send csend} _ :each_with_object $_)
+        PATTERN
+
+        def on_send(node)
+          each_with_object?(node) do |arg|
+            return unless arg.immutable_literal?
+
+            add_offense(node)
+          end
+        end
+        alias on_csend on_send
+      end
+    end
+  end
+end