rubbycop 0.49.0

data/lib/rubbycop/cop/style/redundant_self.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop checks for redundant uses of `self`.
+      #
+      # `self` is only needed when:
+      #
+      # * Sending a message to same object with zero arguments in
+      #   presence of a method name clash with an argument or a local
+      #   variable.
+      #
+      #   Note, with using explicit self you can only send messages
+      #   with public or protected scope, you cannot send private
+      #   messages this way.
+      #
+      #   Example:
+      #
+      #   def bar
+      #     :baz
+      #   end
+      #
+      #   def foo(bar)
+      #     self.bar # resolves name clash with argument
+      #   end
+      #
+      #   def foo2
+      #     bar = 1
+      #     self.bar # resolves name clash with local variable
+      #   end
+      #
+      # * Calling an attribute writer to prevent an local variable assignment
+      #
+      #   attr_writer :bar
+      #
+      #   def foo
+      #     self.bar= 1 # Make sure above attr writer is called
+      #   end
+      #
+      # Special cases:
+      #
+      # We allow uses of `self` with operators because it would be awkward
+      # otherwise.
+      class RedundantSelf < Cop
+        MSG = 'Redundant `self` detected.'.freeze
+
+        def initialize(config = nil, options = nil)
+          super
+          @allowed_send_nodes = []
+          @local_variables_scopes = Hash.new { |hash, key| hash[key] = [] }
+        end
+
+        # Assignment of self.x
+
+        def on_or_asgn(node)
+          lhs, _rhs = *node
+          allow_self(lhs)
+        end
+
+        alias on_and_asgn on_or_asgn
+
+        def on_op_asgn(node)
+          lhs, _op, _rhs = *node
+          allow_self(lhs)
+        end
+
+        # Using self.x to distinguish from local variable x
+
+        def on_def(node)
+          add_scope(node)
+        end
+
+        alias on_defs on_def
+
+        def on_args(node)
+          node.children.each { |arg| on_argument(arg) }
+        end
+
+        def on_blockarg(node)
+          on_argument(node)
+        end
+
+        def on_lvasgn(node)
+          lhs, rhs = *node
+          @local_variables_scopes[rhs] << lhs
+        end
+
+        def on_send(node)
+          return unless node.self_receiver? && regular_method_call?(node)
+          return if node.parent && node.parent.mlhs_type?
+
+          return if @allowed_send_nodes.include?(node) ||
+                    @local_variables_scopes[node].include?(node.method_name)
+
+          add_offense(node, :expression)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.remove(node.receiver.source_range)
+            corrector.remove(node.loc.dot)
+          end
+        end
+
+        private
+
+        def add_scope(node)
+          local_variables = []
+          node.descendants.each do |child_node|
+            @local_variables_scopes[child_node] = local_variables
+          end
+        end
+
+        def regular_method_call?(node)
+          !(operator?(node.method_name) ||
+            keyword?(node.method_name) ||
+            node.camel_case_method? ||
+            node.setter_method? ||
+            node.implicit_call?)
+        end
+
+        def on_argument(node)
+          name, = *node
+          @local_variables_scopes[node] << name
+        end
+
+        def keyword?(method_name)
+          %i[alias and begin break case class def defined? do
+             else elsif end ensure false for if in module
+             next nil not or redo rescue retry return self
+             super then true undef unless until when while
+             yield].include?(method_name)
+        end
+
+        def allow_self(node)
+          return unless node.send_type? && node.self_receiver?
+
+          @allowed_send_nodes << node
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/style/regexp_literal.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop enforces using // or %r around regular expressions.
+      #
+      # @example
+      #   # Good if EnforcedStyle is slashes or mixed, bad if percent_r.
+      #   snake_case = /^[\dA-Z_]+$/
+      #
+      #   # Good if EnforcedStyle is percent_r, bad if slashes or mixed.
+      #   snake_case = %r{^[\dA-Z_]+$}
+      #
+      #   # Good if EnforcedStyle is slashes, bad if percent_r or mixed.
+      #   regex = /
+      #     foo
+      #     (bar)
+      #     (baz)
+      #   /x
+      #
+      #   # Good if EnforcedStyle is percent_r or mixed, bad if slashes.
+      #   regex = %r{
+      #     foo
+      #     (bar)
+      #     (baz)
+      #   }x
+      #
+      #   # Bad unless AllowInnerSlashes is true.
+      #   x =~ /home\//
+      class RegexpLiteral < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG_USE_SLASHES = 'Use `//` around regular expression.'.freeze
+        MSG_USE_PERCENT_R = 'Use `%r` around regular expression.'.freeze
+
+        def on_regexp(node)
+          if slash_literal?(node)
+            check_slash_literal(node)
+          else
+            check_percent_r_literal(node)
+          end
+        end
+
+        private
+
+        def check_slash_literal(node)
+          return if allowed_slash_literal?(node)
+
+          add_offense(node, :expression, MSG_USE_PERCENT_R)
+        end
+
+        def check_percent_r_literal(node)
+          return if allowed_percent_r_literal?(node)
+
+          add_offense(node, :expression, MSG_USE_SLASHES)
+        end
+
+        def allowed_slash_literal?(node)
+          style == :slashes && !contains_disallowed_slash?(node) ||
+            style == :mixed && node.single_line? &&
+              !contains_disallowed_slash?(node)
+        end
+
+        def allowed_percent_r_literal?(node)
+          style == :slashes && contains_disallowed_slash?(node) ||
+            style == :percent_r ||
+            style == :mixed && node.multiline? ||
+            style == :mixed && contains_disallowed_slash?(node)
+        end
+
+        def contains_disallowed_slash?(node)
+          !allow_inner_slashes? && contains_slash?(node)
+        end
+
+        def contains_slash?(node)
+          node_body(node).include?('/')
+        end
+
+        def allow_inner_slashes?
+          cop_config['AllowInnerSlashes']
+        end
+
+        def node_body(node)
+          node.each_child_node(:str).map(&:source).join
+        end
+
+        def slash_literal?(node)
+          node.loc.begin.source == '/'
+        end
+
+        def preferred_delimiters
+          config.for_cop('Style/PercentLiteralDelimiters') \
+            ['PreferredDelimiters']['%r'].split(//)
+        end
+
+        def autocorrect(node)
+          return if contains_slash?(node)
+
+          replacement = if slash_literal?(node)
+                          ['%r', ''].zip(preferred_delimiters).map(&:join)
+                        else
+                          %w[/ /]
+                        end
+
+          lambda do |corrector|
+            corrector.replace(node.loc.begin, replacement.first)
+            corrector.replace(node.loc.end, replacement.last)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/style/rescue_modifier.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop checks for uses of rescue in its modifier form.
+      class RescueModifier < Cop
+        include AutocorrectAlignment
+        include RescueNode
+
+        MSG = 'Avoid using `rescue` in its modifier form.'.freeze
+
+        def on_resbody(node)
+          return unless rescue_modifier?(node)
+          add_offense(node.parent, :expression)
+        end
+
+        def autocorrect(node)
+          operation, rescue_modifier, = *node
+          *_, rescue_args = *rescue_modifier
+
+          indent = indentation(node)
+          correction =
+            "begin\n" \
+            "#{operation.source.gsub(/^/, indent)}" \
+            "\n#{offset(node)}rescue\n" \
+            "#{rescue_args.source.gsub(/^/, indent)}" \
+            "\n#{offset(node)}end"
+
+          lambda do |corrector|
+            corrector.replace(node.source_range, correction)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/style/safe_navigation.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop transforms usages of a method call safeguarded by a non `nil`
+      # check for the variable whose method is being called to
+      # safe navigation (`&.`).
+      #
+      # Configuration option: ConvertCodeThatCanStartToReturnNil
+      # The default for this is `false`. When configured to `true`, this will
+      # check for code in the format `!foo.nil? && foo.bar`. As it is written,
+      # the return of this code is limited to `false` and whatever the return
+      # of the method is. If this is converted to safe navigation,
+      # `foo&.bar` can start returning `nil` as well as what the method
+      # returns.
+      #
+      # @example
+      #   # bad
+      #   foo.bar if foo
+      #   foo.bar(param1, param2) if foo
+      #   foo.bar { |e| e.something } if foo
+      #   foo.bar(param) { |e| e.something } if foo
+      #
+      #   foo.bar if !foo.nil?
+      #   foo.bar unless !foo
+      #   foo.bar unless foo.nil?
+      #
+      #   foo && foo.bar
+      #   foo && foo.bar(param1, param2)
+      #   foo && foo.bar { |e| e.something }
+      #   foo && foo.bar(param) { |e| e.something }
+      #
+      #   # good
+      #   foo&.bar
+      #   foo&.bar(param1, param2)
+      #   foo&.bar { |e| e.something }
+      #   foo&.bar(param) { |e| e.something }
+      #
+      #   foo.nil? || foo.bar
+      #   !foo || foo.bar
+      #
+      #   # Methods that `nil` will `respond_to?` should not be converted to
+      #   # use safe navigation
+      #   foo.to_i if foo
+      class SafeNavigation < Cop
+        extend TargetRubyVersion
+
+        MSG = 'Use safe navigation (`&.`) instead of checking if an object ' \
+              'exists before calling the method.'.freeze
+        NIL_METHODS = nil.methods.freeze
+
+        minimum_target_ruby_version 2.3
+
+        def_node_matcher :safe_navigation_candidate, <<-PATTERN
+          {
+            (if
+              {(send (send $_ :nil?) :!) $_}
+              {(send $_ $_ ...) (block (send $_ $_ ...) ...)}
+            ...)
+            (if
+              (send $_ {:nil? :!}) nil
+              {(send $_ $_ ...) (block (send $_ $_ ...) ...)}
+            ...)
+          }
+        PATTERN
+
+        def_node_matcher :candidate_that_may_introduce_nil, <<-PATTERN
+          (and
+            {(send (send $_ :nil?) :!) $_}
+            {(send $_ $_ ...) (block (send $_ $_ ...) ...)}
+          ...)
+        PATTERN
+
+        def on_if(node)
+          return if node.ternary?
+
+          check_node(node)
+        end
+
+        def on_and(node)
+          check_node(node)
+        end
+
+        def on_or(node)
+          check_node(node)
+        end
+
+        def check_node(node)
+          return if target_ruby_version < 2.3
+          return if allowed_if_condition?(node)
+          checked_variable, receiver, method = extract_parts(node)
+          return unless receiver == checked_variable
+          return if NIL_METHODS.include?(method)
+          return unless method =~ /\w+[=!?]?/
+
+          add_offense(node, :expression)
+        end
+
+        def allowed_if_condition?(node)
+          node.if_type? && (node.else? || node.elsif?)
+        end
+
+        def extract_parts(node)
+          if cop_config['ConvertCodeThatCanStartToReturnNil']
+            safe_navigation_candidate(node) ||
+              candidate_that_may_introduce_nil(node)
+          else
+            safe_navigation_candidate(node)
+          end
+        end
+
+        def autocorrect(node)
+          if node.if_type?
+            _check, body, = *node.node_parts
+          else
+            _check, body = *node
+          end
+
+          method_call, = *body if body.block_type?
+
+          lambda do |corrector|
+            corrector.remove(begin_range(node, body))
+            corrector.remove(end_range(node, body))
+            corrector.insert_before((method_call || body).loc.dot, '&')
+          end
+        end
+
+        private
+
+        def begin_range(node, method_call)
+          Parser::Source::Range.new(node.loc.expression.source_buffer,
+                                    node.loc.expression.begin_pos,
+                                    method_call.loc.expression.begin_pos)
+        end
+
+        def end_range(node, method_call)
+          Parser::Source::Range.new(node.loc.expression,
+                                    method_call.loc.expression.end_pos,
+                                    node.loc.expression.end_pos)
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/style/self_assignment.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop enforces the use the shorthand for self-assignment.
+      #
+      # @example
+      #
+      #   # bad
+      #   x = x + 1
+      #
+      #   # good
+      #   x += 1
+      class SelfAssignment < Cop
+        MSG = 'Use self-assignment shorthand `%s=`.'.freeze
+        OPS = %i[+ - * ** / | &].freeze
+
+        def on_lvasgn(node)
+          check(node, :lvar)
+        end
+
+        def on_ivasgn(node)
+          check(node, :ivar)
+        end
+
+        def on_cvasgn(node)
+          check(node, :cvar)
+        end
+
+        private
+
+        def check(node, var_type)
+          var_name, rhs = *node
+          return unless rhs
+
+          if rhs.send_type?
+            check_send_node(node, rhs, var_name, var_type)
+          elsif %i[and or].include?(rhs.type)
+            check_boolean_node(node, rhs, var_name, var_type)
+          end
+        end
+
+        def check_send_node(node, rhs, var_name, var_type)
+          receiver, method_name, *_args = *rhs
+          return unless OPS.include?(method_name)
+
+          target_node = s(var_type, var_name)
+          return unless receiver == target_node
+
+          add_offense(node, :expression, format(MSG, method_name))
+        end
+
+        def check_boolean_node(node, rhs, var_name, var_type)
+          first_operand, _second_operand = *rhs
+
+          target_node = s(var_type, var_name)
+          return unless first_operand == target_node
+
+          operator = rhs.loc.operator.source
+          add_offense(node, :expression, format(MSG, operator))
+        end
+
+        def autocorrect(node)
+          _var_name, rhs = *node
+
+          if rhs.send_type?
+            autocorrect_send_node(node, rhs)
+          elsif %i[and or].include?(rhs.type)
+            autocorrect_boolean_node(node, rhs)
+          end
+        end
+
+        def autocorrect_send_node(node, rhs)
+          _receiver, method_name, args = *rhs
+          apply_autocorrect(node, rhs, method_name.to_s, args)
+        end
+
+        def autocorrect_boolean_node(node, rhs)
+          _first_operand, second_operand = *rhs
+          apply_autocorrect(node, rhs, rhs.loc.operator.source, second_operand)
+        end
+
+        def apply_autocorrect(node, rhs, operator, new_rhs)
+          lambda do |corrector|
+            corrector.insert_before(node.loc.operator, operator)
+            corrector.replace(rhs.source_range, new_rhs.source)
+          end
+        end
+      end
+    end
+  end
+end