rubocop 0.87.1

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for method signatures that span multiple lines.
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def foo(bar, baz)
+      #   end
+      #
+      #   # bad
+      #
+      #   def foo(bar,
+      #           baz)
+      #   end
+      #
+      class MultilineMethodSignature < Cop
+        MSG = 'Avoid multi-line method signatures.'
+
+        def on_def(node)
+          return unless node.arguments?
+          return if opening_line(node) == closing_line(node)
+          return if correction_exceeds_max_line_length?(node)
+
+          add_offense(node)
+        end
+        alias on_defs on_def
+
+        private
+
+        def opening_line(node)
+          node.first_line
+        end
+
+        def closing_line(node)
+          node.arguments.last_line
+        end
+
+        def correction_exceeds_max_line_length?(node)
+          indentation_width(node) + definition_width(node) > max_line_length
+        end
+
+        def indentation_width(node)
+          processed_source.line_indentation(node.loc.expression.line)
+        end
+
+        def definition_width(node)
+          node.source_range.begin.join(node.arguments.source_range.end).length
+        end
+
+        def max_line_length
+          config.for_cop('Layout/LineLength')['Max'] || 80
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for multi-line ternary op expressions.
+      #
+      # @example
+      #   # bad
+      #   a = cond ?
+      #     b : c
+      #   a = cond ? b :
+      #       c
+      #   a = cond ?
+      #       b :
+      #       c
+      #
+      #   # good
+      #   a = cond ? b : c
+      #   a = if cond
+      #     b
+      #   else
+      #     c
+      #   end
+      class MultilineTernaryOperator < Cop
+        MSG = 'Avoid multi-line ternary operators, ' \
+              'use `if` or `unless` instead.'
+
+        def on_if(node)
+          return unless node.ternary? && node.multiline?
+
+          add_offense(node)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node, <<~RUBY.chop)
+              if #{node.condition.source}
+                #{node.if_branch.source}
+              else
+                #{node.else_branch.source}
+              end
+            RUBY
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks uses of the `then` keyword
+      # in multi-line when statements.
+      #
+      # @example
+      #   # bad
+      #   case foo
+      #   when bar then
+      #   end
+      #
+      #   # good
+      #   case foo
+      #   when bar
+      #   end
+      #
+      #   # good
+      #   case foo
+      #   when bar then do_something
+      #   end
+      #
+      #   # good
+      #   case foo
+      #   when bar then do_something(arg1,
+      #                              arg2)
+      #   end
+      #
+      class MultilineWhenThen < Cop
+        include RangeHelp
+
+        MSG = 'Do not use `then` for multiline `when` statement.'
+
+        def on_when(node)
+          # Without `then`, there's no offense
+          return unless node.then?
+
+          # Single line usage of `then` is not an offense
+          return if !node.children.last.nil? && !node.multiline?
+
+          # Requires `then` for write `when` and its body on the same line.
+          return if require_then?(node)
+
+          # With more than one statements after then, there's not offense
+          return if accept_node_type?(node.body)
+
+          add_offense(node, location: :begin)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.remove(
+              range_with_surrounding_space(
+                range: node.loc.begin, side: :left, newlines: false
+              )
+            )
+          end
+        end
+
+        def require_then?(when_node)
+          return false unless when_node.body
+
+          when_node.loc.line == when_node.body.loc.line
+        end
+
+        def accept_node_type?(node)
+          node&.begin_type? || node&.array_type? || node&.hash_type?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks against comparing a variable with multiple items, where
+      # `Array#include?` could be used instead to avoid code repetition.
+      #
+      # @example
+      #   # bad
+      #   a = 'a'
+      #   foo if a == 'a' || a == 'b' || a == 'c'
+      #
+      #   # good
+      #   a = 'a'
+      #   foo if ['a', 'b', 'c'].include?(a)
+      class MultipleComparison < Cop
+        MSG = 'Avoid comparing a variable with multiple items ' \
+          'in a conditional, use `Array#include?` instead.'
+
+        def on_or(node)
+          root_of_or_node = root_of_or_node(node)
+
+          return unless node == root_of_or_node
+          return unless nested_variable_comparison?(root_of_or_node)
+
+          add_offense(node)
+        end
+
+        private
+
+        def_node_matcher :simple_double_comparison?, '(send $lvar :== $lvar)'
+        def_node_matcher :simple_comparison?, <<~PATTERN
+          {(send $lvar :== _)
+           (send _ :== $lvar)}
+        PATTERN
+
+        def nested_variable_comparison?(node)
+          return false unless nested_comparison?(node)
+
+          variables_in_node(node).count == 1
+        end
+
+        def variables_in_node(node)
+          if node.or_type?
+            node.node_parts
+                .flat_map { |node_part| variables_in_node(node_part) }
+                .uniq
+          else
+            variables_in_simple_node(node)
+          end
+        end
+
+        def variables_in_simple_node(node)
+          simple_double_comparison?(node) do |var1, var2|
+            return [variable_name(var1), variable_name(var2)]
+          end
+          simple_comparison?(node) do |var|
+            return [variable_name(var)]
+          end
+          []
+        end
+
+        def variable_name(node)
+          node.children[0]
+        end
+
+        def nested_comparison?(node)
+          if node.or_type?
+            node.node_parts.all? { |node_part| comparison? node_part }
+          else
+            false
+          end
+        end
+
+        def comparison?(node)
+          simple_comparison?(node) || nested_comparison?(node)
+        end
+
+        def root_of_or_node(or_node)
+          return or_node unless or_node.parent
+
+          if or_node.parent.or_type?
+            root_of_or_node(or_node.parent)
+          else
+            or_node
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks whether some constant value isn't a
+      # mutable literal (e.g. array or hash).
+      #
+      # Strict mode can be used to freeze all constants, rather than
+      # just literals.
+      # Strict mode is considered an experimental feature. It has not been
+      # updated with an exhaustive list of all methods that will produce
+      # frozen objects so there is a decent chance of getting some false
+      # positives. Luckily, there is no harm in freezing an already
+      # frozen object.
+      #
+      # @example EnforcedStyle: literals (default)
+      #   # bad
+      #   CONST = [1, 2, 3]
+      #
+      #   # good
+      #   CONST = [1, 2, 3].freeze
+      #
+      #   # good
+      #   CONST = <<~TESTING.freeze
+      #     This is a heredoc
+      #   TESTING
+      #
+      #   # good
+      #   CONST = Something.new
+      #
+      #
+      # @example EnforcedStyle: strict
+      #   # bad
+      #   CONST = Something.new
+      #
+      #   # bad
+      #   CONST = Struct.new do
+      #     def foo
+      #       puts 1
+      #     end
+      #   end
+      #
+      #   # good
+      #   CONST = Something.new.freeze
+      #
+      #   # good
+      #   CONST = Struct.new do
+      #     def foo
+      #       puts 1
+      #     end
+      #   end.freeze
+      class MutableConstant < Cop
+        include FrozenStringLiteral
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Freeze mutable objects assigned to constants.'
+
+        def on_casgn(node)
+          _scope, _const_name, value = *node
+          on_assignment(value)
+        end
+
+        def on_or_asgn(node)
+          lhs, value = *node
+
+          return unless lhs&.casgn_type?
+
+          on_assignment(value)
+        end
+
+        def autocorrect(node)
+          expr = node.source_range
+
+          lambda do |corrector|
+            splat_value = splat_value(node)
+            if splat_value
+              correct_splat_expansion(corrector, expr, splat_value)
+            elsif node.array_type? && !node.bracketed?
+              corrector.wrap(expr, '[', ']')
+            elsif requires_parentheses?(node)
+              corrector.wrap(expr, '(', ')')
+            end
+
+            corrector.insert_after(expr, '.freeze')
+          end
+        end
+
+        private
+
+        def on_assignment(value)
+          if style == :strict
+            strict_check(value)
+          else
+            check(value)
+          end
+        end
+
+        def strict_check(value)
+          return if immutable_literal?(value)
+          return if operation_produces_immutable_object?(value)
+          return if frozen_string_literal?(value)
+
+          add_offense(value)
+        end
+
+        def check(value)
+          range_enclosed_in_parentheses = range_enclosed_in_parentheses?(value)
+
+          return unless mutable_literal?(value) ||
+                        range_enclosed_in_parentheses
+          return if FROZEN_STRING_LITERAL_TYPES.include?(value.type) &&
+                    frozen_string_literals_enabled?
+
+          add_offense(value)
+        end
+
+        def mutable_literal?(value)
+          value&.mutable_literal?
+        end
+
+        def immutable_literal?(node)
+          node.nil? || node.immutable_literal?
+        end
+
+        def frozen_string_literal?(node)
+          FROZEN_STRING_LITERAL_TYPES.include?(node.type) &&
+            frozen_string_literals_enabled?
+        end
+
+        def requires_parentheses?(node)
+          node.range_type? ||
+            (node.send_type? && node.loc.dot.nil?)
+        end
+
+        def correct_splat_expansion(corrector, expr, splat_value)
+          if range_enclosed_in_parentheses?(splat_value)
+            corrector.replace(expr, "#{splat_value.source}.to_a")
+          else
+            corrector.replace(expr, "(#{splat_value.source}).to_a")
+          end
+        end
+
+        def_node_matcher :splat_value, <<~PATTERN
+          (array (splat $_))
+        PATTERN
+
+        # Some of these patterns may not actually return an immutable object,
+        # but we want to consider them immutable for this cop.
+        def_node_matcher :operation_produces_immutable_object?, <<~PATTERN
+          {
+            (const _ _)
+            (send (const {nil? cbase} :Struct) :new ...)
+            (block (send (const {nil? cbase} :Struct) :new ...) ...)
+            (send _ :freeze)
+            (send {float int} {:+ :- :* :** :/ :% :<<} _)
+            (send _ {:+ :- :* :** :/ :%} {float int})
+            (send _ {:== :=== :!= :<= :>= :< :>} _)
+            (send (const {nil? cbase} :ENV) :[] _)
+            (or (send (const {nil? cbase} :ENV) :[] _) _)
+            (send _ {:count :length :size} ...)
+            (block (send _ {:count :length :size} ...) ...)
+          }
+        PATTERN
+
+        def_node_matcher :range_enclosed_in_parentheses?, <<~PATTERN
+          (begin ({irange erange} _ _))
+        PATTERN
+      end
+    end
+  end
+end