fablicop 1.10.2 → 1.10.3

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.54.1/lib/rubocop/cop/style/empty_literal.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for the use of a method, the result of which
+      # would be a literal, like an empty array, hash, or string.
+      #
+      # @example
+      #   # bad
+      #   a = Array.new
+      #   h = Hash.new
+      #   s = String.new
+      #
+      #   # good
+      #   a = []
+      #   h = {}
+      #   s = ''
+      class EmptyLiteral < Base
+        include FrozenStringLiteral
+        include RangeHelp
+        extend AutoCorrector
+
+        ARR_MSG = 'Use array literal `[]` instead of `Array.new`.'
+        HASH_MSG = 'Use hash literal `{}` instead of `Hash.new`.'
+        STR_MSG = 'Use string literal `%<prefer>s` instead of `String.new`.'
+
+        RESTRICT_ON_SEND = %i[new].freeze
+
+        # @!method array_node(node)
+        def_node_matcher :array_node, '(send (const {nil? cbase} :Array) :new)'
+
+        # @!method hash_node(node)
+        def_node_matcher :hash_node, '(send (const {nil? cbase} :Hash) :new)'
+
+        # @!method str_node(node)
+        def_node_matcher :str_node, '(send (const {nil? cbase} :String) :new)'
+
+        # @!method array_with_block(node)
+        def_node_matcher :array_with_block, '(block (send (const {nil? cbase} :Array) :new) args _)'
+
+        # @!method hash_with_block(node)
+        def_node_matcher :hash_with_block, <<~PATTERN
+          {
+            (block (send (const {nil? cbase} :Hash) :new) args _)
+            (numblock (send (const {nil? cbase} :Hash) :new) ...)
+          }
+        PATTERN
+
+        def on_send(node)
+          return unless (message = offense_message(node))
+
+          add_offense(node, message: message) do |corrector|
+            corrector.replace(replacement_range(node), correction(node))
+          end
+        end
+
+        private
+
+        def offense_message(node)
+          if offense_array_node?(node)
+            ARR_MSG
+          elsif offense_hash_node?(node)
+            HASH_MSG
+          elsif str_node(node) && !frozen_strings?
+            format(STR_MSG, prefer: preferred_string_literal)
+          end
+        end
+
+        def preferred_string_literal
+          enforce_double_quotes? ? '""' : "''"
+        end
+
+        def enforce_double_quotes?
+          string_literals_config['EnforcedStyle'] == 'double_quotes'
+        end
+
+        def string_literals_config
+          config.for_cop('Style/StringLiterals')
+        end
+
+        def first_argument_unparenthesized?(node)
+          parent = node.parent
+          return false unless parent && %i[send super zsuper].include?(parent.type)
+
+          node.equal?(parent.arguments.first) && !parentheses?(node.parent)
+        end
+
+        def replacement_range(node)
+          if hash_node(node) && first_argument_unparenthesized?(node)
+            # `some_method {}` is not same as `some_method Hash.new`
+            # because the braces are interpreted as a block. We will have
+            # to rewrite the arguments to wrap them in parenthesis.
+            args = node.parent.arguments
+
+            range_between(args[0].source_range.begin_pos - 1, args[-1].source_range.end_pos)
+          else
+            node.source_range
+          end
+        end
+
+        def offense_array_node?(node)
+          array_node(node) && !array_with_block(node.parent)
+        end
+
+        def offense_hash_node?(node)
+          # If Hash.new takes a block, it can't be changed to {}.
+          hash_node(node) && !hash_with_block(node.parent)
+        end
+
+        def correction(node)
+          if offense_array_node?(node)
+            '[]'
+          elsif str_node(node)
+            preferred_string_literal
+          elsif offense_hash_node?(node)
+            if first_argument_unparenthesized?(node)
+              # `some_method {}` is not same as `some_method Hash.new`
+              # because the braces are interpreted as a block. We will have
+              # to rewrite the arguments to wrap them in parenthesis.
+              args = node.parent.arguments
+              "(#{args[1..].map(&:source).unshift('{}').join(', ')})"
+            else
+              '{}'
+            end
+          end
+        end
+
+        def frozen_strings?
+          return true if frozen_string_literals_enabled?
+
+          frozen_string_cop_enabled = config.for_cop('Style/FrozenStringLiteral')['Enabled']
+          frozen_string_cop_enabled && !frozen_string_literals_disabled?
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.54.1/lib/rubocop/cop/style/empty_method.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for the formatting of empty method definitions.
+      # By default it enforces empty method definitions to go on a single
+      # line (compact style), but it can be configured to enforce the `end`
+      # to go on its own line (expanded style).
+      #
+      # NOTE: A method definition is not considered empty if it contains
+      # comments.
+      #
+      # NOTE: Autocorrection will not be applied for the `compact` style
+      # if the resulting code is longer than the `Max` configuration for
+      # `Layout/LineLength`, but an offense will still be registered.
+      #
+      # @example EnforcedStyle: compact (default)
+      #   # bad
+      #   def foo(bar)
+      #   end
+      #
+      #   def self.foo(bar)
+      #   end
+      #
+      #   # good
+      #   def foo(bar); end
+      #
+      #   def foo(bar)
+      #     # baz
+      #   end
+      #
+      #   def self.foo(bar); end
+      #
+      # @example EnforcedStyle: expanded
+      #   # bad
+      #   def foo(bar); end
+      #
+      #   def self.foo(bar); end
+      #
+      #   # good
+      #   def foo(bar)
+      #   end
+      #
+      #   def self.foo(bar)
+      #   end
+      class EmptyMethod < Base
+        include ConfigurableEnforcedStyle
+        extend AutoCorrector
+
+        MSG_COMPACT = 'Put empty method definitions on a single line.'
+        MSG_EXPANDED = 'Put the `end` of empty method definitions on the next line.'
+
+        def on_def(node)
+          return if node.body || processed_source.contains_comment?(node.source_range)
+          return if correct_style?(node)
+
+          add_offense(node) do |corrector|
+            correction = corrected(node)
+            next if compact_style? && max_line_length && correction.size > max_line_length
+
+            corrector.replace(node, correction)
+          end
+        end
+        alias on_defs on_def
+
+        private
+
+        def message(_range)
+          compact_style? ? MSG_COMPACT : MSG_EXPANDED
+        end
+
+        def correct_style?(node)
+          (compact_style? && compact?(node)) || (expanded_style? && expanded?(node))
+        end
+
+        def corrected(node)
+          scope = node.receiver ? "#{node.receiver.source}." : ''
+          arguments = if node.arguments?
+                        args = node.arguments.map(&:source).join(', ')
+
+                        parentheses?(node.arguments) ? "(#{args})" : " #{args}"
+                      end
+          signature = [scope, node.method_name, arguments].join
+
+          ["def #{signature}", 'end'].join(joint(node))
+        end
+
+        def joint(node)
+          indent = ' ' * node.loc.column
+
+          compact_style? ? '; ' : "\n#{indent}"
+        end
+
+        def compact?(node)
+          node.single_line?
+        end
+
+        def expanded?(node)
+          node.multiline?
+        end
+
+        def compact_style?
+          style == :compact
+        end
+
+        def expanded_style?
+          style == :expanded
+        end
+
+        def max_line_length
+          return unless config.for_cop('Layout/LineLength')['Enabled']
+
+          config.for_cop('Layout/LineLength')['Max']
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.54.1/lib/rubocop/cop/style/encoding.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks ensures source files have no utf-8 encoding comments.
+      # @example
+      #   # bad
+      #   # encoding: UTF-8
+      #   # coding: UTF-8
+      #   # -*- coding: UTF-8 -*-
+      class Encoding < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Unnecessary utf-8 encoding comment.'
+        ENCODING_PATTERN = /#.*coding\s?[:=]\s?(?:UTF|utf)-8/.freeze
+        SHEBANG = '#!'
+
+        def on_new_investigation
+          return if processed_source.buffer.source.empty?
+
+          comments.each do |line_number, comment|
+            next unless offense?(comment)
+
+            register_offense(line_number, comment)
+          end
+        end
+
+        private
+
+        def comments
+          processed_source.lines.each.with_index.with_object({}) do |(line, line_number), comments|
+            next if line.start_with?(SHEBANG)
+
+            comment = MagicComment.parse(line)
+            return comments unless comment.valid?
+
+            comments[line_number + 1] = comment
+          end
+        end
+
+        def offense?(comment)
+          comment.encoding_specified? && comment.encoding.casecmp('utf-8').zero?
+        end
+
+        def register_offense(line_number, comment)
+          range = processed_source.buffer.line_range(line_number)
+
+          add_offense(range) do |corrector|
+            text = comment.without(:encoding)
+
+            if text.blank?
+              corrector.remove(range_with_surrounding_space(range, side: :right))
+            else
+              corrector.replace(range, text)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.54.1/lib/rubocop/cop/style/end_block.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for END blocks.
+      #
+      # @example
+      #   # bad
+      #   END { puts 'Goodbye!' }
+      #
+      #   # good
+      #   at_exit { puts 'Goodbye!' }
+      #
+      class EndBlock < Base
+        extend AutoCorrector
+
+        MSG = 'Avoid the use of `END` blocks. Use `Kernel#at_exit` instead.'
+
+        def on_postexe(node)
+          add_offense(node.loc.keyword) do |corrector|
+            corrector.replace(node.loc.keyword, 'at_exit')
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.54.1/lib/rubocop/cop/style/endless_method.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for endless methods.
+      #
+      # It can enforce either the use of endless methods definitions
+      # for single-lined method bodies, or disallow endless methods.
+      #
+      # Other method definition types are not considered by this cop.
+      #
+      # The supported styles are:
+      #
+      # * allow_single_line (default) - only single line endless method definitions are allowed.
+      # * allow_always - all endless method definitions are allowed.
+      # * disallow - all endless method definitions are disallowed.
+      #
+      # NOTE: Incorrect endless method definitions will always be
+      # corrected to a multi-line definition.
+      #
+      # @example EnforcedStyle: allow_single_line (default)
+      #   # good
+      #   def my_method() = x
+      #
+      #   # bad, multi-line endless method
+      #   def my_method() = x.foo
+      #                      .bar
+      #                      .baz
+      #
+      # @example EnforcedStyle: allow_always
+      #   # good
+      #   def my_method() = x
+      #
+      #   # good
+      #   def my_method() = x.foo
+      #                      .bar
+      #                      .baz
+      #
+      # @example EnforcedStyle: disallow
+      #   # bad
+      #   def my_method() = x
+      #
+      #   # bad
+      #   def my_method() = x.foo
+      #                      .bar
+      #                      .baz
+      #
+      class EndlessMethod < Base
+        include ConfigurableEnforcedStyle
+        extend TargetRubyVersion
+        extend AutoCorrector
+
+        minimum_target_ruby_version 3.0
+
+        CORRECTION_STYLES = %w[multiline single_line].freeze
+        MSG = 'Avoid endless method definitions.'
+        MSG_MULTI_LINE = 'Avoid endless method definitions with multiple lines.'
+
+        def on_def(node)
+          if style == :disallow
+            handle_disallow_style(node)
+          else
+            handle_allow_style(node)
+          end
+        end
+
+        private
+
+        def handle_allow_style(node)
+          return unless node.endless?
+          return if node.single_line? || style == :allow_always
+
+          add_offense(node, message: MSG_MULTI_LINE) do |corrector|
+            correct_to_multiline(corrector, node)
+          end
+        end
+
+        def handle_disallow_style(node)
+          return unless node.endless?
+
+          add_offense(node) { |corrector| correct_to_multiline(corrector, node) }
+        end
+
+        def correct_to_multiline(corrector, node)
+          replacement = <<~RUBY.strip
+            def #{node.method_name}#{arguments(node)}
+              #{node.body.source}
+            end
+          RUBY
+
+          corrector.replace(node, replacement)
+        end
+
+        def arguments(node, missing = '')
+          node.arguments.any? ? node.arguments.source : missing
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.54.1/lib/rubocop/cop/style/env_home.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for consistent usage of `ENV['HOME']`. If `nil` is used as
+      # the second argument of `ENV.fetch`, it is treated as a bad case like `ENV[]`.
+      #
+      # @safety
+      #   The cop is unsafe because the result when `nil` is assigned to `ENV['HOME']` changes:
+      #
+      #   [source,ruby]
+      #   ----
+      #   ENV['HOME'] = nil
+      #   ENV['HOME'] # => nil
+      #   Dir.home    # => '/home/foo'
+      #   ----
+      #
+      # @example
+      #
+      #   # bad
+      #   ENV['HOME']
+      #   ENV.fetch('HOME', nil)
+      #
+      #   # good
+      #   Dir.home
+      #
+      #   # good
+      #   ENV.fetch('HOME', default)
+      #
+      class EnvHome < Base
+        extend AutoCorrector
+
+        MSG = 'Use `Dir.home` instead.'
+        RESTRICT_ON_SEND = %i[[] fetch].freeze
+
+        # @!method env_home?(node)
+        def_node_matcher :env_home?, <<~PATTERN
+          (send
+            (const {cbase nil?} :ENV) {:[] :fetch}
+            (str "HOME")
+            ...)
+        PATTERN
+
+        def on_send(node)
+          return unless env_home?(node)
+          return if node.arguments.count == 2 && !node.arguments[1].nil_type?
+
+          add_offense(node) do |corrector|
+            corrector.replace(node, 'Dir.home')
+          end
+        end
+      end
+    end
+  end
+end