rubocop 0.75.1

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

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # If the `else` branch of a conditional consists solely of an `if` node,
+      # it can be combined with the `else` to become an `elsif`.
+      # This helps to keep the nesting level from getting too deep.
+      #
+      # @example
+      #   # bad
+      #   if condition_a
+      #     action_a
+      #   else
+      #     if condition_b
+      #       action_b
+      #     else
+      #       action_c
+      #     end
+      #   end
+      #
+      #   # good
+      #   if condition_a
+      #     action_a
+      #   elsif condition_b
+      #     action_b
+      #   else
+      #     action_c
+      #   end
+      #
+      # @example AllowIfModifier: false (default)
+      #   # bad
+      #   if condition_a
+      #     action_a
+      #   else
+      #     action_b if condition_b
+      #   end
+      #
+      #   # good
+      #   if condition_a
+      #     action_a
+      #   elsif condition_b
+      #     action_b
+      #   end
+      #
+      # @example AllowIfModifier: true
+      #   # good
+      #   if condition_a
+      #     action_a
+      #   else
+      #     action_b if condition_b
+      #   end
+      #
+      #   # good
+      #   if condition_a
+      #     action_a
+      #   elsif condition_b
+      #     action_b
+      #   end
+      #
+      class IfInsideElse < Cop
+        MSG = 'Convert `if` nested inside `else` to `elsif`.'
+
+        def on_if(node)
+          return if node.ternary? || node.unless?
+
+          else_branch = node.else_branch
+
+          return unless else_branch&.if_type? && else_branch&.if?
+          return if allow_if_modifier_in_else_branch?(else_branch)
+
+          add_offense(else_branch, location: :keyword)
+        end
+
+        private
+
+        def allow_if_modifier_in_else_branch?(else_branch)
+          allow_if_modifier? && else_branch&.modifier_form?
+        end
+
+        def allow_if_modifier?
+          cop_config['AllowIfModifier']
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for `if` and `unless` statements that would fit on one line if
+      # written as modifier `if`/`unless`. The cop also checks for modifier
+      # `if`/`unless` lines that exceed the maximum line length.
+      #
+      # The maximum line length is configured in the `Metrics/LineLength`
+      # cop. The tab size is configured in the `IndentationWidth` of the
+      # `Layout/Tab` cop.
+      #
+      # @example
+      #   # bad
+      #   if condition
+      #     do_stuff(bar)
+      #   end
+      #
+      #   unless qux.empty?
+      #     Foo.do_something
+      #   end
+      #
+      #   do_something_in_a_method_with_a_long_name(arg) if long_condition
+      #
+      #   # good
+      #   do_stuff(bar) if condition
+      #   Foo.do_something unless qux.empty?
+      #
+      #   if long_condition
+      #     do_something_in_a_method_with_a_long_name(arg)
+      #   end
+      class IfUnlessModifier < Cop
+        include StatementModifier
+
+        MSG_USE_MODIFIER = 'Favor modifier `%<keyword>s` usage when having a ' \
+                           'single-line body. Another good alternative is ' \
+                           'the usage of control flow `&&`/`||`.'
+        MSG_USE_NORMAL =
+          'Modifier form of `%<keyword>s` makes the line too long.'
+
+        ASSIGNMENT_TYPES = %i[lvasgn casgn cvasgn
+                              gvasgn ivasgn masgn].freeze
+
+        def on_if(node)
+          msg = if eligible_node?(node)
+                  MSG_USE_MODIFIER unless named_capture_in_condition?(node)
+                elsif node.modifier_form? && too_long_single_line?(node)
+                  MSG_USE_NORMAL
+                end
+          return unless msg
+
+          add_offense(node,
+                      location: :keyword,
+                      message: format(msg, keyword: node.keyword))
+        end
+
+        def autocorrect(node)
+          replacement = if node.modifier_form?
+                          to_normal_form(node)
+                        else
+                          to_modifier_form(node)
+                        end
+          ->(corrector) { corrector.replace(node.source_range, replacement) }
+        end
+
+        private
+
+        def too_long_single_line?(node)
+          return false unless max_line_length
+
+          range = node.source_range
+          range.first_line == range.last_line &&
+            range.last_column > max_line_length
+        end
+
+        def named_capture_in_condition?(node)
+          node.condition.match_with_lvasgn_type?
+        end
+
+        def eligible_node?(node)
+          !non_eligible_if?(node) && !node.chained? &&
+            !node.nested_conditional? && single_line_as_modifier?(node)
+        end
+
+        def non_eligible_if?(node)
+          node.ternary? || node.modifier_form? || node.elsif? || node.else?
+        end
+
+        def parenthesize?(node)
+          # Parenthesize corrected expression if changing to modifier-if form
+          # would change the meaning of the parent expression
+          # (due to the low operator precedence of modifier-if)
+          return false if node.parent.nil?
+          return true if ASSIGNMENT_TYPES.include?(node.parent.type)
+
+          node.parent.send_type? && !node.parent.parenthesized?
+        end
+
+        def to_modifier_form(node)
+          expression = [node.body.source,
+                        node.keyword,
+                        node.condition.source,
+                        first_line_comment(node)].compact.join(' ')
+
+          parenthesize?(node) ? "(#{expression})" : expression
+        end
+
+        def to_normal_form(node)
+          indentation = ' ' * node.source_range.column
+          <<~RUBY.chomp
+            #{node.keyword} #{node.condition.source}
+            #{indentation}  #{node.body.source}
+            #{indentation}end
+          RUBY
+        end
+
+        def first_line_comment(node)
+          comment =
+            processed_source.find_comment { |c| c.loc.line == node.loc.line }
+
+          comment ? comment.loc.expression.source : nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for if and unless statements used as modifiers of other if or
+      # unless statements.
+      #
+      # @example
+      #
+      #  # bad
+      #  tired? ? 'stop' : 'go faster' if running?
+      #
+      #  # bad
+      #  if tired?
+      #    "please stop"
+      #  else
+      #    "keep going"
+      #  end if running?
+      #
+      #  # good
+      #  if running?
+      #    tired? ? 'stop' : 'go faster'
+      #  end
+      class IfUnlessModifierOfIfUnless < Cop
+        include StatementModifier
+
+        MSG = 'Avoid modifier `%<keyword>s` after another conditional.'
+
+        def on_if(node)
+          return unless node.modifier_form? && node.body.if_type?
+
+          add_offense(node, location: :keyword,
+                            message: format(MSG, keyword: node.keyword))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for uses of semicolon in if statements.
+      #
+      # @example
+      #
+      #   # bad
+      #   result = if some_condition; something else another_thing end
+      #
+      #   # good
+      #   result = some_condition ? something : another_thing
+      #
+      class IfWithSemicolon < Cop
+        include OnNormalIfUnless
+
+        MSG = 'Do not use if x; Use the ternary operator instead.'
+
+        def on_normal_if_unless(node)
+          beginning = node.loc.begin
+          return unless beginning&.is?(';')
+
+          add_offense(node)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for `raise` or `fail` statements which do not specify an
+      # explicit exception class. (This raises a `RuntimeError`. Some projects
+      # might prefer to use exception classes which more precisely identify the
+      # nature of the error.)
+      #
+      # @example
+      #   # bad
+      #   raise 'Error message here'
+      #
+      #   # good
+      #   raise ArgumentError, 'Error message here'
+      class ImplicitRuntimeError < Cop
+        MSG = 'Use `%<method>s` with an explicit exception class and message,' \
+              ' rather than just a message.'
+
+        def_node_matcher :implicit_runtime_error_raise_or_fail,
+                         '(send nil? ${:raise :fail} {str dstr})'
+
+        def on_send(node)
+          implicit_runtime_error_raise_or_fail(node) do |method|
+            add_offense(node, message: format(MSG, method: method))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Use `Kernel#loop` for infinite loops.
+      #
+      # @example
+      #   # bad
+      #   while true
+      #     work
+      #   end
+      #
+      #   # good
+      #   loop do
+      #     work
+      #   end
+      class InfiniteLoop < Cop
+        LEADING_SPACE = /\A(\s*)/.freeze
+
+        MSG = 'Use `Kernel#loop` for infinite loops.'
+
+        def join_force?(force_class)
+          force_class == VariableForce
+        end
+
+        def after_leaving_scope(scope, _variable_table)
+          @variables ||= []
+          @variables.concat(scope.variables.values)
+        end
+
+        def on_while(node)
+          while_or_until(node) if node.condition.truthy_literal?
+        end
+
+        def on_until(node)
+          while_or_until(node) if node.condition.falsey_literal?
+        end
+
+        alias on_while_post on_while
+        alias on_until_post on_until
+
+        def autocorrect(node)
+          if node.while_post_type? || node.until_post_type?
+            replace_begin_end_with_modifier(node)
+          elsif node.modifier_form?
+            replace_source(node.source_range, modifier_replacement(node))
+          else
+            replace_source(non_modifier_range(node), 'loop do')
+          end
+        end
+
+        private
+
+        def while_or_until(node)
+          range = node.source_range
+          # Not every `while true` and `until false` can be turned into a
+          # `loop do` without further modification. The reason is that a
+          # variable that's introduced inside a while/until loop is in scope
+          # outside of that loop too, but a variable that's assigned for the
+          # first time inside a block can not be accessed after the block. In
+          # those more complicated cases we don't report an offense.
+          return if @variables.any? do |var|
+            assigned_inside_loop?(var, range) &&
+            !assigned_before_loop?(var, range) &&
+            referenced_after_loop?(var, range)
+          end
+
+          add_offense(node, location: :keyword)
+        end
+
+        def assigned_inside_loop?(var, range)
+          var.assignments.any? { |a| range.contains?(a.node.source_range) }
+        end
+
+        def assigned_before_loop?(var, range)
+          b = range.begin_pos
+          var.assignments.any? { |a| a.node.source_range.end_pos < b }
+        end
+
+        def referenced_after_loop?(var, range)
+          e = range.end_pos
+          var.references.any? { |r| r.node.source_range.begin_pos > e }
+        end
+
+        def replace_begin_end_with_modifier(node)
+          lambda do |corrector|
+            corrector.replace(node.body.loc.begin, 'loop do')
+            corrector.remove(node.body.loc.end.end.join(node.source_range.end))
+          end
+        end
+
+        def replace_source(range, replacement)
+          lambda do |corrector|
+            corrector.replace(range, replacement)
+          end
+        end
+
+        def modifier_replacement(node)
+          if node.single_line?
+            'loop { ' + node.body.source + ' }'
+          else
+            indentation = node.body.loc.expression.source_line[LEADING_SPACE]
+
+            ['loop do', node.body.source.gsub(/^/, configured_indent),
+             'end'].join("\n#{indentation}")
+          end
+        end
+
+        def non_modifier_range(node)
+          start_range = node.loc.keyword.begin
+          end_range = if node.do?
+                        node.loc.begin.end
+                      else
+                        node.condition.source_range.end
+                      end
+
+          start_range.join(end_range)
+        end
+
+        def configured_indent
+          ' ' * config.for_cop('Layout/IndentationWidth')['Width']
+        end
+      end
+    end
+  end
+end