lightning_ui_kit 0.3.5 → 0.4.1

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

@@ -1,342 +0,0 @@
-# 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: ['nonzero?'] (default)
-      #   # 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)
-        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.82.1/lib/rubocop/cop/team.rb

@@ -1,290 +0,0 @@
-# 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 true if processed_source.comment_config.cop_opted_in?(cop)
-          next false if cop.excluded_file?(processed_source.file_path)
-          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 offset.positive?
-              corrector.import!(to_merge, offset: offset)
-            else
-              corrector.merge!(to_merge)
-            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