rubbycop 0.49.0

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop checks for redundant `begin` blocks.
+      #
+      # Currently it checks for code like this:
+      #
+      # @example
+      #
+      #   def redundant
+      #     begin
+      #       ala
+      #       bala
+      #     rescue StandardError => e
+      #       something
+      #     end
+      #   end
+      #
+      #   def preferred
+      #     ala
+      #     bala
+      #   rescue StandardError => e
+      #     something
+      #   end
+      class RedundantBegin < Cop
+        include OnMethodDef
+
+        MSG = 'Redundant `begin` block detected.'.freeze
+
+        def on_method_def(_node, _method_name, _args, body)
+          return unless body && body.kwbegin_type?
+
+          add_offense(body, :begin)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.remove(node.loc.begin)
+            corrector.remove(node.loc.end)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop checks for RuntimeError as the argument of raise/fail.
+      #
+      # It checks for code like this:
+      #
+      # @example
+      #   # Bad
+      #   raise RuntimeError, 'message'
+      #
+      #   # Bad
+      #   raise RuntimeError.new('message')
+      #
+      #   # Good
+      #   raise 'message'
+      class RedundantException < Cop
+        MSG_1 = 'Redundant `RuntimeError` argument can be removed.'.freeze
+        MSG_2 = 'Redundant `RuntimeError.new` call can be replaced with ' \
+                'just the message.'.freeze
+
+        def on_send(node)
+          exploded?(node) { return add_offense(node, :expression, MSG_1) }
+          compact?(node) { add_offense(node, :expression, MSG_2) }
+        end
+
+        # Switch `raise RuntimeError, 'message'` to `raise 'message'`, and
+        # `raise RuntimeError.new('message')` to `raise 'message'`.
+        def autocorrect(node)
+          exploded?(node) do |command, message|
+            return lambda do |corrector|
+              corrector.replace(node.source_range,
+                                "#{command} #{message.source}")
+            end
+          end
+          compact?(node) do |new_call, message|
+            lambda do |corrector|
+              corrector.replace(new_call.source_range, message.source)
+            end
+          end
+        end
+
+        def_node_matcher :exploded?, <<-PATTERN
+          (send nil ${:raise :fail} (const nil :RuntimeError) $_)
+        PATTERN
+
+        def_node_matcher :compact?, <<-PATTERN
+          (send nil {:raise :fail} $(send (const nil :RuntimeError) :new $_))
+        PATTERN
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop check for uses of Object#freeze on immutable objects.
+      #
+      # @example
+      #   # bad
+      #   CONST = 1.freeze
+      #
+      #   # good
+      #   CONST = 1
+      class RedundantFreeze < Cop
+        include FrozenStringLiteral
+
+        MSG = 'Do not freeze immutable objects, as freezing them has no ' \
+              'effect.'.freeze
+
+        def on_send(node)
+          return unless node.receiver && node.method?(:freeze) &&
+                        immutable_literal?(node.receiver)
+
+          add_offense(node, :expression)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.remove(node.loc.dot)
+            corrector.remove(node.loc.selector)
+          end
+        end
+
+        private
+
+        def immutable_literal?(node)
+          return true if node.immutable_literal?
+
+          FROZEN_STRING_LITERAL_TYPES.include?(node.type) &&
+            frozen_string_literals_enabled?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop checks for redundant parentheses.
+      #
+      # @example
+      #
+      #   # bad
+      #   (x) if ((y.z).nil?)
+      #
+      #   # good
+      #   x if y.z.nil?
+      #
+      class RedundantParentheses < Cop
+        include Parentheses
+
+        ALLOWED_LITERALS = %i[irange erange].freeze
+
+        def_node_matcher :square_brackets?,
+                         '(send {(send _recv _msg) str array hash} :[] ...)'
+        def_node_matcher :range_end?, '^^{irange erange}'
+        def_node_matcher :method_node_and_args, '$(send _recv _msg $...)'
+        def_node_matcher :rescue?, '{^resbody ^^resbody}'
+        def_node_matcher :arg_in_call_with_block?,
+                         '^^(block (send _ _ equal?(%0) ...) ...)'
+
+        def on_begin(node)
+          return if !parentheses?(node) || parens_allowed?(node)
+          check(node)
+        end
+
+        def parens_allowed?(node)
+          empty_parentheses?(node) ||
+            allowed_ancestor?(node) ||
+            hash_literal_as_first_arg?(node) ||
+            rescue?(node) ||
+            allowed_method_call?(node) ||
+            allowed_array_or_hash_element?(node) ||
+            allowed_multiple_expression?(node)
+        end
+
+        def allowed_ancestor?(node)
+          # Don't flag `break(1)`, etc
+          keyword_ancestor?(node) && parens_required?(node)
+        end
+
+        def allowed_method_call?(node)
+          # Don't flag `method (arg) { }`
+          arg_in_call_with_block?(node) && !parentheses?(node.parent)
+        end
+
+        def allowed_multiple_expression?(node)
+          return false if node.children.size == 1
+          ancestor = node.ancestors.first
+          return false unless ancestor
+          !ancestor.begin_type? && !ancestor.def_type? && !ancestor.block_type?
+        end
+
+        def empty_parentheses?(node)
+          # Don't flag `()`
+          node.children.empty?
+        end
+
+        def hash_literal_as_first_arg?(node)
+          # Don't flag `method ({key: value})`
+          node.children.first.hash_type? && first_arg?(node) &&
+            !parentheses?(node.parent)
+        end
+
+        def check(begin_node)
+          node = begin_node.children.first
+          if keyword_with_redundant_parentheses?(node)
+            return offense(begin_node, 'a keyword')
+          end
+          if disallowed_literal?(begin_node, node)
+            return offense(begin_node, 'a literal')
+          end
+          return offense(begin_node, 'a variable') if node.variable?
+          return offense(begin_node, 'a constant') if node.const_type?
+          check_send(begin_node, node) if node.send_type?
+        end
+
+        def check_send(begin_node, node)
+          return check_unary(begin_node, node) if node.unary_operation?
+
+          return unless method_call_with_redundant_parentheses?(node)
+          return if call_chain_starts_with_int?(begin_node, node)
+
+          offense(begin_node, 'a method call')
+        end
+
+        def check_unary(begin_node, node)
+          return if begin_node.chained?
+
+          # parens are not redundant in `(!recv.method arg)`
+          node = node.children.first while node.unary_operation?
+          if node.send_type?
+            return unless method_call_with_redundant_parentheses?(node)
+          end
+
+          offense(begin_node, 'an unary operation')
+        end
+
+        def offense(node, msg)
+          add_offense(node, :expression, "Don't use parentheses around #{msg}.")
+        end
+
+        def keyword_ancestor?(node)
+          node.parent && node.parent.keyword?
+        end
+
+        def allowed_array_or_hash_element?(node)
+          # Don't flag
+          # ```
+          # { a: (1
+          #      ), }
+          # ```
+          (hash_element?(node) || array_element?(node)) &&
+            only_closing_paren_before_comma?(node)
+        end
+
+        def hash_element?(node)
+          node.parent && node.parent.pair_type?
+        end
+
+        def array_element?(node)
+          node.parent && node.parent.array_type?
+        end
+
+        def only_closing_paren_before_comma?(node)
+          source_buffer = node.source_range.source_buffer
+          line_range = source_buffer.line_range(node.loc.end.line)
+
+          line_range.source =~ /^\s*\)\s*,/
+        end
+
+        def disallowed_literal?(begin_node, node)
+          node.literal? &&
+            !ALLOWED_LITERALS.include?(node.type) &&
+            !raised_to_power_negative_numeric?(begin_node, node)
+        end
+
+        def raised_to_power_negative_numeric?(begin_node, node)
+          return false unless node.numeric_type?
+
+          siblings = begin_node.parent && begin_node.parent.children
+          return false if siblings.nil?
+          next_sibling = siblings[begin_node.sibling_index + 1]
+          base_value = node.children.first
+
+          base_value < 0 && next_sibling == :**
+        end
+
+        def keyword_with_redundant_parentheses?(node)
+          return false unless node.keyword?
+          return true if node.special_keyword?
+
+          args = *node
+
+          if only_begin_arg?(args)
+            parentheses?(args.first)
+          else
+            args.empty? || parentheses?(node)
+          end
+        end
+
+        def method_call_with_redundant_parentheses?(node)
+          return false unless node.send_type?
+          return false if node.keyword_not?
+          return false if range_end?(node)
+
+          send_node, args = method_node_and_args(node)
+
+          args.empty? || parentheses?(send_node) || square_brackets?(send_node)
+        end
+
+        def only_begin_arg?(args)
+          args.size == 1 && args.first && args.first.begin_type?
+        end
+
+        def first_arg?(node)
+          send_node = node.parent
+          return false unless send_node && send_node.send_type?
+
+          _receiver, _method_name, *args = *send_node
+          node.equal?(args.first)
+        end
+
+        def call_chain_starts_with_int?(begin_node, send_node)
+          recv = first_part_of_call_chain(send_node)
+          recv && recv.int_type? && (parent = begin_node.parent) &&
+            parent.send_type? && (parent.method?(:-@) || parent.method?(:+@))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop checks for redundant `return` expressions.
+      #
+      # @example
+      #
+      #   def test
+      #     return something
+      #   end
+      #
+      #   def test
+      #     one
+      #     two
+      #     three
+      #     return something
+      #   end
+      #
+      # It should be extended to handle methods whose body is if/else
+      # or a case expression with a default branch.
+      class RedundantReturn < Cop
+        include OnMethodDef
+
+        MSG = 'Redundant `return` detected.'.freeze
+
+        private
+
+        def autocorrect(node)
+          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(node.loc.keyword, :right)
+            corrector.remove(return_kw)
+          end
+        end
+
+        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
+
+        def on_method_def(_node, _method_name, _args, body)
+          return unless body
+
+          check_branch(body)
+        end
+
+        def check_branch(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 :begin then check_begin_node(node)
+          end
+        end
+
+        def check_return_node(node)
+          return if cop_config['AllowMultipleReturnValues'] &&
+                    node.children.size > 1
+
+          add_offense(node, :keyword)
+        end
+
+        def check_case_node(node)
+          _cond, *when_nodes, else_node = *node
+          when_nodes.each { |when_node| check_when_node(when_node) }
+          check_branch(else_node) if else_node
+        end
+
+        def check_when_node(node)
+          return unless node
+          _cond, body = *node
+          check_branch(body) if body
+        end
+
+        def check_if_node(node)
+          return if node.modifier_form? || node.ternary?
+
+          _cond, if_node, else_node = *node.node_parts
+
+          check_branch(if_node) if if_node
+          check_branch(else_node) if else_node
+        end
+
+        def check_begin_node(node)
+          expressions = *node
+          last_expr = expressions.last
+
+          return unless last_expr && last_expr.return_type?
+
+          check_return_node(last_expr)
+        end
+      end
+    end
+  end
+end