rubocop 0.87.1

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for usage of the %W() syntax when %w() would do.
+      #
+      # @example
+      #   # bad
+      #   %W(cat dog pig)
+      #   %W[door wall floor]
+      #
+      #   # good
+      #   %w/swim run bike/
+      #   %w[shirt pants shoes]
+      #   %W(apple #{fruit} grape)
+      class RedundantCapitalW < Cop
+        include PercentLiteral
+
+        MSG = 'Do not use `%W` unless interpolation is needed. ' \
+              'If not, use `%w`.'
+
+        def on_array(node)
+          process(node, '%W')
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            src = node.loc.begin.source
+            corrector.replace(node.loc.begin, src.tr('W', 'w'))
+          end
+        end
+
+        private
+
+        def on_percent_literal(node)
+          return if requires_interpolation?(node)
+
+          add_offense(node)
+        end
+
+        def requires_interpolation?(node)
+          node.child_nodes.any? do |string|
+            string.dstr_type? ||
+              double_quotes_required?(string.source)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for unnecessary conditional expressions.
+      #
+      # @example
+      #   # bad
+      #   a = b ? b : c
+      #
+      #   # good
+      #   a = b || c
+      #
+      # @example
+      #   # bad
+      #   if b
+      #     b
+      #   else
+      #     c
+      #   end
+      #
+      #   # good
+      #   b || c
+      #
+      #   # good
+      #   if b
+      #     b
+      #   elsif cond
+      #     c
+      #   end
+      #
+      class RedundantCondition < Cop
+        include RangeHelp
+
+        MSG = 'Use double pipes `||` instead.'
+        REDUNDANT_CONDITION = 'This condition is not needed.'
+
+        def on_if(node)
+          return if node.elsif_conditional?
+          return unless offense?(node)
+
+          add_offense(node, location: range_of_offense(node))
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            if node.ternary?
+              correct_ternary(corrector, node)
+            elsif node.modifier_form? || !node.else_branch
+              corrector.replace(node, node.if_branch.source)
+            else
+              corrected = make_ternary_form(node)
+
+              corrector.replace(node, corrected)
+            end
+          end
+        end
+
+        private
+
+        def message(node)
+          if node.modifier_form? || !node.else_branch
+            REDUNDANT_CONDITION
+          else
+            MSG
+          end
+        end
+
+        def range_of_offense(node)
+          return :expression unless node.ternary?
+
+          range_between(node.loc.question.begin_pos, node.loc.colon.end_pos)
+        end
+
+        def offense?(node)
+          condition, if_branch, else_branch = *node
+
+          return false if use_if_branch?(else_branch)
+
+          condition == if_branch && !node.elsif? && (
+            node.ternary? ||
+            !else_branch.instance_of?(AST::Node) ||
+            else_branch.single_line?
+          )
+        end
+
+        def use_if_branch?(else_branch)
+          else_branch&.if_type?
+        end
+
+        def else_source(else_branch)
+          if else_branch.basic_conditional? &&
+             else_branch.modifier_form? ||
+             else_branch.range_type?
+            "(#{else_branch.source})"
+          else
+            else_branch.source
+          end
+        end
+
+        def make_ternary_form(node)
+          _condition, if_branch, else_branch = *node
+          ternary_form = [if_branch.source,
+                          else_source(else_branch)].join(' || ')
+
+          if node.parent&.send_type?
+            "(#{ternary_form})"
+          else
+            ternary_form
+          end
+        end
+
+        def correct_ternary(corrector, node)
+          corrector.replace(range_of_offense(node), '||')
+
+          return unless node.else_branch.range_type?
+
+          corrector.wrap(node.else_branch, '(', ')')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for redundant returning of true/false in conditionals.
+      #
+      # @example
+      #   # bad
+      #   x == y ? true : false
+      #
+      #   # bad
+      #   if x == y
+      #     true
+      #   else
+      #     false
+      #   end
+      #
+      #   # good
+      #   x == y
+      #
+      #   # bad
+      #   x == y ? false : true
+      #
+      #   # good
+      #   x != y
+      class RedundantConditional < Cop
+        include Alignment
+
+        operators = RuboCop::AST::Node::COMPARISON_OPERATORS.to_a
+        COMPARISON_OPERATOR_MATCHER = "{:#{operators.join(' :')}}"
+
+        MSG = 'This conditional expression can just be replaced ' \
+              'by `%<msg>s`.'
+
+        def on_if(node)
+          return unless offense?(node)
+
+          add_offense(node)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node, replacement_condition(node))
+          end
+        end
+
+        private
+
+        def message(node)
+          replacement = replacement_condition(node)
+          msg = node.elsif? ? "\n#{replacement}" : replacement
+
+          format(MSG, msg: msg)
+        end
+
+        def_node_matcher :redundant_condition?, <<~RUBY
+          (if (send _ #{COMPARISON_OPERATOR_MATCHER} _) true false)
+        RUBY
+
+        def_node_matcher :redundant_condition_inverted?, <<~RUBY
+          (if (send _ #{COMPARISON_OPERATOR_MATCHER} _) false true)
+        RUBY
+
+        def offense?(node)
+          return if node.modifier_form?
+
+          redundant_condition?(node) || redundant_condition_inverted?(node)
+        end
+
+        def replacement_condition(node)
+          condition = node.condition.source
+          expression = invert_expression?(node) ? "!(#{condition})" : condition
+
+          node.elsif? ? indented_else_node(expression, node) : expression
+        end
+
+        def invert_expression?(node)
+          (
+            (node.if? || node.elsif? || node.ternary?) &&
+            redundant_condition_inverted?(node)
+          ) || (
+            node.unless? &&
+            redundant_condition?(node)
+          )
+        end
+
+        def indented_else_node(expression, node)
+          "else\n#{indentation(node)}#{expression}"
+        end
+
+        def configured_indentation_width
+          super || 2
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module RuboCop
+  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 < Base
+        extend AutoCorrector
+
+        MSG_1 = 'Redundant `RuntimeError` argument can be removed.'
+        MSG_2 = 'Redundant `RuntimeError.new` call can be replaced with ' \
+                'just the message.'
+
+        # Switch `raise RuntimeError, 'message'` to `raise 'message'`, and
+        # `raise RuntimeError.new('message')` to `raise 'message'`.
+        def on_send(node)
+          fix_exploded(node) || fix_compact(node)
+        end
+
+        def fix_exploded(node)
+          exploded?(node) do |command, message|
+            add_offense(node, message: MSG_1) do |corrector|
+              if node.parenthesized?
+                corrector.replace(node,
+                                  "#{command}(#{message.source})")
+              else
+                corrector.replace(node,
+                                  "#{command} #{message.source}")
+              end
+            end
+          end
+        end
+
+        def fix_compact(node)
+          compact?(node) do |new_call, message|
+            add_offense(node, message: MSG_2) do |corrector|
+              corrector.replace(new_call, message.source)
+            end
+          end
+        end
+
+        def_node_matcher :exploded?, <<~PATTERN
+          (send nil? ${:raise :fail} (const {nil? cbase} :RuntimeError) $_)
+        PATTERN
+
+        def_node_matcher :compact?, <<~PATTERN
+          (send nil? {:raise :fail} $(send (const {nil? cbase} :RuntimeError) :new $_))
+        PATTERN
+      end
+    end
+  end
+end

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

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop identifies places where `fetch(key) { value }`
+      # can be replaced by `fetch(key, value)`.
+      #
+      # In such cases `fetch(key, value)` method is faster
+      # than `fetch(key) { value }`.
+      #
+      # @example SafeForConstants: false (default)
+      #   # bad
+      #   hash.fetch(:key) { 5 }
+      #   hash.fetch(:key) { true }
+      #   hash.fetch(:key) { nil }
+      #   array.fetch(5) { :value }
+      #   ENV.fetch(:key) { 'value' }
+      #
+      #   # good
+      #   hash.fetch(:key, 5)
+      #   hash.fetch(:key, true)
+      #   hash.fetch(:key, nil)
+      #   array.fetch(5, :value)
+      #   ENV.fetch(:key, 'value')
+      #
+      # @example SafeForConstants: true
+      #   # bad
+      #   ENV.fetch(:key) { VALUE }
+      #
+      #   # good
+      #   ENV.fetch(:key, VALUE)
+      #
+      class RedundantFetchBlock < Cop
+        include FrozenStringLiteral
+        include RangeHelp
+
+        MSG = 'Use `%<good>s` instead of `%<bad>s`.'
+
+        def_node_matcher :redundant_fetch_block_candidate?, <<~PATTERN
+          (block
+            $(send _ :fetch _)
+            (args)
+            ${nil? #basic_literal? #const_type?})
+        PATTERN
+
+        def on_block(node)
+          redundant_fetch_block_candidate?(node) do |send, body|
+            return if should_not_check?(send, body)
+
+            range = fetch_range(send, node)
+            good = build_good_method(send, body)
+            bad = build_bad_method(send, body)
+
+            add_offense(
+              node,
+              location: range,
+              message: format(MSG, good: good, bad: bad)
+            )
+          end
+        end
+
+        def autocorrect(node)
+          redundant_fetch_block_candidate?(node) do |send, body|
+            lambda do |corrector|
+              receiver, _, key = send.children
+              default_value = body ? body.source : 'nil'
+
+              corrector.replace(node, "#{receiver.source}.fetch(#{key.source}, #{default_value})")
+            end
+          end
+        end
+
+        private
+
+        def basic_literal?(node)
+          node&.basic_literal?
+        end
+
+        def const_type?(node)
+          node&.const_type?
+        end
+
+        def should_not_check?(send, body)
+          (body&.const_type? && !check_for_constant?) ||
+            (body&.str_type? && !check_for_string?) ||
+            rails_cache?(send.receiver)
+        end
+
+        def_node_matcher :rails_cache?, <<~PATTERN
+          (send (const _ :Rails) :cache)
+        PATTERN
+
+        def fetch_range(send, node)
+          range_between(send.loc.selector.begin_pos, node.loc.end.end_pos)
+        end
+
+        def build_good_method(send, body)
+          key = send.children[2].source
+          default_value = body ? body.source : 'nil'
+
+          "fetch(#{key}, #{default_value})"
+        end
+
+        def build_bad_method(send, body)
+          key = send.children[2].source
+          block = body ? "{ #{body.source} }" : '{}'
+
+          "fetch(#{key}) #{block}"
+        end
+
+        def check_for_constant?
+          cop_config['SafeForConstants']
+        end
+
+        def check_for_string?
+          frozen_string_literals_enabled?
+        end
+      end
+    end
+  end
+end