lightning_ui_kit 0.3.5 → 0.4.1

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

@@ -1,238 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    # An offense represents a style violation detected by RuboCop.
-    class Offense
-      include Comparable
-
-      # @api private
-      COMPARISON_ATTRIBUTES = %i[line column cop_name message severity].freeze
-
-      # @api public
-      #
-      # @!attribute [r] severity
-      #
-      # @return [RuboCop::Cop::Severity]
-      attr_reader :severity
-
-      # @api public
-      #
-      # @!attribute [r] location
-      #
-      # @return [Parser::Source::Range]
-      #   the location where the violation is detected.
-      #
-      # @see https://www.rubydoc.info/gems/parser/Parser/Source/Range
-      #   Parser::Source::Range
-      attr_reader :location
-
-      # @api public
-      #
-      # @!attribute [r] message
-      #
-      # @return [String]
-      #   human-readable message
-      #
-      # @example
-      #   'Line is too long. [90/80]'
-      attr_reader :message
-
-      # @api public
-      #
-      # @!attribute [r] cop_name
-      #
-      # @return [String]
-      #   the cop name as a String for which this offense is for.
-      #
-      # @example
-      #   'Layout/LineLength'
-      attr_reader :cop_name
-
-      # @api private
-      attr_reader :status
-
-      # @api public
-      #
-      # @!attribute [r] corrector
-      #
-      # @return [Corrector | nil]
-      #   the autocorrection for this offense, or `nil` when not available
-      attr_reader :corrector
-
-      PseudoSourceRange = Struct.new(:line, :column, :source_line, :begin_pos,
-                                     :end_pos) do
-        alias_method :first_line, :line
-        alias_method :last_line, :line
-        alias_method :last_column, :column
-
-        def column_range
-          column...last_column
-        end
-
-        def size
-          end_pos - begin_pos
-        end
-        alias_method :length, :size
-      end
-      private_constant :PseudoSourceRange
-
-      NO_LOCATION = PseudoSourceRange.new(1, 0, '', 0, 0).freeze
-
-      # @api private
-      def initialize(severity, location, message, cop_name, # rubocop:disable Metrics/ParameterLists
-                     status = :uncorrected, corrector = nil)
-        @severity = RuboCop::Cop::Severity.new(severity)
-        @location = location
-        @message = message.freeze
-        @cop_name = cop_name.freeze
-        @status = status
-        @corrector = corrector
-        freeze
-      end
-
-      # @api public
-      #
-      # @!attribute [r] correctable?
-      #
-      # @return [Boolean]
-      #   whether this offense can be automatically corrected via autocorrect.
-      #   This includes todo comments, for example when requested with `--disable-uncorrectable`.
-      def correctable?
-        @status != :unsupported
-      end
-
-      # @api public
-      #
-      # @!attribute [r] corrected?
-      #
-      # @return [Boolean]
-      #   whether this offense is automatically corrected via
-      #   autocorrect or a todo.
-      def corrected?
-        @status == :corrected || @status == :corrected_with_todo
-      end
-
-      # @api public
-      #
-      # @!attribute [r] corrected_with_todo?
-      #
-      # @return [Boolean]
-      #   whether this offense is automatically disabled via a todo.
-      def corrected_with_todo?
-        @status == :corrected_with_todo
-      end
-
-      # @api public
-      #
-      # @!attribute [r] disabled?
-      #
-      # @return [Boolean]
-      #   whether this offense was locally disabled with a
-      #   disable or todo where it occurred.
-      def disabled?
-        @status == :disabled || @status == :todo
-      end
-
-      # @api public
-      #
-      # @return [Parser::Source::Range]
-      #   the range of the code that is highlighted
-      def highlighted_area
-        Parser::Source::Range.new(source_line, column, column + column_length)
-      end
-
-      # @api private
-      # This is just for debugging purpose.
-      def to_s
-        format('%<severity>s:%3<line>d:%3<column>d: %<message>s',
-               severity: severity.code, line: line,
-               column: real_column, message: message)
-      end
-
-      # @api private
-      def line
-        location.line
-      end
-
-      # @api private
-      def column
-        location.column
-      end
-
-      # @api private
-      def source_line
-        location.source_line
-      end
-
-      # @api private
-      def column_length
-        if first_line == last_line
-          column_range.count
-        else
-          source_line.length - column
-        end
-      end
-
-      # @api private
-      def first_line
-        location.first_line
-      end
-
-      # @api private
-      def last_line
-        location.last_line
-      end
-
-      # @api private
-      def last_column
-        location.last_column
-      end
-
-      # @api private
-      def column_range
-        location.column_range
-      end
-
-      # @api private
-      #
-      # Internally we use column number that start at 0, but when
-      # outputting column numbers, we want them to start at 1. One
-      # reason is that editors, such as Emacs, expect this.
-      def real_column
-        column + 1
-      end
-
-      # @api public
-      #
-      # @return [Boolean]
-      #   returns `true` if two offenses contain same attributes
-      def ==(other)
-        COMPARISON_ATTRIBUTES.all? do |attribute|
-          public_send(attribute) == other.public_send(attribute)
-        end
-      end
-
-      alias eql? ==
-
-      def hash
-        COMPARISON_ATTRIBUTES.map { |attribute| public_send(attribute) }.hash
-      end
-
-      # @api public
-      #
-      # Returns `-1`, `0`, or `+1`
-      # if this offense is less than, equal to, or greater than `other`.
-      #
-      # @return [Integer]
-      #   comparison result
-      def <=>(other)
-        COMPARISON_ATTRIBUTES.each do |attribute|
-          result = public_send(attribute) <=> other.public_send(attribute)
-          return result unless result.zero?
-        end
-        0
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.4.0/gems/rubocop-1.82.1/lib/rubocop/cop/security/json_load.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Security
-      # Checks for the use of JSON class methods which have potential
-      # security issues.
-      #
-      # `JSON.load` and similar methods allow deserialization of arbitrary ruby objects:
-      #
-      # [source,ruby]
-      # ----
-      # require 'json/add/string'
-      # result = JSON.load('{ "json_class": "String", "raw": [72, 101, 108, 108, 111] }')
-      # pp result # => "Hello"
-      # ----
-      #
-      # Never use `JSON.load` for untrusted user input. Prefer `JSON.parse` unless you have
-      # a concrete use-case for `JSON.load`.
-      #
-      # NOTE: Starting with `json` gem version 2.8.0, triggering this behavior without explicitly
-      # passing the `create_additions` keyword argument emits a deprecation warning, with the
-      # goal of being secure by default in the next major version 3.0.0.
-      #
-      # @safety
-      #   This cop's autocorrection is unsafe because it's potentially dangerous.
-      #   If using a stream, like `JSON.load(open('file'))`, you will need to call
-      #   `#read` manually, like `JSON.parse(open('file').read)`.
-      #   Other similar issues may apply.
-      #
-      # @example
-      #   # bad
-      #   JSON.load('{}')
-      #   JSON.restore('{}')
-      #
-      #   # good
-      #   JSON.parse('{}')
-      #   JSON.unsafe_load('{}')
-      #
-      #   # good - explicit use of `create_additions` option
-      #   JSON.load('{}', create_additions: true)
-      #   JSON.load('{}', create_additions: false)
-      #
-      class JSONLoad < Base
-        extend AutoCorrector
-
-        MSG = 'Prefer `JSON.parse` over `JSON.%<method>s`.'
-        RESTRICT_ON_SEND = %i[load restore].freeze
-
-        # @!method insecure_json_load(node)
-        def_node_matcher :insecure_json_load, <<~PATTERN
-          (
-            send (const {nil? cbase} :JSON) ${:load :restore}
-            ...
-            !(hash `(sym $:create_additions))
-          )
-        PATTERN
-
-        def on_send(node)
-          insecure_json_load(node) do |method|
-            add_offense(node.loc.selector, message: format(MSG, method: method)) do |corrector|
-              corrector.replace(node.loc.selector, 'parse')
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,365 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # Access modifiers should be declared to apply to a group of methods
-      # or inline before each method, depending on configuration.
-      # EnforcedStyle config covers only method definitions.
-      # Applications of visibility methods to symbols can be controlled
-      # using AllowModifiersOnSymbols config.
-      # Also, the visibility of `attr*` methods can be controlled using
-      # AllowModifiersOnAttrs config.
-      #
-      # In Ruby 3.0, `attr*` methods now return an array of defined method names
-      # as symbols. So we can write the modifier and `attr*` in inline style.
-      # AllowModifiersOnAttrs config allows `attr*` methods to be written in
-      # inline style without modifying applications that have been maintained
-      # for a long time in group style. Furthermore, developers who are not very
-      # familiar with Ruby may know that the modifier applies to `def`, but they
-      # may not know that it also applies to `attr*` methods. It would be easier
-      # to understand if we could write `attr*` methods in inline style.
-      #
-      # @safety
-      #   Autocorrection is not safe, because the visibility of dynamically
-      #   defined methods can vary depending on the state determined by
-      #   the group access modifier.
-      #
-      # @example EnforcedStyle: group (default)
-      #   # bad
-      #   class Foo
-      #
-      #     private def bar; end
-      #     private def baz; end
-      #
-      #   end
-      #
-      #   # good
-      #   class Foo
-      #
-      #     private
-      #
-      #     def bar; end
-      #     def baz; end
-      #
-      #   end
-      #
-      # @example EnforcedStyle: inline
-      #   # bad
-      #   class Foo
-      #
-      #     private
-      #
-      #     def bar; end
-      #     def baz; end
-      #
-      #   end
-      #
-      #   # good
-      #   class Foo
-      #
-      #     private def bar; end
-      #     private def baz; end
-      #
-      #   end
-      #
-      # @example AllowModifiersOnSymbols: true (default)
-      #   # good
-      #   class Foo
-      #
-      #     private :bar, :baz
-      #     private *%i[qux quux]
-      #     private *METHOD_NAMES
-      #     private *private_methods
-      #
-      #   end
-      #
-      # @example AllowModifiersOnSymbols: false
-      #   # bad
-      #   class Foo
-      #
-      #     private :bar, :baz
-      #     private *%i[qux quux]
-      #     private *METHOD_NAMES
-      #     private *private_methods
-      #
-      #   end
-      #
-      # @example AllowModifiersOnAttrs: true (default)
-      #   # good
-      #   class Foo
-      #
-      #     public attr_reader :bar
-      #     protected attr_writer :baz
-      #     private attr_accessor :qux
-      #     private attr :quux
-      #
-      #     def public_method; end
-      #
-      #     private
-      #
-      #     def private_method; end
-      #
-      #   end
-      #
-      # @example AllowModifiersOnAttrs: false
-      #   # bad
-      #   class Foo
-      #
-      #     public attr_reader :bar
-      #     protected attr_writer :baz
-      #     private attr_accessor :qux
-      #     private attr :quux
-      #
-      #   end
-      #
-      # @example AllowModifiersOnAliasMethod: true (default)
-      #   # good
-      #   class Foo
-      #
-      #     public alias_method :bar, :foo
-      #     protected alias_method :baz, :foo
-      #     private alias_method :qux, :foo
-      #
-      #   end
-      #
-      # @example AllowModifiersOnAliasMethod: false
-      #   # bad
-      #   class Foo
-      #
-      #     public alias_method :bar, :foo
-      #     protected alias_method :baz, :foo
-      #     private alias_method :qux, :foo
-      #
-      #   end
-      class AccessModifierDeclarations < Base
-        extend AutoCorrector
-
-        include ConfigurableEnforcedStyle
-        include RangeHelp
-
-        GROUP_STYLE_MESSAGE = [
-          '`%<access_modifier>s` should not be',
-          'inlined in method definitions.'
-        ].join(' ')
-
-        INLINE_STYLE_MESSAGE = [
-          '`%<access_modifier>s` should be',
-          'inlined in method definitions.'
-        ].join(' ')
-
-        RESTRICT_ON_SEND = %i[private protected public module_function].freeze
-
-        # @!method access_modifier_with_symbol?(node)
-        def_node_matcher :access_modifier_with_symbol?, <<~PATTERN
-          (send nil? {:private :protected :public :module_function}
-            {(sym _)+ (splat {#percent_symbol_array? const send})}
-          )
-        PATTERN
-
-        # @!method access_modifier_with_attr?(node)
-        def_node_matcher :access_modifier_with_attr?, <<~PATTERN
-          (send nil? {:private :protected :public :module_function}
-            (send nil? {:attr :attr_reader :attr_writer :attr_accessor} _+))
-        PATTERN
-
-        # @!method access_modifier_with_alias_method?, <<~PATTERN
-        def_node_matcher :access_modifier_with_alias_method?, <<~PATTERN
-          (send nil? {:private :protected :public :module_function}
-            (send nil? :alias_method _ _))
-        PATTERN
-
-        def on_send(node)
-          return if allowed?(node)
-
-          if offense?(node)
-            add_offense(node.loc.selector) do |corrector|
-              autocorrect(corrector, node)
-            end
-            opposite_style_detected
-          else
-            correct_style_detected
-          end
-        end
-
-        private
-
-        def allowed?(node)
-          !node.access_modifier? ||
-            node.parent&.type?(:pair, :any_block) ||
-            allow_modifiers_on_symbols?(node) ||
-            allow_modifiers_on_attrs?(node) ||
-            allow_modifiers_on_alias_method?(node)
-        end
-
-        def autocorrect(corrector, node)
-          case style
-          when :group
-            autocorrect_group_style(corrector, node)
-          when :inline
-            autocorrect_inline_style(corrector, node)
-          end
-        end
-
-        def autocorrect_group_style(corrector, node)
-          def_nodes = find_corresponding_def_nodes(node)
-          return unless def_nodes.any?
-
-          replace_defs(corrector, node, def_nodes)
-        end
-
-        def autocorrect_inline_style(corrector, node)
-          if node.parent&.begin_type?
-            remove_modifier_node_within_begin(corrector, node, node.parent)
-          else
-            remove_nodes(corrector, node)
-          end
-          select_grouped_def_nodes(node).each do |grouped_def_node|
-            insert_inline_modifier(corrector, grouped_def_node, node.method_name)
-          end
-        end
-
-        def percent_symbol_array?(node)
-          node.array_type? && node.percent_literal?(:symbol)
-        end
-
-        def allow_modifiers_on_symbols?(node)
-          cop_config['AllowModifiersOnSymbols'] && access_modifier_with_symbol?(node)
-        end
-
-        def allow_modifiers_on_attrs?(node)
-          cop_config['AllowModifiersOnAttrs'] && access_modifier_with_attr?(node)
-        end
-
-        def allow_modifiers_on_alias_method?(node)
-          cop_config['AllowModifiersOnAliasMethod'] && access_modifier_with_alias_method?(node)
-        end
-
-        def offense?(node)
-          if group_style?
-            return false if node.parent ? node.parent.if_type? : access_modifier_with_symbol?(node)
-
-            access_modifier_is_inlined?(node) && !right_siblings_same_inline_method?(node)
-          else
-            access_modifier_is_not_inlined?(node) && select_grouped_def_nodes(node).any?
-          end
-        end
-
-        def correctable_group_offense?(node)
-          return false unless group_style?
-          return false if allowed?(node)
-
-          access_modifier_is_inlined?(node) && find_corresponding_def_nodes(node).any?
-        end
-
-        def group_style?
-          style == :group
-        end
-
-        def inline_style?
-          style == :inline
-        end
-
-        def access_modifier_is_inlined?(node)
-          node.arguments.any?
-        end
-
-        def access_modifier_is_not_inlined?(node)
-          !access_modifier_is_inlined?(node)
-        end
-
-        def right_siblings_same_inline_method?(node)
-          node.right_siblings.any? do |sibling|
-            sibling.send_type? &&
-              correctable_group_offense?(sibling) &&
-              sibling.method?(node.method_name) &&
-              !sibling.arguments.empty? &&
-              find_corresponding_def_nodes(sibling).any?
-          end
-        end
-
-        def message(range)
-          access_modifier = range.source
-
-          if group_style?
-            format(GROUP_STYLE_MESSAGE, access_modifier: access_modifier)
-          elsif inline_style?
-            format(INLINE_STYLE_MESSAGE, access_modifier: access_modifier)
-          end
-        end
-
-        def find_corresponding_def_nodes(node)
-          if access_modifier_with_symbol?(node)
-            method_names = node.arguments.filter_map do |argument|
-              next unless argument.sym_type?
-
-              argument.respond_to?(:value) && argument.value
-            end
-
-            def_nodes = node.parent.each_child_node(:def).select do |child|
-              method_names.include?(child.method_name)
-            end
-
-            # If there isn't a `def` node for each symbol, we will skip autocorrection.
-            def_nodes.size == method_names.size ? def_nodes : []
-          else
-            [node.first_argument]
-          end
-        end
-
-        def find_argument_less_modifier_node(node)
-          return unless (parent = node.parent)
-
-          parent.each_child_node(:send).find do |child|
-            child.method?(node.method_name) && child.arguments.empty?
-          end
-        end
-
-        def select_grouped_def_nodes(node)
-          node.right_siblings.take_while do |sibling|
-            !(sibling.send_type? && sibling.bare_access_modifier_declaration?)
-          end.select(&:def_type?)
-        end
-
-        def replace_defs(corrector, node, def_nodes)
-          source = def_source(node, def_nodes)
-          argument_less_modifier_node = find_argument_less_modifier_node(node)
-          if argument_less_modifier_node
-            corrector.insert_after(argument_less_modifier_node, "\n\n#{source}")
-          elsif (ancestor = node.each_ancestor(:class, :module).first)
-
-            corrector.insert_before(ancestor.loc.end, "#{node.method_name}\n\n#{source}\n")
-          else
-            corrector.replace(node, "#{node.method_name}\n\n#{source}")
-            return
-          end
-
-          remove_nodes(corrector, *def_nodes, node)
-        end
-
-        def insert_inline_modifier(corrector, node, modifier_name)
-          corrector.insert_before(node, "#{modifier_name} ")
-        end
-
-        def remove_nodes(corrector, *nodes)
-          nodes.each do |node|
-            corrector.remove(range_with_comments_and_lines(node))
-          end
-        end
-
-        def remove_modifier_node_within_begin(corrector, modifier_node, begin_node)
-          def_node = begin_node.children[begin_node.children.index(modifier_node) + 1]
-          range = modifier_node.source_range.begin.join(def_node.source_range.begin)
-          corrector.remove(range)
-        end
-
-        def def_source(node, def_nodes)
-          [
-            *processed_source.ast_with_comments[node].map(&:text),
-            *def_nodes.map(&:source)
-          ].join("\n")
-        end
-      end
-    end
-  end
-end