rubbycop 0.49.0

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Lint
+      # This cop checks for circular argument references in optional keyword
+      # arguments and optional ordinal arguments.
+      #
+      # This cop mirrors a warning produced by MRI since 2.2.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   def bake(pie: pie)
+      #     pie.heat_up
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def bake(pie:)
+      #     pie.refrigerate
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def bake(pie: self.pie)
+      #     pie.feed_to(user)
+      #   end
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   def cook(dry_ingredients = dry_ingredients)
+      #     dry_ingredients.reduce(&:+)
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def cook(dry_ingredients = self.dry_ingredients)
+      #     dry_ingredients.combine
+      #   end
+      class CircularArgumentReference < Cop
+        MSG = 'Circular argument reference - `%s`.'.freeze
+
+        def on_kwoptarg(node)
+          check_for_circular_argument_references(*node)
+        end
+
+        def on_optarg(node)
+          check_for_circular_argument_references(*node)
+        end
+
+        private
+
+        def check_for_circular_argument_references(arg_name, arg_value)
+          case arg_value.type
+          when :send
+            # Ruby 2.0 will have type send every time, and "send nil" if it is
+            # calling itself with a specified "self" receiver
+            receiver, name = *arg_value
+            return unless name == arg_name && receiver.nil?
+          when :lvar
+            # Ruby 2.2.2 will have type lvar if it is calling its own method
+            # without a specified "self"
+            return unless arg_value.to_a == [arg_name]
+          else
+            return
+          end
+
+          add_offense(arg_value, :expression, format(MSG, arg_name))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Lint
+      # This cop checks for conditions that are not on the same line as
+      # if/while/until.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   if
+      #     some_condition
+      #     do_something
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   if some_condition
+      #     do_something
+      #   end
+      class ConditionPosition < Cop
+        MSG = 'Place the condition on the same line as `%s`.'.freeze
+
+        def on_if(node)
+          return if node.ternary?
+
+          check(node)
+        end
+
+        def on_while(node)
+          check(node)
+        end
+
+        def on_until(node)
+          check(node)
+        end
+
+        private
+
+        def check(node)
+          return if node.modifier_form? || node.single_line_condition?
+
+          add_offense(node.condition, :expression, format(MSG, node.keyword))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Lint
+      # This cop checks for calls to debugger or pry.
+      #
+      # @example
+      #
+      #   # bad (ok during development)
+      #
+      #   # using pry
+      #   def some_method
+      #     binding.pry
+      #     do_something
+      #   end
+      #
+      # @example
+      #
+      #   # bad (ok during development)
+      #
+      #   # using byebug
+      #   def some_method
+      #     byebug
+      #     do_something
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def some_method
+      #     do_something
+      #   end
+      class Debugger < Cop
+        MSG = 'Remove debugger entry point `%s`.'.freeze
+
+        def_node_matcher :debugger_call?, <<-END
+          {(send nil {:debugger :byebug} ...)
+           (send (send nil :binding)
+             {:pry :remote_pry :pry_remote} ...)
+           (send (const nil :Pry) :rescue ...)
+           (send nil {:save_and_open_page
+                      :save_and_open_screenshot
+                      :save_screenshot} ...)}
+        END
+
+        def_node_matcher :binding_irb_call?, <<-END
+          (send (send nil :binding) :irb ...)
+        END
+
+        def_node_matcher :pry_rescue?, '(send (const nil :Pry) :rescue ...)'
+
+        def on_send(node)
+          return unless debugger_call?(node) || binding_irb?(node)
+
+          add_offense(node, :expression)
+        end
+
+        private
+
+        def message(node)
+          format(MSG, node.source)
+        end
+
+        def binding_irb?(node)
+          target_ruby_version >= 2.4 && binding_irb_call?(node)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Lint
+      # This cop checks whether the end keywords of method definitions are
+      # aligned properly.
+      #
+      # Two modes are supported through the EnforcedStyleAlignWith configuration
+      # parameter. If it's set to `start_of_line` (which is the default), the
+      # `end` shall be aligned with the start of the line where the `def`
+      # keyword is. If it's set to `def`, the `end` shall be aligned with the
+      # `def` keyword.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   private def foo
+      #               end
+      #
+      # @example
+      #
+      #   # EnforcedStyleAlignWith: start_of_line (default)
+      #
+      #   # good
+      #
+      #   private def foo
+      #   end
+      #
+      # @example
+      #
+      #   # EnforcedStyleAlignWith: def
+      #
+      #   # good
+      #
+      #   private def foo
+      #           end
+      class DefEndAlignment < Cop
+        include OnMethodDef
+        include EndKeywordAlignment
+
+        MSG = '`end` at %d, %d is not aligned with `%s` at %d, %d.'.freeze
+
+        def on_method_def(node, _method_name, _args, _body)
+          check_end_kw_in_node(node)
+        end
+
+        def on_send(node)
+          return unless modifier_and_def_on_same_line?(node)
+
+          method_def = node.first_argument
+          expr = node.source_range
+
+          line_start = range_between(expr.begin_pos,
+                                     method_def.loc.keyword.end_pos)
+          align_with = {
+            def: method_def.loc.keyword,
+            start_of_line: line_start
+          }
+
+          check_end_kw_alignment(method_def, align_with)
+          ignore_node(method_def) # Don't check the same `end` again.
+        end
+
+        private
+
+        def autocorrect(node)
+          if style == :start_of_line && node.parent && node.parent.send_type?
+            align(node, node.parent)
+          else
+            align(node, node)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Lint
+      # This cop checks for uses of the deprecated class method usages.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   File.exists?(some_path)
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   File.exist?(some_path)
+      class DeprecatedClassMethods < Cop
+        # Inner class to DeprecatedClassMethods.
+        # This class exists to add abstraction and clean naming to the
+        # objects that are going to be operated on.
+        class DeprecatedClassMethod
+          include RubbyCop::AST::Sexp
+
+          attr_reader :class_constant, :deprecated_method, :replacement_method
+
+          def initialize(class_constant, deprecated_method, replacement_method)
+            @class_constant = class_constant
+            @deprecated_method = deprecated_method
+            @replacement_method = replacement_method
+          end
+
+          def class_nodes
+            @class_nodes ||= [
+              s(:const, nil, class_constant),
+              s(:const, s(:cbase), class_constant)
+            ]
+          end
+        end
+
+        MSG = '`%s` is deprecated in favor of `%s`.'.freeze
+        DEPRECATED_METHODS_OBJECT = [
+          DeprecatedClassMethod.new(:File, :exists?, :exist?),
+          DeprecatedClassMethod.new(:Dir, :exists?, :exist?)
+        ].freeze
+
+        def on_send(node)
+          check(node) do |data|
+            add_offense(node, :selector,
+                        format(MSG,
+                               deprecated_method(data),
+                               replacement_method(data)))
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            check(node) do |data|
+              corrector.replace(node.loc.selector,
+                                data.replacement_method.to_s)
+            end
+          end
+        end
+
+        private
+
+        def check(node)
+          DEPRECATED_METHODS_OBJECT.each do |data|
+            next unless data.class_nodes.include?(node.receiver)
+            next unless node.method?(data.deprecated_method)
+            yield data
+          end
+        end
+
+        def deprecated_method(data)
+          method_call(data.class_constant, data.deprecated_method)
+        end
+
+        def replacement_method(data)
+          method_call(data.class_constant, data.replacement_method)
+        end
+
+        def method_call(class_constant, method)
+          format('%s.%s', class_constant, method)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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.'.freeze
+
+        def on_case(case_node)
+          case_node.when_branches.each_with_object([]) do |when_node, previous|
+            when_node.each_condition do |condition|
+              if repeated_condition?(previous, condition)
+                add_offense(condition, :expression, MSG)
+              end
+            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/rubbycop/cop/lint/duplicate_methods.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Lint
+      # This cop checks for duplicated instance (or singleton) method
+      # definitions.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   def duplicated
+      #     1
+      #   end
+      #
+      #   def duplicated
+      #     2
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def duplicated
+      #     1
+      #   end
+      #
+      #   def other_duplicated
+      #     2
+      #   end
+      class DuplicateMethods < Cop
+        MSG = 'Method `%s` is defined at both %s and %s.'.freeze
+
+        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)
+
+          return unless (scope = node.parent_module_name)
+          found_instance_method(node, scope)
+        end
+
+        def on_defs(node)
+          return if node.ancestors.any?(&:if_type?)
+          return if possible_dsl?(node)
+
+          receiver, name, = *node
+          if receiver.const_type?
+            _, const_name = *receiver
+            check_const_receiver(node, name, const_name)
+          elsif receiver.self_type?
+            check_self_receiver(node, name)
+          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_name, @definitions[method_name],
+                 source_location(node))
+        end
+
+        def found_instance_method(node, scope)
+          name, = *node
+          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)
+            add_offense(node, :keyword, message_for_dup(node, method_name))
+          else
+            @definitions[method_name] = source_location(node)
+          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
+          "#{range.source_buffer.name}:#{range.line}"
+        end
+      end
+    end
+  end
+end