lightning_ui_kit 0.3.5 → 0.4.0

data/vendor/bundle/ruby/3.4.0/gems/rubocop-1.84.2/lib/rubocop/cop/style/redundant_condition.rb

@@ -0,0 +1,345 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for unnecessary conditional expressions.
+      #
+      # NOTE: Since the intention of the comment cannot be automatically determined,
+      # autocorrection is not applied when a comment is used, as shown below:
+      #
+      # [source,ruby]
+      # -----
+      # if b
+      #   # Important note.
+      #   b
+      # else
+      #   c
+      # end
+      # -----
+      #
+      # @example
+      #   # bad
+      #   a = b ? b : c
+      #
+      #   # good
+      #   a = b || c
+      #
+      #   # bad
+      #   if b
+      #     b
+      #   else
+      #     c
+      #   end
+      #
+      #   # good
+      #   b || c
+      #
+      #   # good
+      #   if b
+      #     b
+      #   elsif cond
+      #     c
+      #   end
+      #
+      #   # bad
+      #   a.nil? ? true : a
+      #
+      #   # good
+      #   a.nil? || a
+      #
+      #   # bad
+      #   if a.nil?
+      #     true
+      #   else
+      #     a
+      #   end
+      #
+      #   # good
+      #   a.nil? || a
+      #
+      # @example AllowedMethods: ['infinite?', 'nonzero?'] (default)
+      #   # good
+      #   num.infinite? ? true : false
+      #
+      #   # good
+      #   num.nonzero? ? true : false
+      #
+      class RedundantCondition < Base
+        include AllowedMethods
+        include CommentsHelp
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Use double pipes `||` instead.'
+        REDUNDANT_CONDITION = 'This condition is not needed.'
+        ARGUMENT_WITH_OPERATOR_TYPES = %i[
+          splat block_pass forwarded_restarg forwarded_kwrestarg forwarded_args
+        ].freeze
+
+        def on_if(node)
+          return if node.modifier_form? || node.elsif_conditional? || !offense?(node)
+
+          message = message(node)
+
+          add_offense(range_of_offense(node), message: message) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        private
+
+        def message(node)
+          if redundant_condition?(node)
+            REDUNDANT_CONDITION
+          else
+            MSG
+          end
+        end
+
+        def autocorrect(corrector, node)
+          return if node.each_descendant.any? { |descendant| contains_comments?(descendant) }
+
+          if node.ternary? && !branches_have_method?(node)
+            correct_ternary(corrector, node)
+          elsif redundant_condition?(node)
+            corrector.replace(node, node.if_branch.source)
+          else
+            corrected = make_ternary_form(node)
+
+            corrector.replace(node, corrected)
+          end
+        end
+
+        def range_of_offense(node)
+          return node.source_range unless node.ternary?
+          return node.source_range if node.ternary? && branches_have_method?(node)
+
+          range_between(node.loc.question.begin_pos, node.loc.colon.end_pos)
+        end
+
+        def offense?(node)
+          _condition, _if_branch, else_branch = *node # rubocop:disable InternalAffairs/NodeDestructuring
+          return false if use_if_branch?(else_branch) || use_hash_key_assignment?(else_branch)
+
+          synonymous_condition_and_branch?(node) && !node.elsif? &&
+            (node.ternary? || !else_branch.instance_of?(AST::Node) || else_branch.single_line?)
+        end
+
+        def redundant_condition?(node)
+          node.modifier_form? || !node.else_branch
+        end
+
+        def use_if_branch?(else_branch)
+          else_branch&.if_type?
+        end
+
+        def use_hash_key_assignment?(else_branch)
+          else_branch&.send_type? && else_branch.method?(:[]=)
+        end
+
+        def use_hash_key_access?(node)
+          node.send_type? && node.method?(:[])
+        end
+
+        def synonymous_condition_and_branch?(node)
+          condition, if_branch, _else_branch = *node # rubocop:disable InternalAffairs/NodeDestructuring
+          # e.g.
+          #   if var
+          #     var
+          #   else
+          #     'foo'
+          #   end
+          return true if condition == if_branch
+
+          # e.g.
+          #   a.nil? ? true : a
+          # or
+          #   if a.nil?
+          #     true
+          #   else
+          #     a
+          #   end
+          return true if if_branch_is_true_type_and_else_is_not?(node)
+
+          # e.g.
+          #   if foo
+          #     @value = foo
+          #   else
+          #     @value = another_value?
+          #   end
+          return true if branches_have_assignment?(node) && condition == if_branch.expression
+
+          # e.g.
+          #   if foo
+          #     test.value = foo
+          #   else
+          #     test.value = another_value?
+          #   end
+          branches_have_method?(node) && condition == if_branch.first_argument &&
+            !use_hash_key_access?(if_branch)
+        end
+
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def if_branch_is_true_type_and_else_is_not?(node)
+          return false unless node.ternary? || node.if?
+
+          cond = node.condition
+          return false unless cond.call_type?
+          return false if !cond.predicate_method? || allowed_method?(cond.method_name)
+
+          node.if_branch&.true_type? && node.else_branch && !node.else_branch.true_type?
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+        def branches_have_assignment?(node)
+          _condition, if_branch, else_branch = *node # rubocop:disable InternalAffairs/NodeDestructuring
+
+          return false unless if_branch && else_branch
+
+          asgn_type?(if_branch) && (if_branch_variable_name = if_branch.name) &&
+            asgn_type?(else_branch) && (else_branch_variable_name = else_branch.name) &&
+            if_branch_variable_name == else_branch_variable_name
+        end
+
+        def asgn_type?(node)
+          node.type?(:lvasgn, :ivasgn, :cvasgn, :gvasgn, :casgn)
+        end
+
+        def branches_have_method?(node)
+          return false unless node.if_branch && node.else_branch
+
+          single_argument_method?(node.if_branch) && single_argument_method?(node.else_branch) &&
+            same_method?(node.if_branch, node.else_branch)
+        end
+
+        def single_argument_method?(node)
+          return false if !node.send_type? || node.method?(:[]) || !node.arguments.one?
+
+          !argument_with_operator?(node.first_argument)
+        end
+
+        def same_method?(if_branch, else_branch)
+          if_branch.method?(else_branch.method_name) && if_branch.receiver == else_branch.receiver
+        end
+
+        # If the argument is using an operator, it is an invalid syntax.
+        # e.g. `foo || *bar`, `foo || **bar`, and `foo || &bar`.
+        def argument_with_operator?(argument)
+          return true if ARGUMENT_WITH_OPERATOR_TYPES.include?(argument.type)
+          return false unless argument.hash_type?
+          return false unless (node = argument.children.first)
+
+          node.type?(:kwsplat, :forwarded_kwrestarg)
+        end
+
+        def wrap_arguments_with_parens(condition)
+          method = condition.source_range.begin.join(condition.loc.selector.end)
+          arguments = condition.first_argument.source_range.begin.join(condition.source_range.end)
+
+          "#{method.source}(#{arguments.source})"
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        def if_source(if_branch, arithmetic_operation)
+          if branches_have_method?(if_branch.parent) && if_branch.parenthesized?
+            if_branch.source.delete_suffix(')')
+          elsif arithmetic_operation
+            argument_source = if_branch.first_argument.source
+
+            "#{if_branch.receiver.source} #{if_branch.method_name} (#{argument_source}"
+          elsif if_branch.true_type?
+            condition = if_branch.parent.condition
+            return condition.source if condition.arguments.empty? || condition.parenthesized?
+
+            wrap_arguments_with_parens(condition)
+          else
+            if_branch.source
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        def else_source(else_branch, arithmetic_operation) # rubocop:disable Metrics/AbcSize
+          if arithmetic_operation
+            "#{else_branch.first_argument.source})"
+          elsif branches_have_method?(else_branch.parent)
+            else_source_if_has_method(else_branch)
+          elsif require_parentheses?(else_branch)
+            "(#{else_branch.source})"
+          elsif without_argument_parentheses_method?(else_branch)
+            "#{else_branch.method_name}(#{else_branch.arguments.map(&:source).join(', ')})"
+          elsif branches_have_assignment?(else_branch.parent)
+            else_source_if_has_assignment(else_branch)
+          else
+            else_branch.source
+          end
+        end
+
+        def else_source_if_has_method(else_branch)
+          if require_parentheses?(else_branch.first_argument)
+            "(#{else_branch.first_argument.source})"
+          elsif require_braces?(else_branch.first_argument)
+            "{ #{else_branch.first_argument.source} }"
+          else
+            else_branch.first_argument.source
+          end
+        end
+
+        def else_source_if_has_assignment(else_branch)
+          if require_parentheses?(else_branch.expression)
+            "(#{else_branch.expression.source})"
+          elsif require_braces?(else_branch.expression)
+            "{ #{else_branch.expression.source} }"
+          else
+            else_branch.expression.source
+          end
+        end
+
+        def make_ternary_form(node)
+          _condition, if_branch, else_branch = *node # rubocop:disable InternalAffairs/NodeDestructuring
+          arithmetic_operation = use_arithmetic_operation?(if_branch)
+
+          ternary_form = [
+            if_source(if_branch, arithmetic_operation),
+            else_source(else_branch, arithmetic_operation)
+          ].join(' || ')
+          ternary_form += ')' if branches_have_method?(node) && if_branch.parenthesized?
+
+          if node.parent&.send_type?
+            "(#{ternary_form})"
+          else
+            ternary_form
+          end
+        end
+
+        def correct_ternary(corrector, node)
+          corrector.replace(range_of_offense(node), '||')
+
+          return unless node.else_branch.range_type?
+
+          corrector.wrap(node.else_branch, '(', ')')
+        end
+
+        def require_parentheses?(node)
+          (node.basic_conditional? && node.modifier_form?) ||
+            node.range_type? ||
+            node.rescue_type? ||
+            (node.respond_to?(:semantic_operator?) && node.semantic_operator?)
+        end
+
+        def require_braces?(node)
+          node.hash_type? && !node.braces?
+        end
+
+        def use_arithmetic_operation?(node)
+          node.respond_to?(:arithmetic_operation?) && node.arithmetic_operation?
+        end
+
+        def without_argument_parentheses_method?(node)
+          node.send_type? && !node.arguments.empty? &&
+            !node.parenthesized? && !node.operator_method? && !node.assignment_method?
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/rubocop-1.84.2/lib/rubocop/cop/style/reverse_find.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Identifies places where `array.reverse.find` can be replaced by `array.rfind`.
+      #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the receiver
+      #   is an `Array` or responds to the replacement method.
+      #
+      # @example
+      #   # bad
+      #   array.reverse.find { |item| item.even? }
+      #   array.reverse.detect { |item| item.even? }
+      #   array.reverse_each.find { |item| item.even? }
+      #   array.reverse_each.detect { |item| item.even? }
+      #
+      #   # good
+      #   array.rfind { |item| item.even? }
+      #
+      class ReverseFind < Base
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        MSG = 'Use `rfind` instead.'
+        RESTRICT_ON_SEND = %i[find detect].freeze
+
+        minimum_target_ruby_version 4.0
+
+        # @!method reverse_find?(node)
+        def_node_matcher :reverse_find?, <<~PATTERN
+          (call
+            (call
+              _ {:reverse :reverse_each}) {:find :detect} (block_pass sym)?)
+        PATTERN
+
+        def on_send(node)
+          return unless reverse_find?(node)
+
+          range = node.children.first.loc.selector.join(node.loc.selector)
+
+          add_offense(range) do |corrector|
+            corrector.replace(range, 'rfind')
+          end
+        end
+        alias on_csend on_send
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/rubocop-1.84.2/lib/rubocop/cop/team.rb

@@ -0,0 +1,290 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # A group of cops, ready to be called on duty to inspect files.
+    # Team is responsible for selecting only relevant cops to be sent on duty,
+    # as well as insuring that the needed forces are sent along with them.
+    #
+    # For performance reasons, Team will first dispatch cops & forces in two groups,
+    # first the ones needed for autocorrection (if any), then the rest
+    # (unless autocorrections happened).
+    # rubocop:disable Metrics/ClassLength
+    class Team
+      # @return [Team]
+      def self.new(cop_or_classes, config, options = {})
+        # Support v0 api:
+        if cop_or_classes.first.is_a?(Class)
+          warn Rainbow(<<~WARNING).yellow, uplevel: 1
+            `Team.new` with cop classes is deprecated. Use `Team.mobilize` instead.
+          WARNING
+          return mobilize(cop_or_classes, config, options)
+        end
+
+        super
+      end
+
+      # @return [Team] with cops assembled from the given `cop_classes`
+      def self.mobilize(cop_classes, config, options = {})
+        cops = mobilize_cops(cop_classes, config, options)
+        new(cops, config, options)
+      end
+
+      # @return [Array<Cop::Base>]
+      def self.mobilize_cops(cop_classes, config, options = {})
+        cop_classes = Registry.new(cop_classes.to_a, options) unless cop_classes.is_a?(Registry)
+
+        cop_classes.map do |cop_class|
+          cop_class.new(config, options)
+        end
+      end
+
+      # @return [Array<Force>] needed for the given cops
+      def self.forces_for(cops)
+        needed = Hash.new { |h, k| h[k] = [] }
+        cops.each do |cop|
+          forces = cop.class.joining_forces
+          if forces.is_a?(Array)
+            forces.each { |force| needed[force] << cop }
+          elsif forces
+            needed[forces] << cop
+          end
+        end
+
+        needed.map { |force_class, joining_cops| force_class.new(joining_cops) }
+      end
+
+      attr_reader :errors, :warnings, :updated_source_file, :cops
+
+      alias updated_source_file? updated_source_file
+
+      def initialize(cops, config = nil, options = {})
+        @cops = cops
+        @config = config
+        @options = options
+        reset
+        @ready = true
+        @registry = Registry.new(cops, options.dup)
+
+        validate_config
+      end
+
+      def autocorrect?
+        @options[:autocorrect]
+      end
+
+      def debug?
+        @options[:debug]
+      end
+
+      # @deprecated. Use investigate
+      # @return Array<offenses>
+      def inspect_file(processed_source)
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          `inspect_file` is deprecated. Use `investigate` instead.
+        WARNING
+
+        investigate(processed_source).offenses
+      end
+
+      # @return [Commissioner::InvestigationReport]
+      def investigate(processed_source, offset: 0, original: processed_source)
+        be_ready
+
+        # The autocorrection process may have to be repeated multiple times
+        # until there are no corrections left to perform
+        # To speed things up, run autocorrecting cops by themselves, and only
+        # run the other cops when no corrections are left
+        on_duty = roundup_relevant_cops(processed_source)
+
+        autocorrect_cops, other_cops = on_duty.partition(&:autocorrect?)
+        report = investigate_partial(autocorrect_cops, processed_source,
+                                     offset: offset, original: original)
+
+        unless autocorrect(processed_source, report, offset: offset, original: original)
+          # If we corrected some errors, another round of inspection will be
+          # done, and any other offenses will be caught then, so only need
+          # to check other_cops if no correction was done
+          report = report.merge(investigate_partial(other_cops, processed_source,
+                                                    offset: offset, original: original))
+        end
+
+        process_errors(processed_source.path, report.errors)
+
+        report
+      ensure
+        @ready = false
+      end
+
+      # @deprecated
+      def forces
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          `forces` is deprecated.
+        WARNING
+
+        @forces ||= self.class.forces_for(cops)
+      end
+
+      def external_dependency_checksum
+        # The external dependency checksums are cached per RuboCop team so that
+        # the checksums don't need to be recomputed for each file.
+        @external_dependency_checksum ||= begin
+          keys = cops.filter_map(&:external_dependency_checksum)
+          Digest::SHA1.hexdigest(keys.join)
+        end
+      end
+
+      private
+
+      def autocorrect(processed_source, report, original:, offset:)
+        @updated_source_file = false
+        return unless autocorrect?
+        return if report.processed_source.parser_error
+
+        new_source = autocorrect_report(report, original: original, offset: offset)
+
+        return unless new_source
+
+        if @options[:stdin]
+          # holds source read in from stdin, when --stdin option is used
+          @options[:stdin] = new_source
+        else
+          filename = processed_source.file_path
+          File.write(filename, new_source)
+        end
+        @updated_source_file = true
+      end
+
+      def be_ready
+        return if @ready
+
+        reset
+        @cops.map!(&:ready)
+        @ready = true
+      end
+
+      def reset
+        @errors = []
+        @warnings = []
+      end
+
+      # @return [Commissioner::InvestigationReport]
+      def investigate_partial(cops, processed_source, offset:, original:)
+        commissioner = Commissioner.new(cops, self.class.forces_for(cops), @options)
+        commissioner.investigate(processed_source, offset: offset, original: original)
+      end
+
+      # @return [Array<cop>]
+      def roundup_relevant_cops(processed_source)
+        cops.select do |cop|
+          next false if cop.excluded_file?(processed_source.file_path)
+          next true if processed_source.comment_config.cop_opted_in?(cop)
+          next false unless @registry.enabled?(cop, @config)
+
+          support_target_ruby_version?(cop) && support_target_rails_version?(cop)
+        end
+      end
+
+      def support_target_ruby_version?(cop)
+        return true unless cop.class.respond_to?(:support_target_ruby_version?)
+
+        cop.class.support_target_ruby_version?(cop.target_ruby_version)
+      end
+
+      def support_target_rails_version?(cop)
+        # In this case, the rails version was already checked by `#excluded_file?`
+        return true if defined?(RuboCop::Rails::TargetRailsVersion::USES_REQUIRES_GEM_API)
+
+        return true unless cop.class.respond_to?(:support_target_rails_version?)
+
+        cop.class.support_target_rails_version?(cop.target_rails_version)
+      end
+
+      def autocorrect_report(report, offset:, original:)
+        corrector = collate_corrections(report, offset: offset, original: original)
+
+        corrector.rewrite unless corrector.empty?
+      end
+
+      def collate_corrections(report, offset:, original:)
+        corrector = Corrector.new(original)
+
+        each_corrector(report) do |to_merge|
+          suppress_clobbering do
+            if corrector.source_buffer == to_merge.source_buffer
+              corrector.merge!(to_merge)
+            else
+              corrector.import!(to_merge, offset: offset)
+            end
+          end
+        end
+
+        corrector
+      end
+
+      def each_corrector(report)
+        skips = Set.new
+        report.cop_reports.each do |cop_report|
+          cop = cop_report.cop
+          corrector = cop_report.corrector
+
+          next if corrector.nil? || corrector.empty?
+          next if skips.include?(cop.class)
+
+          yield corrector
+
+          skips.merge(cop.class.autocorrect_incompatible_with)
+        end
+      end
+
+      def suppress_clobbering
+        yield
+      rescue ::Parser::ClobberingError
+        # ignore Clobbering errors
+      end
+
+      def validate_config
+        cops.each do |cop|
+          cop.validate_config if cop.respond_to?(:validate_config)
+        end
+      end
+
+      def process_errors(file, errors)
+        errors.each do |error|
+          line = ":#{error.line}" if error.line
+          column = ":#{error.column}" if error.column
+          location = "#{file}#{line}#{column}"
+          cause = error.cause
+
+          if cause.is_a?(Warning)
+            handle_warning(cause, location)
+          elsif cause.is_a?(Force::HookError)
+            handle_error(cause.cause, location, cause.joining_cop)
+          else
+            handle_error(cause, location, error.cop)
+          end
+        end
+      end
+
+      def handle_warning(error, location)
+        message = Rainbow("#{error.message} (from file: #{location})").yellow
+
+        @warnings << message
+        warn message
+        puts error.backtrace if debug?
+      end
+
+      def handle_error(error, location, cop)
+        message = Rainbow("An error occurred while #{cop.name} cop was inspecting #{location}.").red
+        @errors << message
+        warn message
+        if debug?
+          puts error.full_message
+        else
+          warn 'To see the complete backtrace run rubocop -d.'
+        end
+      end
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end