rubocop 0.75.1

data/lib/rubocop/cop/style/redundant_return.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for redundant `return` expressions.
+      #
+      # @example
+      #   # These bad cases should be extended to handle methods whose body is
+      #   # if/else or a case expression with a default branch.
+      #
+      #   # bad
+      #   def test
+      #     return something
+      #   end
+      #
+      #   # bad
+      #   def test
+      #     one
+      #     two
+      #     three
+      #     return something
+      #   end
+      #
+      #   # good
+      #   def test
+      #     return something if something_else
+      #   end
+      #
+      #   # good
+      #   def test
+      #     if x
+      #     elsif y
+      #     else
+      #     end
+      #   end
+      #
+      # @example AllowMultipleReturnValues: false (default)
+      #   # bad
+      #   def test
+      #     return x, y
+      #   end
+      #
+      # @example AllowMultipleReturnValues: true
+      #   # good
+      #   def test
+      #     return x, y
+      #   end
+      #
+      class RedundantReturn < Cop
+        include RangeHelp
+
+        MSG = 'Redundant `return` detected.'
+        MULTI_RETURN_MSG = 'To return multiple values, use an array.'
+
+        def on_def(node)
+          return unless node.body
+
+          check_branch(node.body)
+        end
+        alias on_defs on_def
+
+        def autocorrect(node) # rubocop:disable Metrics/MethodLength
+          lambda do |corrector|
+            unless arguments?(node.children)
+              corrector.replace(node.source_range, 'nil')
+              next
+            end
+
+            return_value, = *node
+            if node.children.size > 1
+              add_brackets(corrector, node)
+            elsif return_value.hash_type?
+              add_braces(corrector, return_value) unless return_value.braces?
+            end
+            return_kw = range_with_surrounding_space(range: node.loc.keyword,
+                                                     side: :right)
+            corrector.remove(return_kw)
+          end
+        end
+
+        private
+
+        def add_brackets(corrector, node)
+          kids = node.children.map(&:source_range)
+          corrector.insert_before(kids.first, '[')
+          corrector.insert_after(kids.last, ']')
+        end
+
+        def add_braces(corrector, node)
+          kids = node.children.map(&:source_range)
+          corrector.insert_before(kids.first, '{')
+          corrector.insert_after(kids.last, '}')
+        end
+
+        def arguments?(args)
+          return false if args.empty?
+          return true if args.size > 1
+
+          !args.first.begin_type? || !args.first.children.empty?
+        end
+
+        # rubocop:disable Metrics/CyclomaticComplexity
+        def check_branch(node)
+          return unless node
+
+          case node.type
+          when :return then check_return_node(node)
+          when :case   then check_case_node(node)
+          when :if     then check_if_node(node)
+          when :rescue, :resbody
+            check_rescue_node(node)
+          when :ensure then check_ensure_node(node)
+          when :begin, :kwbegin
+            check_begin_node(node)
+          end
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity
+
+        def check_return_node(node)
+          return if cop_config['AllowMultipleReturnValues'] &&
+                    node.children.size > 1
+
+          add_offense(node, location: :keyword)
+        end
+
+        def check_case_node(node)
+          node.when_branches.each { |when_node| check_branch(when_node.body) }
+          check_branch(node.else_branch)
+        end
+
+        def check_if_node(node)
+          return if node.modifier_form? || node.ternary?
+
+          check_branch(node.if_branch)
+          check_branch(node.else_branch)
+        end
+
+        def check_rescue_node(node)
+          node.child_nodes.each do |child_node|
+            check_branch(child_node)
+          end
+        end
+
+        def check_ensure_node(node)
+          rescue_node = node.node_parts[0]
+          check_branch(rescue_node)
+        end
+
+        def check_begin_node(node)
+          expressions = *node
+          last_expr = expressions.last
+
+          return unless last_expr&.return_type?
+
+          check_return_node(last_expr)
+        end
+
+        def allow_multiple_return_values?
+          cop_config['AllowMultipleReturnValues'] || false
+        end
+
+        def message(node)
+          if !allow_multiple_return_values? && node.children.size > 1
+            "#{MSG} #{MULTI_RETURN_MSG}"
+          else
+            MSG
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for redundant uses of `self`.
+      #
+      # The usage of `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.
+      #
+      # * Calling an attribute writer to prevent an local variable assignment.
+      #
+      # Note, with using explicit self you can only send messages with public or
+      # protected scope, you cannot send private messages this way.
+      #
+      # Note we allow uses of `self` with operators because it would be awkward
+      # otherwise.
+      #
+      # @example
+      #
+      #   # bad
+      #   def foo(bar)
+      #     self.baz
+      #   end
+      #
+      #   # good
+      #   def foo(bar)
+      #     self.bar  # Resolves name clash with the argument.
+      #   end
+      #
+      #   def foo
+      #     bar = 1
+      #     self.bar  # Resolves name clash with the local variable.
+      #   end
+      #
+      #   def foo
+      #     %w[x y z].select do |bar|
+      #       self.bar == bar  # Resolves name clash with argument of the block.
+      #     end
+      #   end
+      class RedundantSelf < Cop
+        MSG = 'Redundant `self` detected.'
+        KERNEL_METHODS = Kernel.methods(false)
+
+        def self.autocorrect_incompatible_with
+          [ColonMethodCall]
+        end
+
+        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_masgn(node)
+          lhs, rhs = *node
+          lhs.children.each do |child|
+            add_lhs_to_local_variables_scopes(rhs, child.to_a.first)
+          end
+        end
+
+        def on_lvasgn(node)
+          lhs, rhs = *node
+          add_lhs_to_local_variables_scopes(rhs, lhs)
+        end
+
+        def on_send(node)
+          return unless node.self_receiver? && regular_method_call?(node)
+          return if node.parent&.mlhs_type?
+
+          return if allowed_send_node?(node)
+
+          add_offense(node)
+        end
+
+        def on_block(node)
+          add_scope(node, @local_variables_scopes[node])
+        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 allowed_send_node?(node)
+          @allowed_send_nodes.include?(node) ||
+            @local_variables_scopes[node].include?(node.method_name) ||
+            KERNEL_METHODS.include?(node.method_name)
+        end
+
+        def regular_method_call?(node)
+          !(node.operator_method? ||
+            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 __FILE__ __LINE__ __ENCODING__].include?(method_name)
+        end
+
+        def allow_self(node)
+          return unless node.send_type? && node.self_receiver?
+
+          @allowed_send_nodes << node
+        end
+
+        def add_lhs_to_local_variables_scopes(rhs, lhs)
+          if rhs&.send_type? && !rhs.arguments.empty?
+            rhs.arguments.each do |argument|
+              @local_variables_scopes[argument] << lhs
+            end
+          else
+            @local_variables_scopes[rhs] << lhs
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/redundant_sort_by.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop identifies places where `sort_by { ... }` can be replaced by
+      # `sort`.
+      #
+      # @example
+      #   # bad
+      #   array.sort_by { |x| x }
+      #   array.sort_by do |var|
+      #     var
+      #   end
+      #
+      #   # good
+      #   array.sort
+      class RedundantSortBy < Cop
+        include RangeHelp
+
+        MSG = 'Use `sort` instead of `sort_by { |%<var>s| %<var>s }`.'
+
+        def_node_matcher :redundant_sort_by, <<~PATTERN
+          (block $(send _ :sort_by) (args (arg $_x)) (lvar _x))
+        PATTERN
+
+        def on_block(node)
+          redundant_sort_by(node) do |send, var_name|
+            range = sort_by_range(send, node)
+
+            add_offense(node,
+                        location: range,
+                        message: format(MSG, var: var_name))
+          end
+        end
+
+        def autocorrect(node)
+          send = node.send_node
+          ->(corrector) { corrector.replace(sort_by_range(send, node), 'sort') }
+        end
+
+        private
+
+        def sort_by_range(send, node)
+          range_between(send.loc.selector.begin_pos, node.loc.end.end_pos)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop enforces using // or %r around regular expressions.
+      #
+      # @example EnforcedStyle: slashes (default)
+      #   # bad
+      #   snake_case = %r{^[\dA-Z_]+$}
+      #
+      #   # bad
+      #   regex = %r{
+      #     foo
+      #     (bar)
+      #     (baz)
+      #   }x
+      #
+      #   # good
+      #   snake_case = /^[\dA-Z_]+$/
+      #
+      #   # good
+      #   regex = /
+      #     foo
+      #     (bar)
+      #     (baz)
+      #   /x
+      #
+      # @example EnforcedStyle: percent_r
+      #   # bad
+      #   snake_case = /^[\dA-Z_]+$/
+      #
+      #   # bad
+      #   regex = /
+      #     foo
+      #     (bar)
+      #     (baz)
+      #   /x
+      #
+      #   # good
+      #   snake_case = %r{^[\dA-Z_]+$}
+      #
+      #   # good
+      #   regex = %r{
+      #     foo
+      #     (bar)
+      #     (baz)
+      #   }x
+      #
+      # @example EnforcedStyle: mixed
+      #   # bad
+      #   snake_case = %r{^[\dA-Z_]+$}
+      #
+      #   # bad
+      #   regex = /
+      #     foo
+      #     (bar)
+      #     (baz)
+      #   /x
+      #
+      #   # good
+      #   snake_case = /^[\dA-Z_]+$/
+      #
+      #   # good
+      #   regex = %r{
+      #     foo
+      #     (bar)
+      #     (baz)
+      #   }x
+      #
+      # @example AllowInnerSlashes: false (default)
+      #   # If `false`, the cop will always recommend using `%r` if one or more
+      #   # slashes are found in the regexp string.
+      #
+      #   # bad
+      #   x =~ /home\//
+      #
+      #   # good
+      #   x =~ %r{home/}
+      #
+      # @example AllowInnerSlashes: true
+      #   # good
+      #   x =~ /home\//
+      class RegexpLiteral < Cop
+        include ConfigurableEnforcedStyle
+        include RangeHelp
+
+        MSG_USE_SLASHES = 'Use `//` around regular expression.'
+        MSG_USE_PERCENT_R = 'Use `%r` around regular expression.'
+
+        def on_regexp(node)
+          if slash_literal?(node)
+            check_slash_literal(node)
+          else
+            check_percent_r_literal(node)
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            correct_delimiters(node, corrector)
+            correct_inner_slashes(node, corrector)
+          end
+        end
+
+        private
+
+        def check_slash_literal(node)
+          return if allowed_slash_literal?(node)
+
+          add_offense(node, message: MSG_USE_PERCENT_R)
+        end
+
+        def check_percent_r_literal(node)
+          return if allowed_percent_r_literal?(node)
+
+          add_offense(node, message: MSG_USE_SLASHES)
+        end
+
+        def allowed_slash_literal?(node)
+          style == :slashes && !contains_disallowed_slash?(node) ||
+            allowed_mixed_slash?(node)
+        end
+
+        def allowed_mixed_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 ||
+            allowed_mixed_percent_r?(node)
+        end
+
+        def allowed_mixed_percent_r?(node)
+          style == :mixed && node.multiline? ||
+            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, include_begin_nodes: false)
+          types = include_begin_nodes ? %i[str begin] : %i[str]
+          node.each_child_node(*types).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 correct_delimiters(node, corrector)
+          replacement = calculate_replacement(node)
+          corrector.replace(node.loc.begin, replacement.first)
+          corrector.replace(node.loc.end, replacement.last)
+        end
+
+        def correct_inner_slashes(node, corrector)
+          regexp_begin = node.loc.begin.end_pos
+
+          inner_slash_indices(node).each do |index|
+            start = regexp_begin + index
+
+            corrector.replace(
+              range_between(
+                start,
+                start + inner_slash_before_correction(node).length
+              ),
+              inner_slash_after_correction(node)
+            )
+          end
+        end
+
+        def inner_slash_indices(node)
+          text    = node_body(node, include_begin_nodes: true)
+          pattern = inner_slash_before_correction(node)
+          index   = -1
+          indices = []
+
+          while (index = text.index(pattern, index + 1))
+            indices << index
+          end
+
+          indices
+        end
+
+        def inner_slash_before_correction(node)
+          inner_slash_for(node.loc.begin.source)
+        end
+
+        def inner_slash_after_correction(node)
+          inner_slash_for(calculate_replacement(node).first)
+        end
+
+        def inner_slash_for(opening_delimiter)
+          if ['/', '%r/'].include?(opening_delimiter)
+            '\/'
+          else
+            '/'
+          end
+        end
+
+        def calculate_replacement(node)
+          if slash_literal?(node)
+            ['%r', ''].zip(preferred_delimiters).map(&:join)
+          else
+            %w[/ /]
+          end
+        end
+      end
+    end
+  end
+end