siteimprove_api_client 1.0.2 → 1.0.3

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.76.2/lib/rubocop/cop/lint/useless_access_modifier.rb

@@ -0,0 +1,313 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for redundant access modifiers, including those with no
+      # code, those which are repeated, those which are on top-level, and
+      # leading `public` modifiers in a class or module body.
+      # Conditionally-defined methods are considered as always being defined,
+      # and thus access modifiers guarding such methods are not redundant.
+      #
+      # This cop has `ContextCreatingMethods` option. The default setting value
+      # is an empty array that means no method is specified.
+      # This setting is an array of methods which, when called, are known to
+      # create its own context in the module's current access context.
+      #
+      # It also has `MethodCreatingMethods` option. The default setting value
+      # is an empty array that means no method is specified.
+      # This setting is an array of methods which, when called, are known to
+      # create other methods in the module's current access context.
+      #
+      # @example
+      #   # bad
+      #   class Foo
+      #     public # this is redundant (default access is public)
+      #
+      #     def method
+      #     end
+      #   end
+      #
+      #   # bad
+      #   class Foo
+      #     # The following is redundant (methods defined on the class'
+      #     # singleton class are not affected by the private modifier)
+      #     private
+      #
+      #     def self.method3
+      #     end
+      #   end
+      #
+      #   # bad
+      #   class Foo
+      #     protected
+      #
+      #     define_method(:method2) do
+      #     end
+      #
+      #     protected # this is redundant (repeated from previous modifier)
+      #
+      #     [1,2,3].each do |i|
+      #       define_method("foo#{i}") do
+      #       end
+      #     end
+      #   end
+      #
+      #   # bad
+      #   class Foo
+      #     private # this is redundant (no following methods are defined)
+      #   end
+      #
+      #   # bad
+      #   private # this is useless (access modifiers have no effect on top-level)
+      #
+      #   def method
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     private # this is not redundant (a method is defined)
+      #
+      #     def method2
+      #     end
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     # The following is not redundant (conditionally defined methods are
+      #     # considered as always defining a method)
+      #     private
+      #
+      #     if condition?
+      #       def method
+      #       end
+      #     end
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     protected # this is not redundant (a method is defined)
+      #
+      #     define_method(:method2) do
+      #     end
+      #   end
+      #
+      # @example ContextCreatingMethods: concerning
+      #   # Lint/UselessAccessModifier:
+      #   #   ContextCreatingMethods:
+      #   #     - concerning
+      #
+      #   # good
+      #   require 'active_support/concern'
+      #   class Foo
+      #     concerning :Bar do
+      #       def some_public_method
+      #       end
+      #
+      #       private
+      #
+      #       def some_private_method
+      #       end
+      #     end
+      #
+      #     # this is not redundant because `concerning` created its own context
+      #     private
+      #
+      #     def some_other_private_method
+      #     end
+      #   end
+      #
+      # @example MethodCreatingMethods: delegate
+      #   # Lint/UselessAccessModifier:
+      #   #   MethodCreatingMethods:
+      #   #     - delegate
+      #
+      #   # good
+      #   require 'active_support/core_ext/module/delegation'
+      #   class Foo
+      #     # this is not redundant because `delegate` creates methods
+      #     private
+      #
+      #     delegate :method_a, to: :method_b
+      #   end
+      class UselessAccessModifier < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Useless `%<current>s` access modifier.'
+
+        def on_class(node)
+          check_node(node.body)
+        end
+        alias on_module on_class
+        alias on_sclass on_class
+
+        def on_block(node)
+          return unless eval_call?(node) || included_block?(node)
+
+          check_node(node.body)
+        end
+
+        alias on_numblock on_block
+        alias on_itblock on_block
+
+        def on_begin(node)
+          return if node.parent
+
+          node.child_nodes.each do |child|
+            next unless child.send_type? && access_modifier?(child)
+
+            # This call always registers an offense for access modifier `child.method_name`
+            check_send_node(child, child.method_name, true)
+          end
+        end
+
+        private
+
+        def autocorrect(corrector, node)
+          range = range_by_whole_lines(node.source_range, include_final_newline: true)
+
+          corrector.remove(range)
+        end
+
+        # @!method static_method_definition?(node)
+        def_node_matcher :static_method_definition?, <<~PATTERN
+          {def (send nil? {:attr :attr_reader :attr_writer :attr_accessor} ...)}
+        PATTERN
+
+        # @!method dynamic_method_definition?(node)
+        def_node_matcher :dynamic_method_definition?, <<~PATTERN
+          {(send nil? :define_method ...) (any_block (send nil? :define_method ...) ...)}
+        PATTERN
+
+        # @!method class_or_instance_eval?(node)
+        def_node_matcher :class_or_instance_eval?, <<~PATTERN
+          (any_block (send _ {:class_eval :instance_eval}) ...)
+        PATTERN
+
+        def check_node(node)
+          return if node.nil?
+
+          if node.begin_type?
+            check_scope(node)
+          elsif node.send_type? && node.bare_access_modifier?
+            add_offense(node, message: format(MSG, current: node.method_name)) do |corrector|
+              autocorrect(corrector, node)
+            end
+          end
+        end
+
+        def access_modifier?(node)
+          node.bare_access_modifier? || node.method?(:private_class_method)
+        end
+
+        def check_scope(node)
+          cur_vis, unused = check_child_nodes(node, nil, :public)
+          return unless unused
+
+          add_offense(unused, message: format(MSG, current: cur_vis)) do |corrector|
+            autocorrect(corrector, unused)
+          end
+        end
+
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def check_child_nodes(node, unused, cur_vis)
+          node.child_nodes.each do |child|
+            if child.send_type? && access_modifier?(child)
+              cur_vis, unused = check_send_node(child, cur_vis, unused)
+            elsif child.block_type? && included_block?(child)
+              next
+            elsif method_definition?(child)
+              unused = nil
+            elsif start_of_new_scope?(child)
+              check_scope(child)
+            elsif !child.defs_type?
+              cur_vis, unused = check_child_nodes(child, unused, cur_vis)
+            end
+          end
+
+          [cur_vis, unused]
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+        def check_send_node(node, cur_vis, unused)
+          if node.bare_access_modifier?
+            check_new_visibility(node, unused, node.method_name, cur_vis)
+          elsif node.method?(:private_class_method) && !node.arguments?
+            add_offense(node, message: format(MSG, current: node.method_name)) do |corrector|
+              autocorrect(corrector, node)
+            end
+            [cur_vis, unused]
+          end
+        end
+
+        def check_new_visibility(node, unused, new_vis, cur_vis)
+          # does this modifier just repeat the existing visibility?
+          if new_vis == cur_vis
+            add_offense(node, message: format(MSG, current: cur_vis)) do |corrector|
+              autocorrect(corrector, node)
+            end
+          else
+            # was the previous modifier never applied to any defs?
+            if unused
+              add_offense(unused, message: format(MSG, current: cur_vis)) do |corrector|
+                autocorrect(corrector, unused)
+              end
+            end
+            # once we have already warned about a certain modifier, don't
+            # warn again even if it is never applied to any method defs
+            unused = node
+          end
+
+          [new_vis, unused]
+        end
+
+        def included_block?(block_node)
+          active_support_extensions_enabled? && block_node.method?(:included)
+        end
+
+        def method_definition?(child)
+          static_method_definition?(child) ||
+            dynamic_method_definition?(child) ||
+            any_method_definition?(child)
+        end
+
+        def any_method_definition?(child)
+          cop_config.fetch('MethodCreatingMethods', []).any? do |m|
+            matcher_name = :"#{m}_method?"
+            unless respond_to?(matcher_name)
+              self.class.def_node_matcher matcher_name, <<~PATTERN
+                {def (send nil? :#{m} ...)}
+              PATTERN
+            end
+
+            public_send(matcher_name, child)
+          end
+        end
+
+        def start_of_new_scope?(child)
+          child.type?(:module, :class, :sclass) || eval_call?(child)
+        end
+
+        def eval_call?(child)
+          class_or_instance_eval?(child) ||
+            child.class_constructor? ||
+            any_context_creating_methods?(child)
+        end
+
+        def any_context_creating_methods?(child)
+          cop_config.fetch('ContextCreatingMethods', []).any? do |m|
+            matcher_name = :"#{m}_block?"
+            unless respond_to?(matcher_name)
+              self.class.def_node_matcher matcher_name, <<~PATTERN
+                (any_block (send {nil? const} {:#{m}} ...) ...)
+              PATTERN
+            end
+
+            public_send(matcher_name, child)
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.76.2/lib/rubocop/cop/lint/useless_default_value_argument.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for usage of method `fetch` or `Array.new` with default value argument
+      # and block. In such cases, block will always be used as default value.
+      #
+      # This cop emulates Ruby warning "block supersedes default value argument" which
+      # applies to `Array.new`, `Array#fetch`, `Hash#fetch`, `ENV.fetch` and
+      # `Thread#fetch`.
+      #
+      # A `fetch` call without a receiver is considered a custom method and does not register
+      # an offense.
+      #
+      # @safety
+      #   This cop is unsafe because the receiver could have nonstandard implementation
+      #   of `fetch`, or be a class other than the one listed above.
+      #
+      #   It is also unsafe because default value argument could have side effects:
+      #
+      #   [source,ruby]
+      #   ----
+      #   def x(a) = puts "side effect"
+      #   Array.new(5, x(1)) { 2 }
+      #   ----
+      #
+      #   so removing it would change behavior.
+      #
+      # @example
+      #   # bad
+      #   x.fetch(key, default_value) { block_value }
+      #   Array.new(size, default_value) { block_value }
+      #
+      #   # good
+      #   x.fetch(key) { block_value }
+      #   Array.new(size) { block_value }
+      #
+      #   # also good - in case default value argument is desired instead
+      #   x.fetch(key, default_value)
+      #   Array.new(size, default_value)
+      #
+      #   # good - keyword arguments aren't registered as offenses
+      #   x.fetch(key, keyword: :arg) { block_value }
+      #
+      # @example AllowedReceivers: ['Rails.cache']
+      #   # good
+      #   Rails.cache.fetch(name, options) { block }
+      #
+      class UselessDefaultValueArgument < Base
+        include AllowedReceivers
+        extend AutoCorrector
+
+        MSG = 'Block supersedes default value argument.'
+
+        RESTRICT_ON_SEND = %i[fetch new].freeze
+
+        # @!method default_value_argument_and_block(node)
+        def_node_matcher :default_value_argument_and_block, <<~PATTERN
+          (any_block
+            {
+              (call !nil? :fetch $_key $_default_value)
+              (send (const _ :Array) :new $_size $_default_value)
+            }
+            _args
+            _block_body)
+        PATTERN
+
+        def on_send(node)
+          unless (prev_arg_node, default_value_node = default_value_argument_and_block(node.parent))
+            return
+          end
+          return if allowed_receiver?(node.receiver)
+          return if hash_without_braces?(default_value_node)
+
+          add_offense(default_value_node) do |corrector|
+            corrector.remove(prev_arg_node.source_range.end.join(default_value_node.source_range))
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def hash_without_braces?(node)
+          node.hash_type? && !node.braces?
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.76.2/lib/rubocop/cop/lint/useless_or.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for useless OR (`||` and `or`) expressions.
+      #
+      # Some methods always return a truthy value, even when called
+      # on `nil` (e.g. `nil.to_i` evaluates to `0`). Therefore, OR expressions
+      # appended after these methods will never evaluate.
+      #
+      # @example
+      #
+      #   # bad
+      #   x.to_a || fallback
+      #   x.to_c || fallback
+      #   x.to_d || fallback
+      #   x.to_i || fallback
+      #   x.to_f || fallback
+      #   x.to_h || fallback
+      #   x.to_r || fallback
+      #   x.to_s || fallback
+      #   x.to_sym || fallback
+      #   x.intern || fallback
+      #   x.inspect || fallback
+      #   x.hash || fallback
+      #   x.object_id || fallback
+      #   x.__id__ || fallback
+      #
+      #   x.to_s or fallback
+      #
+      #   # good - if fallback is same as return value of method called on nil
+      #   x.to_a # nil.to_a returns []
+      #   x.to_c # nil.to_c returns (0+0i)
+      #   x.to_d # nil.to_d returns 0.0
+      #   x.to_i # nil.to_i returns 0
+      #   x.to_f # nil.to_f returns 0.0
+      #   x.to_h # nil.to_h returns {}
+      #   x.to_r # nil.to_r returns (0/1)
+      #   x.to_s # nil.to_s returns ''
+      #   x.to_sym # nil.to_sym raises an error
+      #   x.intern # nil.intern raises an error
+      #   x.inspect # nil.inspect returns "nil"
+      #   x.hash # nil.hash returns an Integer
+      #   x.object_id # nil.object_id returns an Integer
+      #   x.__id__ # nil.object_id returns an Integer
+      #
+      #   # good - if the intention is not to call the method on nil
+      #   x&.to_a || fallback
+      #   x&.to_c || fallback
+      #   x&.to_d || fallback
+      #   x&.to_i || fallback
+      #   x&.to_f || fallback
+      #   x&.to_h || fallback
+      #   x&.to_r || fallback
+      #   x&.to_s || fallback
+      #   x&.to_sym || fallback
+      #   x&.intern || fallback
+      #   x&.inspect || fallback
+      #   x&.hash || fallback
+      #   x&.object_id || fallback
+      #   x&.__id__ || fallback
+      #
+      #   x&.to_s or fallback
+      #
+      class UselessOr < Base
+        MSG = '`%<rhs>s` will never evaluate because `%<lhs>s` always returns a truthy value.'
+
+        TRUTHY_RETURN_VALUE_METHODS = Set[:to_a, :to_c, :to_d, :to_i, :to_f, :to_h, :to_r,
+                                          :to_s, :to_sym, :intern, :inspect, :hash, :object_id,
+                                          :__id__].freeze
+
+        # @!method truthy_return_value_method?(node)
+        def_node_matcher :truthy_return_value_method?, <<~PATTERN
+          (send _ %TRUTHY_RETURN_VALUE_METHODS)
+        PATTERN
+
+        def on_or(node)
+          if truthy_return_value_method?(node.lhs)
+            report_offense(node, node.lhs)
+          elsif truthy_return_value_method?(node.rhs)
+            parent = node.parent
+            parent = parent.parent if parent&.begin_type?
+
+            report_offense(parent, node.rhs) if parent&.or_type?
+          end
+        end
+
+        private
+
+        def report_offense(or_node, truthy_node)
+          add_offense(or_node.loc.operator.join(or_node.rhs.source_range),
+                      message: format(MSG, lhs: truthy_node.source, rhs: or_node.rhs.source))
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.76.2/lib/rubocop/cop/metrics/abc_size.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Metrics
+      # Checks that the ABC size of methods is not higher than the
+      # configured maximum. The ABC size is based on assignments, branches
+      # (method calls), and conditions. See http://c2.com/cgi/wiki?AbcMetric
+      # and https://en.wikipedia.org/wiki/ABC_Software_Metric.
+      #
+      # Interpreting ABC size:
+      #
+      # * ``<= 17`` satisfactory
+      # * `18..30` unsatisfactory
+      # * `>` 30 dangerous
+      #
+      # You can have repeated "attributes" calls count as a single "branch".
+      # For this purpose, attributes are any method with no argument; no attempt
+      # is meant to distinguish actual `attr_reader` from other methods.
+      #
+      # @example CountRepeatedAttributes: false (default is true)
+      #
+      #    # `model` and `current_user`, referenced 3 times each,
+      #    # are each counted as only 1 branch each if
+      #    # `CountRepeatedAttributes` is set to 'false'
+      #
+      #    def search
+      #      @posts = model.active.visible_by(current_user)
+      #                .search(params[:q])
+      #      @posts = model.some_process(@posts, current_user)
+      #      @posts = model.another_process(@posts, current_user)
+      #
+      #      render 'pages/search/page'
+      #    end
+      #
+      # This cop also takes into account `AllowedMethods` (defaults to `[]`)
+      # And `AllowedPatterns` (defaults to `[]`)
+      #
+      class AbcSize < Base
+        include MethodComplexity
+
+        MSG = 'Assignment Branch Condition size for `%<method>s` is too high. ' \
+              '[%<abc_vector>s %<complexity>.4g/%<max>.4g]'
+
+        private
+
+        def complexity(node)
+          Utils::AbcSizeCalculator.calculate(
+            node,
+            discount_repeated_attributes: !cop_config['CountRepeatedAttributes']
+          )
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.76.2/lib/rubocop/cop/mixin/frozen_string_literal.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for dealing with frozen string literals.
+    module FrozenStringLiteral
+      module_function
+
+      FROZEN_STRING_LITERAL_ENABLED = '# frozen_string_literal: true'
+      FROZEN_STRING_LITERAL_TYPES_RUBY27 = %i[str dstr].freeze
+
+      private_constant :FROZEN_STRING_LITERAL_TYPES_RUBY27
+
+      def frozen_string_literal_comment_exists?
+        leading_comment_lines.any? { |line| MagicComment.parse(line).valid_literal_value? }
+      end
+
+      private
+
+      def frozen_string_literal?(node)
+        frozen_string = if target_ruby_version >= 3.0
+                          uninterpolated_string?(node) || uninterpolated_heredoc?(node)
+                        else
+                          FROZEN_STRING_LITERAL_TYPES_RUBY27.include?(node.type)
+                        end
+
+        frozen_string && frozen_string_literals_enabled?
+      end
+
+      def uninterpolated_string?(node)
+        node.str_type? || (
+          node.dstr_type? && node.each_descendant(:begin, :ivar, :cvar, :gvar).none?
+        )
+      end
+
+      def uninterpolated_heredoc?(node)
+        return false unless node.dstr_type? && node.heredoc?
+
+        node.children.all?(&:str_type?)
+      end
+      alias frozen_heredoc? uninterpolated_heredoc?
+
+      def frozen_string_literals_enabled?
+        ruby_version = processed_source.ruby_version
+        return false unless ruby_version
+
+        # Check if a magic string literal comment specifies what to do
+        magic_comments = leading_comment_lines.filter_map { |line| MagicComment.parse(line) }
+        if (literal_magic_comment = magic_comments.find(&:frozen_string_literal_specified?))
+          return literal_magic_comment.frozen_string_literal?
+        end
+
+        # TODO: Ruby officially abandon making frozen string literals default
+        # for Ruby 3.0.
+        # https://bugs.ruby-lang.org/issues/11473#note-53
+        # Whether frozen string literals will be the default after Ruby 4.0
+        # or not is still unclear as of July 2024.
+        # It may be necessary to add this code in the future.
+        #
+        #   return ruby_version >= 4.0 if string_literals_frozen_by_default?.nil?
+        #
+        # And the above `ruby_version >= 4.0` is undecided whether it will be
+        # Ruby 4.0 or others.
+        # See https://bugs.ruby-lang.org/issues/20205 for details.
+        # For now, offer a configuration value to override behavior is using RUBYOPT.
+        return false if string_literals_frozen_by_default?.nil?
+
+        string_literals_frozen_by_default?
+      end
+
+      def frozen_string_literals_disabled?
+        leading_comment_lines.any? do |line|
+          MagicComment.parse(line).frozen_string_literal == false
+        end
+      end
+
+      def frozen_string_literal_specified?
+        leading_comment_lines.any? do |line|
+          MagicComment.parse(line).frozen_string_literal_specified?
+        end
+      end
+
+      def leading_magic_comments
+        leading_comment_lines.map { |line| MagicComment.parse(line) }
+      end
+
+      def leading_comment_lines
+        first_non_comment_token = processed_source.tokens.find { |token| !token.comment? }
+
+        if first_non_comment_token
+          # `line` is 1-indexed so we need to subtract 1 to get the array index
+          processed_source.lines[0...(first_non_comment_token.line - 1)]
+        else
+          processed_source.lines
+        end
+      end
+    end
+  end
+end