rubbycop 0.49.0

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

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop checks for identical lines at the beginning or end of
+      # each branch of a conditional statement.
+      #
+      # @example
+      #   @bad
+      #   if condition
+      #     do_x
+      #     do_z
+      #   else
+      #     do_y
+      #     do_z
+      #   end
+      #
+      #   @good
+      #   if condition
+      #     do_x
+      #   else
+      #     do_y
+      #   end
+      #   do_z
+      #
+      #   @bad
+      #   if condition
+      #     do_z
+      #     do_x
+      #   else
+      #     do_z
+      #     do_y
+      #   end
+      #
+      #   @good
+      #   do_z
+      #   if condition
+      #     do_x
+      #   else
+      #     do_y
+      #   end
+      #
+      #   @bad
+      #   case foo
+      #   when 1
+      #     do_x
+      #   when 2
+      #     do_x
+      #   else
+      #     do_x
+      #   end
+      #
+      #   @good
+      #   case foo
+      #   when 1
+      #     do_x
+      #     do_y
+      #   when 2
+      #     # nothing
+      #   else
+      #     do_x
+      #     do_z
+      #   end
+      class IdenticalConditionalBranches < Cop
+        MSG = 'Move `%s` out of the conditional.'.freeze
+
+        def on_if(node)
+          return if node.elsif?
+
+          branches = expand_elses(node.else_branch).unshift(node.if_branch)
+
+          # return if any branch is empty. An empty branch can be an `if`
+          # without an `else`, or a branch that contains only comments.
+          return if branches.any?(&:nil?)
+
+          check_branches(branches)
+        end
+
+        def on_case(node)
+          return unless node.else? && node.else_branch
+
+          branches = node.when_branches.map(&:body).push(node.else_branch)
+
+          return if branches.any?(&:nil?)
+
+          check_branches(branches)
+        end
+
+        private
+
+        def check_branches(branches)
+          tails = branches.compact.map { |branch| tail(branch) }
+          check_expressions(tails)
+          heads = branches.compact.map { |branch| head(branch) }
+          check_expressions(heads)
+        end
+
+        def check_expressions(expressions)
+          return unless expressions.size > 1 && expressions.uniq.one?
+
+          expressions.each do |expression|
+            add_offense(expression, :expression, format(MSG, expression.source))
+          end
+        end
+
+        # `elsif` branches show up in the if node as nested `else` branches. We
+        # need to recursively iterate over all `else` branches.
+        def expand_elses(branch)
+          if branch.nil?
+            [nil]
+          elsif branch.if_type?
+            _condition, elsif_branch, else_branch = *branch
+            expand_elses(else_branch).unshift(elsif_branch)
+          else
+            [branch]
+          end
+        end
+
+        def tail(node)
+          node.begin_type? ? node.children.last : node
+        end
+
+        def head(node)
+          node.begin_type? ? node.children.first : node
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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
+      #   @good
+      #   if condition_a
+      #     action_a
+      #   elsif condition_b
+      #     action_b
+      #   else
+      #     action_c
+      #   end
+      #
+      #   @bad
+      #   if condition_a
+      #     action_a
+      #   else
+      #     if condition_b
+      #       action_b
+      #     else
+      #       action_c
+      #     end
+      #   end
+      class IfInsideElse < Cop
+        MSG = 'Convert `if` nested inside `else` to `elsif`.'.freeze
+
+        def on_if(node)
+          return if node.ternary? || node.unless?
+
+          else_branch = node.else_branch
+
+          return unless else_branch && else_branch.if_type? && else_branch.if?
+
+          add_offense(else_branch, :keyword)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # Checks for if and unless statements that would fit on one line
+      # if written as a modifier if/unless.
+      # The maximum line length is configurable.
+      class IfUnlessModifier < Cop
+        include StatementModifier
+
+        MSG = 'Favor modifier `%s` usage when having a single-line body. ' \
+              'Another good alternative is the usage of control flow ' \
+              '`&&`/`||`.'.freeze
+
+        ASSIGNMENT_TYPES = %i[lvasgn casgn cvasgn
+                              gvasgn ivasgn masgn].freeze
+
+        def on_if(node)
+          return unless eligible_node?(node)
+
+          add_offense(node, :keyword, format(MSG, node.keyword))
+        end
+
+        private
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.source_range, to_modifier_form(node))
+          end
+        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)
+
+          if node.parent.send_type?
+            _receiver, _name, *args = *node.parent
+            return !method_uses_parens?(node.parent, args.first)
+          end
+
+          false
+        end
+
+        def method_uses_parens?(node, limit)
+          source = node.source_range.source_line[0...limit.loc.column]
+          source =~ /\s*\(\s*$/
+        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 first_line_comment(node)
+          comment =
+            processed_source.comments.find { |c| c.loc.line == node.loc.line }
+
+          comment ? comment.loc.expression.source : nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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 `%s` after another conditional.'.freeze
+
+        def on_if(node)
+          return unless node.modifier_form? && node.body.if_type?
+
+          add_offense(node, :keyword, format(MSG, node.keyword))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # Checks for uses of semicolon in if statements.
+      class IfWithSemicolon < Cop
+        include OnNormalIfUnless
+
+        MSG = 'Do not use if x; Use the ternary operator instead.'.freeze
+
+        def on_normal_if_unless(node)
+          beginning = node.loc.begin
+          return unless beginning && beginning.is?(';')
+          add_offense(node, :expression, MSG)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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
+        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, :expression, "Use `#{method}` with an explicit " \
+                                           'exception class and message, ' \
+                                           'rather than just a message.')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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*)/
+
+        MSG = 'Use `Kernel#loop` for infinite loops.'.freeze
+
+        def on_while(node)
+          return unless node.condition.truthy_literal?
+
+          add_offense(node, :keyword)
+        end
+
+        def on_until(node)
+          return unless node.condition.falsey_literal?
+
+          add_offense(node, :keyword)
+        end
+
+        alias on_while_post on_while
+        alias on_until_post on_until
+
+        private
+
+        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
+
+        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('IndentationWidth')['Width']
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop checks for trailing inline comments.
+      #
+      # @example
+      #
+      #   # good
+      #   foo.each do |f|
+      #     # Standalone comment
+      #     f.bar
+      #   end
+      #
+      #   # bad
+      #   foo.each do |f|
+      #     f.bar # Trailing inline comment
+      #   end
+      class InlineComment < Cop
+        MSG = 'Avoid trailing inline comments.'.freeze
+
+        def investigate(processed_source)
+          processed_source.comments.each do |comment|
+            next if comment_line?(processed_source[comment.loc.line - 1])
+            add_offense(comment, :expression)
+          end
+        end
+      end
+    end
+  end
+end