fablicop 1.10.2 → 1.10.3

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.54.1/lib/rubocop/cop/lint/else_layout.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for odd `else` block layout - like
+      # having an expression on the same line as the `else` keyword,
+      # which is usually a mistake.
+      #
+      # Its autocorrection tweaks layout to keep the syntax. So, this autocorrection
+      # is compatible correction for bad case syntax, but if your code makes a mistake
+      # with `elsif` and `else`, you will have to correct it manually.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   if something
+      #     # ...
+      #   else do_this
+      #     do_that
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   # This code is compatible with the bad case. It will be autocorrected like this.
+      #   if something
+      #     # ...
+      #   else
+      #     do_this
+      #     do_that
+      #   end
+      #
+      #   # This code is incompatible with the bad case.
+      #   # If `do_this` is a condition, `elsif` should be used instead of `else`.
+      #   if something
+      #     # ...
+      #   elsif do_this
+      #     do_that
+      #   end
+      class ElseLayout < Base
+        include Alignment
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Odd `else` layout detected. Did you mean to use `elsif`?'
+
+        def on_if(node)
+          return if node.ternary?
+
+          # If the if is on a single line, it'll be handled by `Style/OneLineConditional`
+          return if node.single_line?
+
+          check(node)
+        end
+
+        private
+
+        def check(node)
+          return unless node.else_branch
+
+          if node.else? && node.loc.else.is?('else')
+            check_else(node)
+          elsif node.if?
+            check(node.else_branch)
+          end
+        end
+
+        def check_else(node)
+          else_branch = node.else_branch
+          first_else = else_branch.begin_type? ? else_branch.children.first : else_branch
+
+          return unless first_else
+          return unless same_line?(first_else, node.loc.else)
+
+          add_offense(first_else) { |corrector| autocorrect(corrector, node, first_else) }
+        end
+
+        def autocorrect(corrector, node, first_else)
+          corrector.insert_after(node.loc.else, "\n")
+
+          blank_range = range_between(node.loc.else.end_pos, first_else.source_range.begin_pos)
+          corrector.replace(blank_range, indentation(node))
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.54.1/lib/rubocop/cop/lint/empty_block.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for blocks without a body.
+      # Such empty blocks are typically an oversight or we should provide a comment
+      # be clearer what we're aiming for.
+      #
+      # Empty lambdas and procs are ignored by default.
+      #
+      # NOTE: For backwards compatibility, the configuration that allows/disallows
+      # empty lambdas and procs is called `AllowEmptyLambdas`, even though it also
+      # applies to procs.
+      #
+      # @example
+      #   # bad
+      #   items.each { |item| }
+      #
+      #   # good
+      #   items.each { |item| puts item }
+      #
+      # @example AllowComments: true (default)
+      #   # good
+      #   items.each do |item|
+      #     # TODO: implement later (inner comment)
+      #   end
+      #
+      #   items.each { |item| } # TODO: implement later (inline comment)
+      #
+      # @example AllowComments: false
+      #   # bad
+      #   items.each do |item|
+      #     # TODO: implement later (inner comment)
+      #   end
+      #
+      #   items.each { |item| } # TODO: implement later (inline comment)
+      #
+      # @example AllowEmptyLambdas: true (default)
+      #   # good
+      #   allow(subject).to receive(:callable).and_return(-> {})
+      #
+      #   placeholder = lambda do
+      #   end
+      #   (callable || placeholder).call
+      #
+      #   proc { }
+      #
+      #   Proc.new { }
+      #
+      # @example AllowEmptyLambdas: false
+      #   # bad
+      #   allow(subject).to receive(:callable).and_return(-> {})
+      #
+      #   placeholder = lambda do
+      #   end
+      #   (callable || placeholder).call
+      #
+      #   proc { }
+      #
+      #   Proc.new { }
+      #
+      class EmptyBlock < Base
+        MSG = 'Empty block detected.'
+
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+          return if node.body
+          return if allow_empty_lambdas? && node.lambda_or_proc?
+          return if cop_config['AllowComments'] && allow_comment?(node)
+
+          add_offense(node)
+        end
+
+        private
+
+        def allow_comment?(node)
+          return false unless processed_source.contains_comment?(node.source_range)
+
+          line_comment = processed_source.comment_at_line(node.source_range.line)
+          !line_comment || !comment_disables_cop?(line_comment.source)
+        end
+
+        def allow_empty_lambdas?
+          cop_config['AllowEmptyLambdas']
+        end
+
+        def comment_disables_cop?(comment)
+          regexp_pattern = "# rubocop : (disable|todo) ([^,],)* (all|#{cop_name})"
+          Regexp.new(regexp_pattern.gsub(' ', '\s*')).match?(comment)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.54.1/lib/rubocop/cop/lint/empty_class.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for classes and metaclasses without a body.
+      # Such empty classes and metaclasses are typically an oversight or we should provide a comment
+      # to be clearer what we're aiming for.
+      #
+      # @example
+      #   # bad
+      #   class Foo
+      #   end
+      #
+      #   class Bar
+      #     class << self
+      #     end
+      #   end
+      #
+      #   class << obj
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     def do_something
+      #       # ... code
+      #     end
+      #   end
+      #
+      #   class Bar
+      #     class << self
+      #       attr_reader :bar
+      #     end
+      #   end
+      #
+      #   class << obj
+      #     attr_reader :bar
+      #   end
+      #
+      # @example AllowComments: false (default)
+      #   # bad
+      #   class Foo
+      #     # TODO: implement later
+      #   end
+      #
+      #   class Bar
+      #     class << self
+      #       # TODO: implement later
+      #     end
+      #   end
+      #
+      #   class << obj
+      #     # TODO: implement later
+      #   end
+      #
+      # @example AllowComments: true
+      #   # good
+      #   class Foo
+      #     # TODO: implement later
+      #   end
+      #
+      #   class Bar
+      #     class << self
+      #       # TODO: implement later
+      #     end
+      #   end
+      #
+      #   class << obj
+      #     # TODO: implement later
+      #   end
+      #
+      class EmptyClass < Base
+        CLASS_MSG = 'Empty class detected.'
+        METACLASS_MSG = 'Empty metaclass detected.'
+
+        def on_class(node)
+          add_offense(node, message: CLASS_MSG) unless body_or_allowed_comment_lines?(node) ||
+                                                       node.parent_class
+        end
+
+        def on_sclass(node)
+          add_offense(node, message: METACLASS_MSG) unless body_or_allowed_comment_lines?(node)
+        end
+
+        private
+
+        def body_or_allowed_comment_lines?(node)
+          return true if node.body
+
+          cop_config['AllowComments'] && processed_source.contains_comment?(node.source_range)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.54.1/lib/rubocop/cop/lint/empty_conditional_body.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for the presence of `if`, `elsif` and `unless` branches without a body.
+      #
+      # NOTE: empty `else` branches are handled by `Style/EmptyElse`.
+      #
+      # @safety
+      #   Autocorrection for this cop is not safe. The conditions for empty branches that
+      #   the autocorrection removes may have side effects, or the logic in subsequent
+      #   branches may change due to the removal of a previous condition.
+      #
+      # @example
+      #   # bad
+      #   if condition
+      #   end
+      #
+      #   # bad
+      #   unless condition
+      #   end
+      #
+      #   # bad
+      #   if condition
+      #     do_something
+      #   elsif other_condition
+      #   end
+      #
+      #   # good
+      #   if condition
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   unless condition
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   if condition
+      #     do_something
+      #   elsif other_condition
+      #     do_something_else
+      #   end
+      #
+      # @example AllowComments: true (default)
+      #   # good
+      #   if condition
+      #     do_something
+      #   elsif other_condition
+      #     # noop
+      #   end
+      #
+      # @example AllowComments: false
+      #   # bad
+      #   if condition
+      #     do_something
+      #   elsif other_condition
+      #     # noop
+      #   end
+      #
+      class EmptyConditionalBody < Base
+        extend AutoCorrector
+        include CommentsHelp
+        include RangeHelp
+
+        MSG = 'Avoid `%<keyword>s` branches without a body.'
+
+        def on_if(node)
+          return if node.body || same_line?(node.loc.begin, node.loc.end)
+          return if cop_config['AllowComments'] && contains_comments?(node)
+
+          add_offense(node, message: format(MSG, keyword: node.keyword)) do |corrector|
+            next if node.parent&.call_type?
+
+            autocorrect(corrector, node)
+          end
+        end
+
+        private
+
+        def autocorrect(corrector, node)
+          remove_comments(corrector, node)
+          remove_empty_branch(corrector, node)
+          correct_other_branches(corrector, node)
+        end
+
+        def remove_comments(corrector, node)
+          comments_in_range(node).each do |comment|
+            range = range_by_whole_lines(comment.source_range, include_final_newline: true)
+            corrector.remove(range)
+          end
+        end
+
+        def remove_empty_branch(corrector, node)
+          if empty_if_branch?(node) && else_branch?(node)
+            corrector.remove(branch_range(node))
+          else
+            corrector.remove(deletion_range(branch_range(node)))
+          end
+        end
+
+        def correct_other_branches(corrector, node)
+          return unless require_other_branches_correction?(node)
+
+          if node.else_branch&.if_type?
+            # Replace an orphaned `elsif` with `if`
+            corrector.replace(node.else_branch.loc.keyword, 'if')
+          else
+            # Flip orphaned `else`
+            corrector.replace(node.loc.else, "#{node.inverse_keyword} #{node.condition.source}")
+          end
+        end
+
+        def require_other_branches_correction?(node)
+          return false unless node.if_type? && node.else?
+          return false if !empty_if_branch?(node) && node.elsif?
+
+          !empty_elsif_branch?(node)
+        end
+
+        def empty_if_branch?(node)
+          return false unless (parent = node.parent)
+          return true unless parent.if_type?
+          return true unless (if_branch = parent.if_branch)
+
+          if_branch.if_type? && !if_branch.body
+        end
+
+        def empty_elsif_branch?(node)
+          return false unless (else_branch = node.else_branch)
+
+          else_branch.if_type? && !else_branch.body
+        end
+
+        def else_branch?(node)
+          node.else_branch && !node.else_branch.if_type?
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        def branch_range(node)
+          if empty_if_branch?(node) && else_branch?(node)
+            node.source_range.with(end_pos: node.loc.else.begin_pos)
+          elsif node.loc.else
+            node.source_range.with(end_pos: node.condition.source_range.end_pos)
+          elsif all_branches_body_missing?(node)
+            if_node = node.ancestors.detect(&:if?)
+            node.source_range.with(end_pos: if_node.loc.end.end_pos)
+          else
+            node.source_range
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        def all_branches_body_missing?(node)
+          return false unless node.parent&.if_type?
+
+          node.parent.branches.compact.empty?
+        end
+
+        def deletion_range(range)
+          # Collect a range between the start of the `if` node and the next relevant node,
+          # including final new line.
+          # Based on `RangeHelp#range_by_whole_lines` but allows the `if` to not start
+          # on the first column.
+          buffer = @processed_source.buffer
+
+          last_line = buffer.source_line(range.last_line)
+          end_offset = last_line.length - range.last_column + 1
+
+          range.adjust(end_pos: end_offset).intersect(buffer.source_range)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.54.1/lib/rubocop/cop/lint/empty_ensure.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for empty `ensure` blocks
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   def some_method
+      #     do_something
+      #   ensure
+      #   end
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   begin
+      #     do_something
+      #   ensure
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def some_method
+      #     do_something
+      #   ensure
+      #     do_something_else
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   begin
+      #     do_something
+      #   ensure
+      #     do_something_else
+      #   end
+      class EmptyEnsure < Base
+        extend AutoCorrector
+
+        MSG = 'Empty `ensure` block detected.'
+
+        def on_ensure(node)
+          return if node.body
+
+          add_offense(node.loc.keyword) { |corrector| corrector.remove(node.loc.keyword) }
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.54.1/lib/rubocop/cop/lint/empty_expression.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # 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 < Base
+        MSG = 'Avoid empty expressions.'
+
+        def on_begin(node)
+          return unless empty_expression?(node)
+
+          add_offense(node)
+        end
+
+        private
+
+        def empty_expression?(begin_node)
+          begin_node.children.empty?
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.54.1/lib/rubocop/cop/lint/empty_file.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Enforces that Ruby source files are not empty.
+      #
+      # @example
+      #   # bad
+      #   # Empty file
+      #
+      #   # good
+      #   # File containing non commented source lines
+      #
+      # @example AllowComments: true (default)
+      #   # good
+      #   # File consisting only of comments
+      #
+      # @example AllowComments: false
+      #   # bad
+      #   # File consisting only of comments
+      #
+      class EmptyFile < Base
+        include RangeHelp
+
+        MSG = 'Empty file detected.'
+
+        def on_new_investigation
+          add_global_offense(MSG) if offending?
+        end
+
+        private
+
+        def offending?
+          empty_file? || (!cop_config['AllowComments'] && contains_only_comments?)
+        end
+
+        def empty_file?
+          processed_source.buffer.source.empty?
+        end
+
+        def contains_only_comments?
+          processed_source.lines.all? { |line| line.blank? || comment_line?(line) }
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.54.1/lib/rubocop/cop/lint/empty_in_pattern.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for the presence of `in` pattern branches without a body.
+      #
+      # @example
+      #
+      #   # bad
+      #   case condition
+      #   in [a]
+      #     do_something
+      #   in [a, b]
+      #   end
+      #
+      #   # good
+      #   case condition
+      #   in [a]
+      #     do_something
+      #   in [a, b]
+      #     nil
+      #   end
+      #
+      # @example AllowComments: true (default)
+      #
+      #   # good
+      #   case condition
+      #   in [a]
+      #     do_something
+      #   in [a, b]
+      #     # noop
+      #   end
+      #
+      # @example AllowComments: false
+      #
+      #   # bad
+      #   case condition
+      #   in [a]
+      #     do_something
+      #   in [a, b]
+      #     # noop
+      #   end
+      #
+      class EmptyInPattern < Base
+        extend TargetRubyVersion
+        include CommentsHelp
+
+        MSG = 'Avoid `in` branches without a body.'
+
+        minimum_target_ruby_version 2.7
+
+        def on_case_match(node)
+          node.in_pattern_branches.each do |branch|
+            next if branch.body
+            next if cop_config['AllowComments'] && contains_comments?(branch)
+
+            add_offense(branch)
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.54.1/lib/rubocop/cop/lint/empty_interpolation.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for empty interpolation.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   "result is #{}"
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   "result is #{some_result}"
+      class EmptyInterpolation < Base
+        include Interpolation
+        extend AutoCorrector
+
+        MSG = 'Empty interpolation detected.'
+
+        def on_interpolation(begin_node)
+          return unless begin_node.children.empty?
+
+          add_offense(begin_node) { |corrector| corrector.remove(begin_node) }
+        end
+      end
+    end
+  end
+end