study_line 0.2.7 → 0.2.8

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.60.0/lib/rubocop/cop/lint/format_parameter_mismatch.rb

@@ -1,201 +0,0 @@
-# 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 < Base
-        # 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
-        RESTRICT_ON_SEND = %i[format sprintf %].freeze
-
-        def on_send(node)
-          return unless format_string?(node)
-
-          if invalid_format_string?(node)
-            add_offense(node.loc.selector, message: MSG_INVALID)
-            return
-          end
-
-          return unless offending_node?(node)
-
-          add_offense(node.loc.selector, message: message(node))
-        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
-
-          first_arg = node.first_argument
-          return false if num_of_expected_fields.zero? &&
-                          (first_arg.dstr_type? || first_arg.array_type?)
-
-          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
-
-        # @!method called_on_string?(node)
-        def_node_matcher :called_on_string?, <<~PATTERN
-          {(send {nil? const_type?} _ {str dstr} ...)
-           (send {str dstr} ...)}
-        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 && string_type?(node.first_argument)
-        end
-
-        def expected_fields_count(node)
-          return :unknown unless string_type?(node)
-
-          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_type?(receiver) || node.first_argument.array_type?)
-
-          return false if percent && string_type?(receiver) && 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
-
-        def string_type?(node)
-          STRING_TYPES.include?(node.type)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.60.0/lib/rubocop/cop/lint/hash_compare_by_identity.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Lint
-      # Prefer using `Hash#compare_by_identity` rather than using `object_id`
-      # for hash keys.
-      #
-      # This cop looks for hashes being keyed by objects' `object_id`, using
-      # one of these methods: `key?`, `has_key?`, `fetch`, `[]` and `[]=`.
-      #
-      # @safety
-      #   This cop is unsafe. Although unlikely, the hash could store both object
-      #   ids and other values that need be compared by value, and thus
-      #   could be a false positive.
-      #
-      #   Furthermore, this cop cannot guarantee that the receiver of one of the
-      #   methods (`key?`, etc.) is actually a hash.
-      #
-      # @example
-      #   # bad
-      #   hash = {}
-      #   hash[foo.object_id] = :bar
-      #   hash.key?(baz.object_id)
-      #
-      #   # good
-      #   hash = {}.compare_by_identity
-      #   hash[foo] = :bar
-      #   hash.key?(baz)
-      #
-      class HashCompareByIdentity < Base
-        RESTRICT_ON_SEND = %i[key? has_key? fetch [] []=].freeze
-
-        MSG = 'Use `Hash#compare_by_identity` instead of using `object_id` for keys.'
-
-        # @!method id_as_hash_key?(node)
-        def_node_matcher :id_as_hash_key?, <<~PATTERN
-          (call _ {:key? :has_key? :fetch :[] :[]=} (send _ :object_id) ...)
-        PATTERN
-
-        def on_send(node)
-          add_offense(node) if id_as_hash_key?(node)
-        end
-        alias on_csend on_send
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.60.0/lib/rubocop/cop/lint/heredoc_method_call_position.rb

@@ -1,152 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Lint
-      # 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 < Base
-        include RangeHelp
-        extend AutoCorrector
-
-        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(call_after_heredoc_range(heredoc)) do |corrector|
-            autocorrect(corrector, node, heredoc)
-          end
-        end
-        alias on_csend on_send
-
-        private
-
-        def autocorrect(corrector, node, heredoc)
-          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
-
-        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 false 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/vendor/bundle/ruby/3.2.0/gems/rubocop-1.60.0/lib/rubocop/cop/lint/identity_comparison.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Lint
-      # Prefer `equal?` over `==` when comparing `object_id`.
-      #
-      # `Object#equal?` is provided to compare objects for identity, and in contrast
-      # `Object#==` is provided for the purpose of doing value comparison.
-      #
-      # @example
-      #   # bad
-      #   foo.object_id == bar.object_id
-      #
-      #   # good
-      #   foo.equal?(bar)
-      #
-      class IdentityComparison < Base
-        extend AutoCorrector
-
-        MSG = 'Use `equal?` instead `==` when comparing `object_id`.'
-        RESTRICT_ON_SEND = %i[==].freeze
-
-        def on_send(node)
-          return unless compare_between_object_id_by_double_equal?(node)
-
-          add_offense(node) do |corrector|
-            receiver = node.receiver.receiver
-            argument = node.first_argument.receiver
-            return unless receiver && argument
-
-            replacement = "#{receiver.source}.equal?(#{argument.source})"
-
-            corrector.replace(node, replacement)
-          end
-        end
-
-        private
-
-        def compare_between_object_id_by_double_equal?(node)
-          object_id_method?(node.receiver) && object_id_method?(node.first_argument)
-        end
-
-        def object_id_method?(node)
-          node.send_type? && node.method?(:object_id)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.60.0/lib/rubocop/cop/lint/implicit_string_concatenation.rb

@@ -1,101 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Lint
-      # 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 < Base
-        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(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.
-          case str.source[0]
-          when "'"
-            "'"
-          when '"'
-            '"'
-          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 node.source.include?("\n")
-            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

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.60.0/lib/rubocop/cop/lint/incompatible_io_select_with_fiber_scheduler.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Lint
-      # Checks for `IO.select` that is incompatible with Fiber Scheduler since Ruby 3.0.
-      #
-      # When an array of IO objects waiting for an exception (the third argument of `IO.select`)
-      # is used as an argument, there is no alternative API, so offenses are not registered.
-      #
-      # NOTE: When the method is successful the return value of `IO.select` is `[[IO]]`,
-      # and the return value of `io.wait_readable` and `io.wait_writable` are `self`.
-      # They are not autocorrected when assigning a return value because these types are different.
-      # It's up to user how to handle the return value.
-      #
-      # @safety
-      #   This cop's autocorrection is unsafe because `NoMethodError` occurs
-      #   if `require 'io/wait'` is not called.
-      #
-      # @example
-      #
-      #   # bad
-      #   IO.select([io], [], [], timeout)
-      #
-      #   # good
-      #   io.wait_readable(timeout)
-      #
-      #   # bad
-      #   IO.select([], [io], [], timeout)
-      #
-      #   # good
-      #   io.wait_writable(timeout)
-      #
-      class IncompatibleIoSelectWithFiberScheduler < Base
-        extend AutoCorrector
-
-        MSG = 'Use `%<preferred>s` instead of `%<current>s`.'
-        RESTRICT_ON_SEND = %i[select].freeze
-
-        # @!method io_select(node)
-        def_node_matcher :io_select, <<~PATTERN
-          (send
-            (const {nil? cbase} :IO) :select $...)
-        PATTERN
-
-        def on_send(node)
-          read, write, excepts, timeout = *io_select(node)
-          return if excepts && !excepts.children.empty?
-          return unless scheduler_compatible?(read, write) || scheduler_compatible?(write, read)
-
-          preferred = preferred_method(read, write, timeout)
-          message = format(MSG, preferred: preferred, current: node.source)
-
-          add_offense(node, message: message) do |corrector|
-            next if node.parent&.assignment?
-
-            corrector.replace(node, preferred)
-          end
-        end
-
-        private
-
-        def scheduler_compatible?(io1, io2)
-          return false unless io1&.array_type? && io1.values.size == 1
-
-          io2&.array_type? ? io2.values.empty? : (io2.nil? || io2.nil_type?)
-        end
-
-        def preferred_method(read, write, timeout)
-          timeout_argument = timeout.nil? ? '' : "(#{timeout.source})"
-
-          if read.array_type? && read.values[0]
-            "#{read.values[0].source}.wait_readable#{timeout_argument}"
-          else
-            "#{write.values[0].source}.wait_writable#{timeout_argument}"
-          end
-        end
-      end
-    end
-  end
-end