siteimprove_api_client 1.0.1 → 1.0.2

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.73.1/lib/rubocop/cop/layout/empty_line_after_guard_clause.rb

@@ -1,214 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Layout
-      # Enforces empty line after guard clause.
-      #
-      # This cop allows `# :nocov:` directive after guard clause because
-      # SimpleCov excludes code from the coverage report by wrapping it in `# :nocov:`:
-      #
-      # [source,ruby]
-      # ----
-      # def foo
-      #   # :nocov:
-      #   return if condition
-      #   # :nocov:
-      #   bar
-      # end
-      # ----
-      #
-      # Refer to SimpleCov's documentation for more details:
-      # https://github.com/simplecov-ruby/simplecov#ignoringskipping-code
-      #
-      # @example
-      #
-      #   # bad
-      #   def foo
-      #     return if need_return?
-      #     bar
-      #   end
-      #
-      #   # good
-      #   def foo
-      #     return if need_return?
-      #
-      #     bar
-      #   end
-      #
-      #   # good
-      #   def foo
-      #     return if something?
-      #     return if something_different?
-      #
-      #     bar
-      #   end
-      #
-      #   # also good
-      #   def foo
-      #     if something?
-      #       do_something
-      #       return if need_return?
-      #     end
-      #   end
-      class EmptyLineAfterGuardClause < Base
-        include RangeHelp
-        extend AutoCorrector
-        extend Util
-
-        MSG = 'Add empty line after guard clause.'
-        END_OF_HEREDOC_LINE = 1
-        SIMPLE_DIRECTIVE_COMMENT_PATTERN = /\A# *:nocov:\z/.freeze
-
-        def on_if(node)
-          return if correct_style?(node)
-          return if multiple_statements_on_line?(node)
-
-          if node.modifier_form? && (heredoc_node = last_heredoc_argument(node))
-            if next_line_empty_or_allowed_directive_comment?(heredoc_line(node, heredoc_node))
-              return
-            end
-
-            add_offense(heredoc_node.loc.heredoc_end) do |corrector|
-              autocorrect(corrector, heredoc_node)
-            end
-          else
-            return if next_line_empty_or_allowed_directive_comment?(node.last_line)
-
-            add_offense(offense_location(node)) { |corrector| autocorrect(corrector, node) }
-          end
-        end
-
-        private
-
-        def autocorrect(corrector, node)
-          node_range = if heredoc?(node)
-                         range_by_whole_lines(node.loc.heredoc_body)
-                       else
-                         range_by_whole_lines(node.source_range)
-                       end
-
-          next_line = node_range.last_line + 1
-          if next_line_allowed_directive_comment?(next_line)
-            node_range = processed_source.comment_at_line(next_line)
-          end
-
-          corrector.insert_after(node_range, "\n")
-        end
-
-        def correct_style?(node)
-          !contains_guard_clause?(node) ||
-            next_line_rescue_or_ensure?(node) ||
-            next_sibling_parent_empty_or_else?(node) ||
-            next_sibling_empty_or_guard_clause?(node)
-        end
-
-        def contains_guard_clause?(node)
-          node.if_branch&.guard_clause?
-        end
-
-        def next_line_empty_or_allowed_directive_comment?(line)
-          return true if next_line_empty?(line)
-
-          next_line = line + 1
-          next_line_allowed_directive_comment?(next_line) && next_line_empty?(next_line)
-        end
-
-        def next_line_empty?(line)
-          processed_source[line].blank?
-        end
-
-        def next_line_allowed_directive_comment?(line)
-          return false unless (comment = processed_source.comment_at_line(line))
-
-          DirectiveComment.new(comment).enabled? || simplecov_directive_comment?(comment)
-        end
-
-        def next_line_rescue_or_ensure?(node)
-          parent = node.parent
-          parent.nil? || parent.rescue_type? || parent.ensure_type?
-        end
-
-        def next_sibling_parent_empty_or_else?(node)
-          next_sibling = node.right_sibling
-          return true if next_sibling.nil?
-
-          parent = next_sibling.parent
-
-          parent&.if_type? && parent.else?
-        end
-
-        def next_sibling_empty_or_guard_clause?(node)
-          next_sibling = node.right_sibling
-          return true if next_sibling.nil?
-
-          next_sibling.if_type? && contains_guard_clause?(next_sibling)
-        end
-
-        def last_heredoc_argument(node)
-          n = last_heredoc_argument_node(node)
-
-          return n if heredoc?(n)
-          return unless n.respond_to?(:arguments)
-
-          n.arguments.each do |argument|
-            node = last_heredoc_argument(argument)
-            return node if node
-          end
-
-          last_heredoc_argument(n.receiver) if n.respond_to?(:receiver)
-        end
-
-        def last_heredoc_argument_node(node)
-          return node unless node.respond_to?(:if_branch)
-
-          if node.if_branch.and_type?
-            node.if_branch.children.first
-          elsif use_heredoc_in_condition?(node.condition)
-            node.condition
-          else
-            node.if_branch.children.last
-          end
-        end
-
-        def heredoc_line(node, heredoc_node)
-          heredoc_body = heredoc_node.loc.heredoc_body
-          num_of_heredoc_lines = heredoc_body.last_line - heredoc_body.first_line
-
-          node.last_line + num_of_heredoc_lines + END_OF_HEREDOC_LINE
-        end
-
-        def heredoc?(node)
-          node.respond_to?(:heredoc?) && node.heredoc?
-        end
-
-        def use_heredoc_in_condition?(condition)
-          condition.descendants.any? do |descendant|
-            descendant.respond_to?(:heredoc?) && descendant.heredoc?
-          end
-        end
-
-        def offense_location(node)
-          if node.loc?(:end)
-            node.loc.end
-          else
-            node
-          end
-        end
-
-        def multiple_statements_on_line?(node)
-          parent = node.parent
-          return false unless parent
-
-          parent.begin_type? && same_line?(node, node.right_sibling)
-        end
-
-        # SimpleCov excludes code from the coverage report by wrapping it in `# :nocov:`:
-        # https://github.com/simplecov-ruby/simplecov#ignoringskipping-code
-        def simplecov_directive_comment?(comment)
-          SIMPLE_DIRECTIVE_COMMENT_PATTERN.match?(comment.text)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.73.1/lib/rubocop/cop/layout/empty_line_between_defs.rb

@@ -1,293 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Layout
-      # Checks whether class/module/method definitions are
-      # separated by one or more empty lines.
-      #
-      # `NumberOfEmptyLines` can be an integer (default is 1) or
-      # an array (e.g. [1, 2]) to specify a minimum and maximum
-      # number of empty lines permitted.
-      #
-      # `AllowAdjacentOneLineDefs` configures whether adjacent
-      # one-line definitions are considered an offense.
-      #
-      # @example EmptyLineBetweenMethodDefs: true (default)
-      #   # checks for empty lines between method definitions.
-      #
-      #   # bad
-      #   def a
-      #   end
-      #   def b
-      #   end
-      #
-      #   # good
-      #   def a
-      #   end
-      #
-      #   def b
-      #   end
-      #
-      # @example EmptyLineBetweenClassDefs: true (default)
-      #   # checks for empty lines between class definitions.
-      #
-      #   # bad
-      #   class A
-      #   end
-      #   class B
-      #   end
-      #   def b
-      #   end
-      #
-      #   # good
-      #   class A
-      #   end
-      #
-      #   class B
-      #   end
-      #
-      #   def b
-      #   end
-      #
-      # @example EmptyLineBetweenModuleDefs: true (default)
-      #   # checks for empty lines between module definitions.
-      #
-      #   # bad
-      #   module A
-      #   end
-      #   module B
-      #   end
-      #   def b
-      #   end
-      #
-      #   # good
-      #   module A
-      #   end
-      #
-      #   module B
-      #   end
-      #
-      #   def b
-      #   end
-      #
-      # @example AllowAdjacentOneLineDefs: true (default)
-      #
-      #   # good
-      #   class ErrorA < BaseError; end
-      #   class ErrorB < BaseError; end
-      #   class ErrorC < BaseError; end
-      #
-      #   # good
-      #   class ErrorA < BaseError; end
-      #
-      #   class ErrorB < BaseError; end
-      #
-      #   class ErrorC < BaseError; end
-      #
-      # @example AllowAdjacentOneLineDefs: false
-      #
-      #   # bad
-      #   class ErrorA < BaseError; end
-      #   class ErrorB < BaseError; end
-      #   class ErrorC < BaseError; end
-      #
-      #   # good
-      #   class ErrorA < BaseError; end
-      #
-      #   class ErrorB < BaseError; end
-      #
-      #   class ErrorC < BaseError; end
-      #
-      class EmptyLineBetweenDefs < Base
-        include RangeHelp
-        extend AutoCorrector
-
-        MSG = 'Expected %<expected>s between %<type>s definitions; found %<actual>d.'
-
-        def self.autocorrect_incompatible_with
-          [Layout::EmptyLines]
-        end
-
-        # We operate on `begin` nodes, instead of using `OnMethodDef`,
-        # so that we can walk over pairs of consecutive nodes and
-        # efficiently access a node's predecessor; #prev_node ends up
-        # doing a linear scan over siblings, so we don't want to call
-        # it on each def.
-        def on_begin(node)
-          node.children.each_cons(2) do |prev, n|
-            nodes = [prev, n]
-            check_defs(nodes) if nodes.all? { |def_candidate| candidate?(def_candidate) }
-          end
-        end
-
-        def check_defs(nodes)
-          count = blank_lines_count_between(*nodes)
-
-          return if line_count_allowed?(count)
-          return if multiple_blank_lines_groups?(*nodes)
-          return if nodes.all?(&:single_line?) && cop_config['AllowAdjacentOneLineDefs']
-
-          correction_node = nodes.last
-
-          location = def_location(correction_node)
-          add_offense(location, message: message(correction_node, count: count)) do |corrector|
-            autocorrect(corrector, *nodes, count)
-          end
-        end
-
-        def autocorrect(corrector, prev_def, node, count)
-          # finds position of first newline
-          end_pos = end_loc(prev_def).end_pos
-          source_buffer = end_loc(prev_def).source_buffer
-          newline_pos = source_buffer.source.index("\n", end_pos)
-
-          # Handle the case when multiple one-liners are on the same line.
-          begin_pos = node.source_range.begin_pos
-          newline_pos = begin_pos - 1 if newline_pos > begin_pos
-
-          if count > maximum_empty_lines
-            autocorrect_remove_lines(corrector, newline_pos, count)
-          else
-            autocorrect_insert_lines(corrector, newline_pos, count)
-          end
-        end
-
-        private
-
-        def def_location(correction_node)
-          if correction_node.any_block_type?
-            correction_node.source_range.join(correction_node.children.first.source_range)
-          else
-            correction_node.loc.keyword.join(correction_node.loc.name)
-          end
-        end
-
-        def candidate?(node)
-          return false unless node
-
-          method_candidate?(node) || class_candidate?(node) || module_candidate?(node) ||
-            macro_candidate?(node)
-        end
-
-        def empty_line_between_macros
-          cop_config.fetch('DefLikeMacros', []).map(&:to_sym)
-        end
-
-        def macro_candidate?(node)
-          node.any_block_type? && node.children.first.macro? &&
-            empty_line_between_macros.include?(node.children.first.method_name)
-        end
-
-        def method_candidate?(node)
-          cop_config['EmptyLineBetweenMethodDefs'] && node.type?(:def, :defs)
-        end
-
-        def class_candidate?(node)
-          cop_config['EmptyLineBetweenClassDefs'] && node.class_type?
-        end
-
-        def module_candidate?(node)
-          cop_config['EmptyLineBetweenModuleDefs'] && node.module_type?
-        end
-
-        def message(node, count: nil)
-          type = node_type(node)
-
-          format(MSG, type: type, expected: expected_lines, actual: count)
-        end
-
-        def expected_lines
-          if allowance_range?
-            "#{minimum_empty_lines..maximum_empty_lines} empty lines"
-          else
-            lines = maximum_empty_lines == 1 ? 'line' : 'lines'
-            "#{maximum_empty_lines} empty #{lines}"
-          end
-        end
-
-        def multiple_blank_lines_groups?(first_def_node, second_def_node)
-          lines = lines_between_defs(first_def_node, second_def_node)
-          blank_start = lines.each_index.select { |i| lines[i].blank? }.max
-          non_blank_end = lines.each_index.reject { |i| lines[i].blank? }.min
-          return false if blank_start.nil? || non_blank_end.nil?
-
-          blank_start > non_blank_end
-        end
-
-        def line_count_allowed?(count)
-          (minimum_empty_lines..maximum_empty_lines).cover?(count)
-        end
-
-        def blank_lines_count_between(first_def_node, second_def_node)
-          lines_between_defs(first_def_node, second_def_node).count(&:blank?)
-        end
-
-        def minimum_empty_lines
-          Array(cop_config['NumberOfEmptyLines']).first
-        end
-
-        def maximum_empty_lines
-          Array(cop_config['NumberOfEmptyLines']).last
-        end
-
-        def lines_between_defs(first_def_node, second_def_node)
-          begin_line_num = def_end(first_def_node)
-          end_line_num = def_start(second_def_node) - 2
-          return [] if end_line_num.negative?
-
-          processed_source.lines[begin_line_num..end_line_num]
-        end
-
-        def def_start(node)
-          if node.any_block_type? && node.children.first.send_type?
-            node.source_range.line
-          else
-            node.loc.keyword.line
-          end
-        end
-
-        def def_end(node)
-          end_loc(node).line
-        end
-
-        def end_loc(node)
-          if node.type?(:def, :defs) && node.endless?
-            node.source_range.end
-          else
-            node.loc.end
-          end
-        end
-
-        def autocorrect_remove_lines(corrector, newline_pos, count)
-          difference = count - maximum_empty_lines
-          range_to_remove = range_between(newline_pos, newline_pos + difference)
-
-          corrector.remove(range_to_remove)
-        end
-
-        def autocorrect_insert_lines(corrector, newline_pos, count)
-          difference = minimum_empty_lines - count
-          where_to_insert = range_between(newline_pos, newline_pos + 1)
-
-          corrector.insert_after(where_to_insert, "\n" * difference)
-        end
-
-        def node_type(node)
-          case node.type
-          when :def, :defs
-            :method
-          when :numblock
-            :block
-          else
-            node.type
-          end
-        end
-
-        def allowance_range?
-          minimum_empty_lines != maximum_empty_lines
-        end
-      end
-    end
-  end
-end