rubocop 0.75.1

data/lib/rubocop/cop/lint/empty_expression.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for the presence of empty expressions.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   foo = ()
+      #   if ()
+      #     bar
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   foo = (some_expression)
+      #   if (some_expression)
+      #     bar
+      #   end
+      class EmptyExpression < Cop
+        MSG = 'Avoid empty expressions.'
+
+        def on_begin(node)
+          return unless empty_expression?(node)
+
+          add_offense(node, location: node.source_range)
+        end
+
+        private
+
+        def empty_expression?(begin_node)
+          begin_node.children.empty?
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/empty_interpolation.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for empty interpolation.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   "result is #{}"
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   "result is #{some_result}"
+      class EmptyInterpolation < Cop
+        include Interpolation
+
+        MSG = 'Empty interpolation detected.'
+
+        def on_interpolation(begin_node)
+          add_offense(begin_node) if begin_node.children.empty?
+        end
+
+        def autocorrect(node)
+          lambda do |collector|
+            collector.remove(node.loc.expression)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/empty_when.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for the presence of `when` branches without a body.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   case foo
+      #   when bar then 1
+      #   when baz then # nothing
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   case foo
+      #   when bar then 1
+      #   when baz then 2
+      #   end
+      class EmptyWhen < Cop
+        MSG = 'Avoid `when` branches without a body.'
+
+        def on_case(node)
+          node.each_when do |when_node|
+            next if when_node.body
+
+            add_offense(when_node, location: when_node.source_range)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/end_in_method.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for END blocks in method definitions.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   def some_method
+      #     END { do_something }
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def some_method
+      #     at_exit { do_something }
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   # outside defs
+      #   END { do_something }
+      class EndInMethod < Cop
+        MSG = '`END` found in method definition. Use `at_exit` instead.'
+
+        def on_postexe(node)
+          inside_of_method = node.each_ancestor(:def, :defs).count.nonzero?
+          add_offense(node, location: :keyword) if inside_of_method
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/ensure_return.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for *return* from an *ensure* block.
+      # Explicit return from an ensure block alters the control flow
+      # as the return will take precedence over any exception being raised,
+      # and the exception will be silently thrown away as if it were rescued.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   begin
+      #     do_something
+      #   ensure
+      #     do_something_else
+      #     return
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   begin
+      #     do_something
+      #   ensure
+      #     do_something_else
+      #   end
+      class EnsureReturn < Cop
+        MSG = 'Do not return from an `ensure` block.'
+
+        def on_ensure(node)
+          ensure_body = node.body
+
+          return unless ensure_body
+
+          ensure_body.each_node(:return) do |return_node|
+            add_offense(return_node)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/erb_new_arguments.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      #
+      # This cop emulates the following Ruby warnings in Ruby 2.6.
+      #
+      # % cat example.rb
+      # ERB.new('hi', nil, '-', '@output_buffer')
+      # % ruby -rerb example.rb
+      # example.rb:1: warning: Passing safe_level with the 2nd argument of
+      # ERB.new is deprecated. Do not use it, and specify other arguments as
+      # keyword arguments.
+      # example.rb:1: warning: Passing trim_mode with the 3rd argument of
+      # ERB.new is deprecated. Use keyword argument like
+      # ERB.new(str, trim_mode:...) instead.
+      # example.rb:1: warning: Passing eoutvar with the 4th argument of ERB.new
+      # is deprecated. Use keyword argument like ERB.new(str, eoutvar: ...)
+      # instead.
+      #
+      # Now non-keyword arguments other than first one are softly deprecated
+      # and will be removed when Ruby 2.5 becomes EOL.
+      # `ERB.new` with non-keyword arguments is deprecated since ERB 2.2.0.
+      # Use `:trim_mode` and `:eoutvar` keyword arguments to `ERB.new`.
+      # This cop identifies places where `ERB.new(str, trim_mode, eoutvar)` can
+      # be replaced by `ERB.new(str, :trim_mode: trim_mode, eoutvar: eoutvar)`.
+      #
+      # @example
+      #   # Target codes supports Ruby 2.6 and higher only
+      #   # bad
+      #   ERB.new(str, nil, '-', '@output_buffer')
+      #
+      #   # good
+      #   ERB.new(str, trim_mode: '-', eoutvar: '@output_buffer')
+      #
+      #   # Target codes supports Ruby 2.5 and lower only
+      #   # good
+      #   ERB.new(str, nil, '-', '@output_buffer')
+      #
+      #   # Target codes supports Ruby 2.6, 2.5 and lower
+      #   # bad
+      #   ERB.new(str, nil, '-', '@output_buffer')
+      #
+      #   # good
+      #   # Ruby standard library style
+      #   # https://github.com/ruby/ruby/commit/3406c5d
+      #   if ERB.instance_method(:initialize).parameters.assoc(:key) # Ruby 2.6+
+      #     ERB.new(str, trim_mode: '-', eoutvar: '@output_buffer')
+      #   else
+      #     ERB.new(str, nil, '-', '@output_buffer')
+      #   end
+      #
+      #   # good
+      #   # Use `RUBY_VERSION` style
+      #   if RUBY_VERSION >= '2.6'
+      #     ERB.new(str, trim_mode: '-', eoutvar: '@output_buffer')
+      #   else
+      #     ERB.new(str, nil, '-', '@output_buffer')
+      #   end
+      #
+      class ErbNewArguments < Cop
+        extend TargetRubyVersion
+        include RangeHelp
+
+        minimum_target_ruby_version 2.6
+
+        MESSAGES = [
+          'Passing safe_level with the 2nd argument of `ERB.new` is ' \
+          'deprecated. Do not use it, and specify other arguments as ' \
+          'keyword arguments.',
+          'Passing trim_mode with the 3rd argument of `ERB.new` is ' \
+          'deprecated. Use keyword argument like ' \
+          '`ERB.new(str, trim_mode: %<arg_value>s)` instead.',
+          'Passing eoutvar with the 4th argument of `ERB.new` is ' \
+          'deprecated. Use keyword argument like ' \
+          '`ERB.new(str, eoutvar: %<arg_value>s)` instead.'
+        ].freeze
+
+        def_node_matcher :erb_new_with_non_keyword_arguments, <<~PATTERN
+          (send
+            (const {nil? cbase} :ERB) :new $...)
+        PATTERN
+
+        def on_send(node)
+          erb_new_with_non_keyword_arguments(node) do |arguments|
+            return if correct_arguments?(arguments)
+
+            1.upto(3) do |i|
+              next if !arguments[i] || arguments[i].hash_type?
+
+              message = format(MESSAGES[i - 1], arg_value: arguments[i].source)
+
+              add_offense(
+                node, location: arguments[i].source_range, message: message
+              )
+            end
+          end
+        end
+
+        def autocorrect(node)
+          str_arg = node.arguments[0].source
+
+          kwargs = build_kwargs(node)
+          overridden_kwargs = override_by_legacy_args(kwargs, node)
+
+          good_arguments = [
+            str_arg, overridden_kwargs
+          ].flatten.compact.join(', ')
+
+          lambda do |corrector|
+            corrector.replace(arguments_range(node), good_arguments)
+          end
+        end
+
+        private
+
+        def correct_arguments?(arguments)
+          arguments.size == 1 ||
+            arguments.size == 2 && arguments[1].hash_type?
+        end
+
+        def build_kwargs(node)
+          return [nil, nil] unless node.arguments.last.hash_type?
+
+          trim_mode_arg, eoutvar_arg = nil
+
+          node.arguments.last.pairs.each do |pair|
+            case pair.key.source
+            when 'trim_mode'
+              trim_mode_arg = "trim_mode: #{pair.value.source}"
+            when 'eoutvar'
+              eoutvar_arg = "eoutvar: #{pair.value.source}"
+            end
+          end
+
+          [trim_mode_arg, eoutvar_arg]
+        end
+
+        def override_by_legacy_args(kwargs, node)
+          overridden_kwargs = kwargs.dup
+
+          if node.arguments[2]
+            overridden_kwargs[0] = "trim_mode: #{node.arguments[2].source}"
+          end
+
+          if node.arguments[3] && !node.arguments[3].hash_type?
+            overridden_kwargs[1] = "eoutvar: #{node.arguments[3].source}"
+          end
+
+          overridden_kwargs
+        end
+
+        def arguments_range(node)
+          arguments = node.arguments
+
+          range_between(arguments.first.source_range.begin_pos,
+                        arguments.last.source_range.end_pos)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/flip_flop.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop looks for uses of flip-flop operator.
+      # flip-flop operator is deprecated since Ruby 2.6.0.
+      #
+      # @example
+      #   # bad
+      #   (1..20).each do |x|
+      #     puts x if (x == 5) .. (x == 10)
+      #   end
+      #
+      #   # good
+      #   (1..20).each do |x|
+      #     puts x if (x >= 5) && (x <= 10)
+      #   end
+      class FlipFlop < Cop
+        MSG = 'Avoid the use of flip-flop operators.'
+
+        def on_iflipflop(node)
+          add_offense(node)
+        end
+
+        def on_eflipflop(node)
+          add_offense(node)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/float_out_of_range.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop identifies Float literals which are, like, really really really
+      # really really really really really big. Too big. No-one needs Floats
+      # that big. If you need a float that big, something is wrong with you.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   float = 3.0e400
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   float = 42.9
+      class FloatOutOfRange < Cop
+        MSG = 'Float out of range.'
+
+        def on_float(node)
+          value, = *node
+
+          return unless value.infinite? ||
+                        value.zero? && node.source =~ /[1-9]/
+
+          add_offense(node)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/format_parameter_mismatch.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This lint sees if there is a mismatch between the number of
+      # expected fields for format/sprintf/#% and what is actually
+      # passed as arguments.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   format('A value: %s and another: %i', a_value)
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   format('A value: %s and another: %i', a_value, another)
+      class FormatParameterMismatch < Cop
+        # http://rubular.com/r/CvpbxkcTzy
+        MSG = "Number of arguments (%<arg_num>i) to `%<method>s` doesn't " \
+              'match the number of fields (%<field_num>i).'
+
+        KERNEL = 'Kernel'
+        SHOVEL = '<<'
+        STRING_TYPES = %i[str dstr].freeze
+
+        def on_send(node)
+          return unless offending_node?(node)
+
+          add_offense(node, location: :selector)
+        end
+
+        private
+
+        def offending_node?(node)
+          return false unless called_on_string?(node)
+          return false unless method_with_format_args?(node)
+          return false if splat_args?(node)
+
+          num_of_format_args, num_of_expected_fields = count_matches(node)
+
+          return false if num_of_format_args == :unknown
+
+          matched_arguments_count?(num_of_expected_fields, num_of_format_args)
+        end
+
+        def matched_arguments_count?(expected, passed)
+          if passed.negative?
+            expected < passed.abs
+          else
+            expected != passed
+          end
+        end
+
+        def_node_matcher :called_on_string?, <<~PATTERN
+          {(send {nil? const_type?} _ (str _) ...)
+           (send (str ...) ...)}
+        PATTERN
+
+        def method_with_format_args?(node)
+          sprintf?(node) || format?(node) || percent?(node)
+        end
+
+        def splat_args?(node)
+          return false if percent?(node)
+
+          node.arguments.drop(1).any?(&:splat_type?)
+        end
+
+        def heredoc?(node)
+          node.first_argument.source[0, 2] == SHOVEL
+        end
+
+        def count_matches(node)
+          if countable_format?(node)
+            count_format_matches(node)
+          elsif countable_percent?(node)
+            count_percent_matches(node)
+          else
+            [:unknown] * 2
+          end
+        end
+
+        def countable_format?(node)
+          (sprintf?(node) || format?(node)) && !heredoc?(node)
+        end
+
+        def countable_percent?(node)
+          percent?(node) && node.first_argument.array_type?
+        end
+
+        def count_format_matches(node)
+          [node.arguments.count - 1, expected_fields_count(node.first_argument)]
+        end
+
+        def count_percent_matches(node)
+          [node.first_argument.child_nodes.count,
+           expected_fields_count(node.receiver)]
+        end
+
+        def format_method?(name, node)
+          return false if node.const_receiver? &&
+                          !node.receiver.loc.name.is?(KERNEL)
+          return false unless node.method?(name)
+
+          node.arguments.size > 1 && node.first_argument.str_type?
+        end
+
+        def expected_fields_count(node)
+          return :unknown unless node.str_type?
+
+          format_string = RuboCop::Cop::Utils::FormatString.new(node.source)
+          return 1 if format_string.named_interpolation?
+
+          max_digit_dollar_num = format_string.max_digit_dollar_num
+          return max_digit_dollar_num if max_digit_dollar_num&.nonzero?
+
+          format_string
+            .format_sequences
+            .reject(&:percent?)
+            .reduce(0) { |acc, seq| acc + seq.arity }
+        end
+
+        def format?(node)
+          format_method?(:format, node)
+        end
+
+        def sprintf?(node)
+          format_method?(:sprintf, node)
+        end
+
+        def percent?(node)
+          receiver = node.receiver
+
+          percent = node.method?(:%) &&
+                    (STRING_TYPES.include?(receiver.type) ||
+                     node.first_argument.array_type?)
+
+          return false if percent && STRING_TYPES.include?(receiver.type) &&
+                          heredoc?(node)
+
+          percent
+        end
+
+        def message(node)
+          num_args_for_format, num_expected_fields = count_matches(node)
+
+          method_name = node.method?(:%) ? 'String#%' : node.method_name
+
+          format(MSG, arg_num: num_args_for_format, method: method_name,
+                      field_num: num_expected_fields)
+        end
+      end
+    end
+  end
+end