fablicop 1.10.1 → 1.10.3

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

@@ -0,0 +1,152 @@
+# 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 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/vendor/bundle/ruby/3.2.0/gems/rubocop-1.52.1/lib/rubocop/cop/lint/identity_comparison.rb

@@ -0,0 +1,50 @@
+# 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.52.1/lib/rubocop/cop/lint/implicit_string_concatenation.rb

@@ -0,0 +1,101 @@
+# 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.52.1/lib/rubocop/cop/lint/incompatible_io_select_with_fiber_scheduler.rb

@@ -0,0 +1,81 @@
+# 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

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.52.1/lib/rubocop/cop/lint/ineffective_access_modifier.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for `private` or `protected` access modifiers which are
+      # applied to a singleton method. These access modifiers do not make
+      # singleton methods private/protected. `private_class_method` can be
+      # used for that.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   class C
+      #     private
+      #
+      #     def self.method
+      #       puts 'hi'
+      #     end
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   class C
+      #     def self.method
+      #       puts 'hi'
+      #     end
+      #
+      #     private_class_method :method
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   class C
+      #     class << self
+      #       private
+      #
+      #       def method
+      #         puts 'hi'
+      #       end
+      #     end
+      #   end
+      class IneffectiveAccessModifier < Base
+        MSG = '`%<modifier>s` (on line %<line>d) does not make singleton ' \
+              'methods %<modifier>s. Use %<alternative>s instead.'
+        ALTERNATIVE_PRIVATE = '`private_class_method` or `private` inside a `class << self` block'
+        ALTERNATIVE_PROTECTED = '`protected` inside a `class << self` block'
+
+        # @!method private_class_methods(node)
+        def_node_search :private_class_methods, <<~PATTERN
+          (send nil? :private_class_method $...)
+        PATTERN
+
+        def on_class(node)
+          check_node(node.body)
+        end
+        alias on_module on_class
+
+        private
+
+        def check_node(node)
+          return unless node&.begin_type?
+
+          ineffective_modifier(node) do |defs_node, modifier|
+            add_offense(defs_node.loc.keyword, message: format_message(modifier))
+          end
+        end
+
+        def private_class_method_names(node)
+          private_class_methods(node).to_a.flatten.select(&:basic_literal?).map(&:value)
+        end
+
+        def format_message(modifier)
+          visibility = modifier.method_name
+          alternative = if visibility == :private
+                          ALTERNATIVE_PRIVATE
+                        else
+                          ALTERNATIVE_PROTECTED
+                        end
+          format(MSG, modifier: visibility,
+                      line: modifier.source_range.line,
+                      alternative: alternative)
+        end
+
+        # rubocop:disable Metrics/CyclomaticComplexity
+        def ineffective_modifier(node, ignored_methods = nil, modifier = nil, &block)
+          node.each_child_node do |child|
+            case child.type
+            when :send
+              modifier = child if access_modifier?(child)
+            when :defs
+              ignored_methods ||= private_class_method_names(node)
+              next if correct_visibility?(child, modifier, ignored_methods)
+
+              yield child, modifier
+            when :kwbegin
+              ignored_methods ||= private_class_method_names(node)
+              ineffective_modifier(child, ignored_methods, modifier, &block)
+            end
+          end
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity
+
+        def access_modifier?(node)
+          node.bare_access_modifier? && !node.method?(:module_function)
+        end
+
+        def correct_visibility?(node, modifier, ignored_methods)
+          return true if modifier.nil? || modifier.method?(:public)
+
+          ignored_methods.include?(node.method_name)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.52.1/lib/rubocop/cop/lint/inherit_exception.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Looks for error classes inheriting from `Exception`.
+      # It is configurable to suggest using either `StandardError` (default) or
+      # `RuntimeError` instead.
+      #
+      # @safety
+      #   This cop's autocorrection is unsafe because `rescue` that omit
+      #   exception class handle `StandardError` and its subclasses,
+      #   but not `Exception` and its subclasses.
+      #
+      # @example EnforcedStyle: standard_error (default)
+      #   # bad
+      #
+      #   class C < Exception; end
+      #
+      #   C = Class.new(Exception)
+      #
+      #   # good
+      #
+      #   class C < StandardError; end
+      #
+      #   C = Class.new(StandardError)
+      #
+      # @example EnforcedStyle: runtime_error
+      #   # bad
+      #
+      #   class C < Exception; end
+      #
+      #   C = Class.new(Exception)
+      #
+      #   # good
+      #
+      #   class C < RuntimeError; end
+      #
+      #   C = Class.new(RuntimeError)
+      class InheritException < Base
+        include ConfigurableEnforcedStyle
+        extend AutoCorrector
+
+        MSG = 'Inherit from `%<prefer>s` instead of `Exception`.'
+        PREFERRED_BASE_CLASS = {
+          runtime_error: 'RuntimeError',
+          standard_error: 'StandardError'
+        }.freeze
+
+        RESTRICT_ON_SEND = %i[new].freeze
+
+        # @!method class_new_call?(node)
+        def_node_matcher :class_new_call?, <<~PATTERN
+          (send
+            (const {cbase nil?} :Class) :new
+            $(const {cbase nil?} _))
+        PATTERN
+
+        def on_class(node)
+          return unless node.parent_class && exception_class?(node.parent_class)
+          return if inherit_exception_class_with_omitted_namespace?(node)
+
+          message = message(node.parent_class)
+
+          add_offense(node.parent_class, message: message) do |corrector|
+            corrector.replace(node.parent_class, preferred_base_class)
+          end
+        end
+
+        def on_send(node)
+          constant = class_new_call?(node)
+          return unless constant && exception_class?(constant)
+
+          message = message(constant)
+
+          add_offense(constant, message: message) do |corrector|
+            corrector.replace(constant, preferred_base_class)
+          end
+        end
+
+        private
+
+        def message(node)
+          format(MSG, prefer: preferred_base_class, current: node.const_name)
+        end
+
+        def exception_class?(class_node)
+          class_node.const_name == 'Exception'
+        end
+
+        def inherit_exception_class_with_omitted_namespace?(class_node)
+          return false if class_node.parent_class.namespace&.cbase_type?
+
+          class_node.left_siblings.any? do |sibling|
+            sibling.respond_to?(:identifier) && exception_class?(sibling.identifier)
+          end
+        end
+
+        def preferred_base_class
+          PREFERRED_BASE_CLASS[style]
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.52.1/lib/rubocop/cop/lint/interpolation_check.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for interpolation in a single quoted string.
+      #
+      # @safety
+      #   This cop's autocorrection is unsafe because although it always replaces single quotes as
+      #   if it were miswritten double quotes, it is not always the case. For example,
+      #   `'#{foo} bar'` would be replaced by `"#{foo} bar"`, so the replaced code would evaluate
+      #   the expression `foo`.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   foo = 'something with #{interpolation} inside'
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   foo = "something with #{interpolation} inside"
+      class InterpolationCheck < Base
+        extend AutoCorrector
+
+        MSG = 'Interpolation in single quoted string detected. ' \
+              'Use double quoted strings if you need interpolation.'
+
+        def on_str(node)
+          return if node.parent&.regexp_type?
+          return unless /(?<!\\)#\{.*\}/.match?(node.source)
+          return if heredoc?(node)
+          return unless node.loc.begin && node.loc.end
+
+          add_offense(node) { |corrector| autocorrect(corrector, node) }
+        end
+
+        private
+
+        def autocorrect(corrector, node)
+          starting_token, ending_token = if node.source.include?('"')
+                                           ['%{', '}']
+                                         else
+                                           ['"', '"']
+                                         end
+
+          corrector.replace(node.loc.begin, starting_token)
+          corrector.replace(node.loc.end, ending_token)
+        end
+
+        def heredoc?(node)
+          node.loc.is_a?(Parser::Source::Map::Heredoc) || (node.parent && heredoc?(node.parent))
+        end
+      end
+    end
+  end
+end