rubocop 0.87.1

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? && /[1-9]/.match?(node.source)
+
+          add_offense(node)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,195 @@
+# 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.
+      #
+      # In addition it checks whether different formats are used in the same
+      # format string. Do not mix numbered, unnumbered, and named formats in
+      # the same format string.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   format('A value: %s and another: %i', a_value)
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   format('A value: %s and another: %i', a_value, another)
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   format('Unnumbered format: %s and numbered: %2$s', a_value, another)
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   format('Numbered format: %1$s and numbered %2$s', 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).'
+        MSG_INVALID = 'Format string is invalid because formatting sequence types ' \
+                      '(numbered, named or unnumbered) are mixed.'
+
+        KERNEL = 'Kernel'
+        SHOVEL = '<<'
+        STRING_TYPES = %i[str dstr].freeze
+
+        def on_send(node)
+          return unless format_string?(node)
+
+          if invalid_format_string?(node)
+            add_offense(node, location: :selector, message: MSG_INVALID)
+            return
+          end
+
+          return unless offending_node?(node)
+
+          add_offense(node, location: :selector)
+        end
+
+        private
+
+        def format_string?(node)
+          called_on_string?(node) && method_with_format_args?(node)
+        end
+
+        def invalid_format_string?(node)
+          string = if sprintf?(node) || format?(node)
+                     node.first_argument.source
+                   else
+                     node.receiver.source
+                   end
+          !RuboCop::Cop::Utils::FormatString.new(string).valid?
+        end
+
+        def offending_node?(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

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

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for the ordering of a method call where
+      # the receiver of the call is a HEREDOC.
+      #
+      # @example
+      #   # bad
+      #
+      #      <<-SQL
+      #        bar
+      #      SQL
+      #      .strip_indent
+      #
+      #      <<-SQL
+      #        bar
+      #      SQL
+      #      .strip_indent
+      #      .trim
+      #
+      #   # good
+      #
+      #      <<~SQL
+      #        bar
+      #      SQL
+      #
+      #      <<~SQL.trim
+      #        bar
+      #      SQL
+      #
+      class HeredocMethodCallPosition < Cop
+        include RangeHelp
+
+        MSG = 'Put a method call with a HEREDOC receiver on the ' \
+        'same line as the HEREDOC opening.'
+
+        def on_send(node)
+          heredoc = heredoc_node_descendent_receiver(node)
+          return unless heredoc
+          return if correctly_positioned?(node, heredoc)
+
+          add_offense(node, location: call_after_heredoc_range(heredoc))
+        end
+        alias on_csend on_send
+
+        def autocorrect(node)
+          heredoc = heredoc_node_descendent_receiver(node)
+
+          lambda do |corrector|
+            call_range = call_range_to_safely_reposition(node, heredoc)
+            return if call_range.nil?
+
+            call_source = call_range.source.strip
+            corrector.remove(call_range)
+            corrector.insert_after(heredoc_begin_line_range(node), call_source)
+          end
+        end
+
+        private
+
+        def heredoc_node_descendent_receiver(node)
+          while send_node?(node)
+            return node.receiver if heredoc_node?(node.receiver)
+
+            node = node.receiver
+          end
+        end
+
+        def send_node?(node)
+          return nil unless node
+
+          node.call_type?
+        end
+
+        def heredoc_node?(node)
+          node.respond_to?(:heredoc?) && node.heredoc?
+        end
+
+        def call_after_heredoc_range(heredoc)
+          pos = heredoc_end_pos(heredoc)
+          range_between(pos + 1, pos + 2)
+        end
+
+        def correctly_positioned?(node, heredoc)
+          heredoc_end_pos(heredoc) > call_end_pos(node)
+        end
+
+        def calls_on_multiple_lines?(node, _heredoc)
+          last_line = node.last_line
+          while send_node?(node)
+            return true unless last_line == node.last_line
+            return true unless all_on_same_line?(node.arguments)
+
+            node = node.receiver
+          end
+          false
+        end
+
+        def all_on_same_line?(nodes)
+          return true if nodes.empty?
+
+          nodes.first.first_line == nodes.last.last_line
+        end
+
+        def heredoc_end_pos(heredoc)
+          heredoc.location.heredoc_end.end_pos
+        end
+
+        def call_end_pos(node)
+          node.source_range.end_pos
+        end
+
+        def heredoc_begin_line_range(heredoc)
+          pos = heredoc.source_range.begin_pos
+          range_by_whole_lines(range_between(pos, pos))
+        end
+
+        def call_line_range(node)
+          pos = node.source_range.end_pos
+          range_by_whole_lines(range_between(pos, pos))
+        end
+
+        # Returns nil if no range can be safely repositioned.
+        def call_range_to_safely_reposition(node, heredoc)
+          return nil if calls_on_multiple_lines?(node, heredoc)
+
+          heredoc_end_pos = heredoc_end_pos(heredoc)
+          call_end_pos = call_end_pos(node)
+
+          call_range = range_between(heredoc_end_pos, call_end_pos)
+          call_line_range = call_line_range(node)
+
+          call_source = call_range.source.strip
+          call_line_source = call_line_range.source.strip
+
+          return call_range if call_source == call_line_source
+
+          if trailing_comma?(call_source, call_line_source)
+            # If there's some on the last line other than the call, e.g.
+            # a trailing comma, then we leave the "\n" following the
+            # heredoc_end in place.
+            return range_between(heredoc_end_pos, call_end_pos + 1)
+          end
+
+          nil
+        end
+
+        def trailing_comma?(call_source, call_line_source)
+          call_source + ',' == call_line_source
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for implicit string concatenation of string literals
+      # which are on the same line.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   array = ['Item 1' 'Item 2']
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   array = ['Item 1Item 2']
+      #   array = ['Item 1' + 'Item 2']
+      #   array = [
+      #     'Item 1' \
+      #     'Item 2'
+      #   ]
+      class ImplicitStringConcatenation < Cop
+        MSG = 'Combine %<string1>s and %<string2>s into a single string ' \
+              'literal, rather than using implicit string concatenation.'
+        FOR_ARRAY = ' Or, if they were intended to be separate array ' \
+                    'elements, separate them with a comma.'
+        FOR_METHOD = ' Or, if they were intended to be separate method ' \
+                     'arguments, separate them with a comma.'
+
+        def on_dstr(node)
+          each_bad_cons(node) do |child_node1, child_node2|
+            range   = child_node1.source_range.join(child_node2.source_range)
+            message = format(MSG,
+                             string1: display_str(child_node1),
+                             string2: display_str(child_node2))
+            if node.parent&.array_type?
+              message << FOR_ARRAY
+            elsif node.parent&.send_type?
+              message << FOR_METHOD
+            end
+            add_offense(node, location: range, message: message)
+          end
+        end
+
+        private
+
+        def each_bad_cons(node)
+          node.children.each_cons(2) do |child_node1, child_node2|
+            # `'abc' 'def'` -> (dstr (str "abc") (str "def"))
+            next unless string_literals?(child_node1, child_node2)
+            next unless child_node1.last_line == child_node2.first_line
+
+            # Make sure we don't flag a string literal which simply has
+            # embedded newlines
+            # `"abc\ndef"` also -> (dstr (str "abc") (str "def"))
+            next unless child_node1.source[-1] == ending_delimiter(child_node1)
+
+            yield child_node1, child_node2
+          end
+        end
+
+        def ending_delimiter(str)
+          # implicit string concatenation does not work with %{}, etc.
+          if str.source[0] == "'"
+            "'"
+          elsif str.source[0] == '"'
+            '"'
+          end
+        end
+
+        def string_literal?(node)
+          node.str_type? ||
+            (node.dstr_type? && node.children.all? { |c| string_literal?(c) })
+        end
+
+        def string_literals?(node1, node2)
+          string_literal?(node1) && string_literal?(node2)
+        end
+
+        def display_str(node)
+          if /\n/.match?(node.source)
+            str_content(node).inspect
+          else
+            node.source
+          end
+        end
+
+        def str_content(node)
+          if node.str_type?
+            node.children[0]
+          else
+            node.children.map { |c| str_content(c) }.join
+          end
+        end
+      end
+    end
+  end
+end