lightning_ui_kit 0.3.5 → 0.4.1

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

@@ -1,267 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Layout
-      # Checks the indentation of the method name part in method calls
-      # that span more than one line.
-      #
-      # @example EnforcedStyle: aligned (default)
-      #   # bad
-      #   while myvariable
-      #   .b
-      #     # do something
-      #   end
-      #
-      #   # good
-      #   while myvariable
-      #         .b
-      #     # do something
-      #   end
-      #
-      #   # good
-      #   Thing.a
-      #        .b
-      #        .c
-      #
-      # @example EnforcedStyle: indented
-      #   # good
-      #   while myvariable
-      #     .b
-      #
-      #     # do something
-      #   end
-      #
-      # @example EnforcedStyle: indented_relative_to_receiver
-      #   # good
-      #   while myvariable
-      #           .a
-      #           .b
-      #
-      #     # do something
-      #   end
-      #
-      #   # good
-      #   myvariable = Thing
-      #                  .a
-      #                  .b
-      #                  .c
-      class MultilineMethodCallIndentation < Base
-        include ConfigurableEnforcedStyle
-        include Alignment
-        include MultilineExpressionIndentation
-        extend AutoCorrector
-
-        def validate_config
-          return unless style == :aligned && cop_config['IndentationWidth']
-
-          raise ValidationError,
-                'The `Layout/MultilineMethodCallIndentation` ' \
-                'cop only accepts an `IndentationWidth` ' \
-                'configuration parameter when ' \
-                '`EnforcedStyle` is `indented`.'
-        end
-
-        private
-
-        def autocorrect(corrector, node)
-          AlignmentCorrector.correct(corrector, processed_source, node, @column_delta)
-        end
-
-        def relevant_node?(send_node)
-          send_node.loc.dot # Only check method calls with dot operator
-        end
-
-        def right_hand_side(send_node)
-          dot = send_node.loc.dot
-          selector = send_node.loc.selector
-          if (send_node.dot? || send_node.safe_navigation?) && selector && same_line?(dot, selector)
-            dot.join(selector)
-          elsif selector
-            selector
-          elsif send_node.implicit_call?
-            dot.join(send_node.loc.begin)
-          end
-        end
-
-        # rubocop:disable Metrics/AbcSize
-        def offending_range(node, lhs, rhs, given_style)
-          return false unless begins_its_line?(rhs)
-          return false if not_for_this_cop?(node)
-
-          @base = alignment_base(node, rhs, given_style)
-          correct_column = if @base
-                             parent = node.parent
-                             parent = parent.parent if parent&.any_block_type?
-                             @base.column + extra_indentation(given_style, parent)
-                           else
-                             indentation(lhs) + correct_indentation(node)
-                           end
-          @column_delta = correct_column - rhs.column
-          rhs if @column_delta.nonzero?
-        end
-        # rubocop:enable Metrics/AbcSize
-
-        def extra_indentation(given_style, parent)
-          if given_style == :indented_relative_to_receiver
-            if parent&.type?(:splat, :kwsplat)
-              configured_indentation_width - parent.loc.operator.length
-            else
-              configured_indentation_width
-            end
-          else
-            0
-          end
-        end
-
-        def message(node, lhs, rhs)
-          if should_indent_relative_to_receiver?
-            relative_to_receiver_message(rhs)
-          elsif should_align_with_base?
-            align_with_base_message(rhs)
-          else
-            no_base_message(lhs, rhs, node)
-          end
-        end
-
-        def should_indent_relative_to_receiver?
-          @base && style == :indented_relative_to_receiver
-        end
-
-        def should_align_with_base?
-          @base && style != :indented_relative_to_receiver
-        end
-
-        def relative_to_receiver_message(rhs)
-          "Indent `#{rhs.source}` #{configured_indentation_width} spaces " \
-            "more than `#{base_source}` on line #{@base.line}."
-        end
-
-        def align_with_base_message(rhs)
-          "Align `#{rhs.source}` with `#{base_source}` on line #{@base.line}."
-        end
-
-        def base_source
-          @base.source[/[^\n]*/]
-        end
-
-        def no_base_message(lhs, rhs, node)
-          used_indentation = rhs.column - indentation(lhs)
-          what = operation_description(node, rhs)
-
-          "Use #{correct_indentation(node)} (not #{used_indentation}) " \
-            "spaces for indenting #{what} spanning multiple lines."
-        end
-
-        def alignment_base(node, rhs, given_style)
-          case given_style
-          when :aligned
-            semantic_alignment_base(node, rhs) || syntactic_alignment_base(node, rhs)
-          when :indented
-            nil
-          when :indented_relative_to_receiver
-            receiver_alignment_base(node)
-          end
-        end
-
-        def syntactic_alignment_base(lhs, rhs)
-          # a if b
-          #      .c
-          kw_node_with_special_indentation(lhs) do |base|
-            return indented_keyword_expression(base).source_range
-          end
-
-          # a = b
-          #     .c
-          part_of_assignment_rhs(lhs, rhs) { |base| return assignment_rhs(base).source_range }
-
-          # a + b
-          #     .c
-          operation_rhs(lhs) { |base| return base.source_range }
-        end
-
-        # a.b
-        #  .c
-        def semantic_alignment_base(node, rhs)
-          return unless rhs.source.start_with?('.', '&.')
-
-          node = semantic_alignment_node(node)
-          return unless node&.loc&.selector && node.loc.dot
-
-          node.loc.dot.join(node.loc.selector)
-        end
-
-        # a
-        #   .b
-        #   .c
-        def receiver_alignment_base(node)
-          node = node.receiver while node.receiver
-          node = node.parent
-          node = node.parent until node.loc.dot
-
-          node&.receiver&.source_range
-        end
-
-        def semantic_alignment_node(node)
-          return if argument_in_method_call(node, :with_parentheses)
-
-          dot_right_above = get_dot_right_above(node)
-          return dot_right_above if dot_right_above
-
-          if (multiline_block_chain_node = find_multiline_block_chain_node(node))
-            return multiline_block_chain_node
-          end
-
-          node = first_call_has_a_dot(node)
-          return if node.loc.dot.line != node.first_line
-
-          node
-        end
-
-        def get_dot_right_above(node)
-          node.each_ancestor.find do |a|
-            dot = a.loc.dot if a.loc?(:dot)
-            next unless dot
-
-            dot.line == node.loc.dot.line - 1 && dot.column == node.loc.dot.column
-          end
-        end
-
-        def find_multiline_block_chain_node(node)
-          return unless (block_node = node.each_descendant(:any_block).first)
-          return unless block_node.multiline? && block_node.parent.call_type?
-
-          if node.receiver.call_type?
-            node.receiver
-          else
-            block_node.parent
-          end
-        end
-
-        def first_call_has_a_dot(node)
-          # descend to root of method chain
-          node = node.receiver while node.receiver
-          # ascend to first call which has a dot
-          node = node.parent
-          node = node.parent until node.loc?(:dot)
-
-          node
-        end
-
-        def operation_rhs(node)
-          operation_rhs = node.receiver.each_ancestor(:send).find do |rhs|
-            operator_rhs?(rhs, node.receiver)
-          end
-
-          return unless operation_rhs
-
-          yield operation_rhs.first_argument
-        end
-
-        def operator_rhs?(node, receiver)
-          node.operator_method? && node.arguments? && within_node?(receiver, node.first_argument)
-        end
-      end
-    end
-  end
-end

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

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Layout
-      # Checks for spaces between `->` and opening parameter
-      # parenthesis (`(`) in lambda literals.
-      #
-      # @example EnforcedStyle: require_no_space (default)
-      #     # bad
-      #     a = -> (x, y) { x + y }
-      #
-      #     # good
-      #     a = ->(x, y) { x + y }
-      #
-      # @example EnforcedStyle: require_space
-      #     # bad
-      #     a = ->(x, y) { x + y }
-      #
-      #     # good
-      #     a = -> (x, y) { x + y }
-      class SpaceInLambdaLiteral < Base
-        include ConfigurableEnforcedStyle
-        include RangeHelp
-        extend AutoCorrector
-
-        MSG_REQUIRE_SPACE = 'Use a space between `->` and `(` in lambda literals.'
-        MSG_REQUIRE_NO_SPACE = 'Do not use spaces between `->` and `(` in lambda literals.'
-
-        def on_send(node)
-          return unless arrow_lambda_with_args?(node)
-
-          if style == :require_space && !space_after_arrow?(node)
-            lambda_node = range_of_offense(node)
-
-            add_offense(lambda_node, message: MSG_REQUIRE_SPACE) do |corrector|
-              corrector.insert_before(lambda_arguments(node), ' ')
-            end
-          elsif style == :require_no_space && space_after_arrow?(node)
-            space = space_after_arrow(node)
-
-            add_offense(space, message: MSG_REQUIRE_NO_SPACE) do |corrector|
-              corrector.remove(space)
-            end
-          end
-        end
-
-        private
-
-        def arrow_lambda_with_args?(node)
-          node.lambda_literal? && node.parent.arguments?
-        end
-
-        def space_after_arrow?(lambda_node)
-          !space_after_arrow(lambda_node).empty?
-        end
-
-        def space_after_arrow(lambda_node)
-          arrow = lambda_node.parent.children[0].source_range
-          parentheses = lambda_node.parent.children[1].source_range
-
-          arrow.end.join(parentheses.begin)
-        end
-
-        def range_of_offense(node)
-          range_between(
-            node.parent.source_range.begin_pos,
-            node.parent.arguments.source_range.end_pos
-          )
-        end
-
-        def lambda_arguments(node)
-          node.parent.children[1]
-        end
-      end
-    end
-  end
-end

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

@@ -1,346 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Lint
-      # Checks for duplicated instance (or singleton) method
-      # definitions.
-      #
-      # NOTE: Aliasing a method to itself is allowed, as it indicates that
-      # the developer intends to suppress Ruby's method redefinition warnings.
-      # See https://bugs.ruby-lang.org/issues/13574.
-      #
-      # @example
-      #
-      #   # bad
-      #   def foo
-      #     1
-      #   end
-      #
-      #   def foo
-      #     2
-      #   end
-      #
-      #   # bad
-      #   def foo
-      #     1
-      #   end
-      #
-      #   alias foo bar
-      #
-      #   # good
-      #   def foo
-      #     1
-      #   end
-      #
-      #   def bar
-      #     2
-      #   end
-      #
-      #   # good
-      #   def foo
-      #     1
-      #   end
-      #
-      #   alias bar foo
-      #
-      #   # good
-      #   alias foo foo
-      #   def foo
-      #     1
-      #   end
-      #
-      #   # good
-      #   alias_method :foo, :foo
-      #   def foo
-      #     1
-      #   end
-      #
-      # @example AllCops:ActiveSupportExtensionsEnabled: false (default)
-      #
-      #   # good
-      #   def foo
-      #     1
-      #   end
-      #
-      #   delegate :foo, to: :bar
-      #
-      # @example AllCops:ActiveSupportExtensionsEnabled: true
-      #
-      #   # bad
-      #   def foo
-      #     1
-      #   end
-      #
-      #   delegate :foo, to: :bar
-      #
-      #   # good
-      #   def foo
-      #     1
-      #   end
-      #
-      #   delegate :baz, to: :bar
-      #
-      #   # good - delegate with splat arguments is ignored
-      #   def foo
-      #     1
-      #   end
-      #
-      #   delegate :foo, **options
-      #
-      #   # good - delegate inside a condition is ignored
-      #   def foo
-      #     1
-      #   end
-      #
-      #   if cond
-      #     delegate :foo, to: :bar
-      #   end
-      #
-      class DuplicateMethods < Base
-        MSG = 'Method `%<method>s` is defined at both %<defined>s and %<current>s.'
-        RESTRICT_ON_SEND = %i[alias_method attr_reader attr_writer attr_accessor attr
-                              delegate].freeze
-
-        def initialize(config = nil, options = nil)
-          super
-          @definitions = {}
-          @scopes = Hash.new { |hash, key| hash[key] = [] }
-        end
-
-        def on_def(node)
-          # if a method definition is inside an if, it is very likely
-          # that a different definition is used depending on platform, etc.
-          return if node.each_ancestor.any?(&:if_type?)
-
-          found_instance_method(node, node.method_name)
-        end
-
-        def on_defs(node)
-          return if node.each_ancestor.any?(&:if_type?)
-
-          if node.receiver.const_type?
-            _, const_name = *node.receiver
-            check_const_receiver(node, node.method_name, const_name)
-          elsif node.receiver.self_type?
-            check_self_receiver(node, node.method_name)
-          end
-        end
-
-        # @!method method_alias?(node)
-        def_node_matcher :method_alias?, <<~PATTERN
-          (alias (sym $_name) (sym $_original_name))
-        PATTERN
-
-        def on_alias(node)
-          name, original_name = method_alias?(node)
-          return unless name && original_name
-          return if name == original_name
-          return if node.ancestors.any?(&:if_type?)
-
-          found_instance_method(node, name)
-        end
-
-        # @!method alias_method?(node)
-        def_node_matcher :alias_method?, <<~PATTERN
-          (send nil? :alias_method (sym $_name) (sym $_original_name))
-        PATTERN
-
-        # @!method delegate_method?(node)
-        def_node_matcher :delegate_method?, <<~PATTERN
-          (send nil? :delegate
-            ({sym str} $_)+
-            (hash <(pair (sym :to) {sym str}) ...>)
-          )
-        PATTERN
-
-        # @!method sym_name(node)
-        def_node_matcher :sym_name, '(sym $_name)'
-
-        def on_send(node) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-          name, original_name = alias_method?(node)
-
-          if name && original_name
-            return if name == original_name
-            return if node.ancestors.any?(&:if_type?)
-
-            found_instance_method(node, name)
-          elsif (attr = node.attribute_accessor?)
-            on_attr(node, *attr)
-          elsif active_support_extensions_enabled? && (names = delegate_method?(node))
-            return if node.ancestors.any?(&:if_type?)
-
-            on_delegate(node, names)
-          end
-        end
-
-        private
-
-        def check_const_receiver(node, name, const_name)
-          qualified = lookup_constant(node, const_name)
-          return unless qualified
-
-          found_method(node, "#{qualified}.#{name}")
-        end
-
-        def check_self_receiver(node, name)
-          enclosing = node.parent_module_name
-          return unless enclosing
-
-          found_method(node, "#{enclosing}.#{name}")
-        end
-
-        def message_for_dup(node, method_name, key)
-          format(MSG, method: method_name, defined: source_location(@definitions[key]),
-                      current: source_location(node))
-        end
-
-        def on_delegate(node, method_names)
-          name_prefix = delegate_prefix(node)
-
-          method_names.each do |name|
-            name = "#{name_prefix}_#{name}" if name_prefix
-
-            found_instance_method(node, name)
-          end
-        end
-
-        def delegate_prefix(node)
-          kwargs_node = node.last_argument
-
-          return unless (prefix = hash_value(kwargs_node, :prefix))
-
-          if prefix.true_type?
-            hash_value(kwargs_node, :to).value
-          elsif prefix.type?(:sym, :str)
-            prefix.value
-          end
-        end
-
-        def hash_value(node, key)
-          node.pairs.find { |pair| pair.key.value == key }&.value
-        end
-
-        def found_instance_method(node, name)
-          return found_sclass_method(node, name) unless (scope = node.parent_module_name)
-
-          # Humanize the scope
-          scope = scope.sub(
-            /(?:(?<name>.*)::)#<Class:\k<name>>|#<Class:(?<name>.*)>(?:::)?/,
-            '\k<name>.'
-          )
-          scope << '#' unless scope.end_with?('.')
-
-          found_method(node, "#{scope}#{name}")
-        end
-
-        def found_sclass_method(node, name)
-          singleton_ancestor = node.each_ancestor.find(&:sclass_type?)
-          return unless singleton_ancestor
-
-          singleton_receiver_node = singleton_ancestor.children[0]
-          return unless singleton_receiver_node.send_type?
-
-          found_method(node, "#{singleton_receiver_node.method_name}.#{name}")
-        end
-
-        def found_method(node, method_name)
-          key = method_key(node, method_name)
-          scope = node.each_ancestor(:rescue, :ensure).first&.type
-
-          if @definitions.key?(key)
-            if scope && !@scopes[scope].include?(key)
-              @definitions[key] = node
-              @scopes[scope] << key
-              return
-            end
-
-            message = message_for_dup(node, method_name, key)
-
-            add_offense(location(node), message: message)
-          else
-            @definitions[key] = node
-          end
-        end
-
-        def method_key(node, method_name)
-          if (ancestor_def = node.each_ancestor(:any_def).first)
-            "#{ancestor_def.method_name}.#{method_name}"
-          else
-            method_name
-          end
-        end
-
-        def location(node)
-          if node.any_def_type?
-            node.loc.keyword.join(node.loc.name)
-          else
-            node.source_range
-          end
-        end
-
-        def on_attr(node, attr_name, args)
-          case attr_name
-          when :attr
-            writable = args.size == 2 && args.last.true_type?
-            found_attr(node, [args.first], readable: true, writable: writable)
-          when :attr_reader
-            found_attr(node, args, readable: true)
-          when :attr_writer
-            found_attr(node, args, writable: true)
-          when :attr_accessor
-            found_attr(node, args, readable: true, writable: true)
-          end
-        end
-
-        def found_attr(node, args, readable: false, writable: false)
-          args.each do |arg|
-            name = sym_name(arg)
-            next unless name
-
-            found_instance_method(node, name) if readable
-            found_instance_method(node, "#{name}=") if writable
-          end
-        end
-
-        def lookup_constant(node, const_name)
-          # this method is quite imperfect and can be fooled
-          # to do much better, we would need to do global analysis of the whole
-          # codebase
-          node.each_ancestor(:class, :module, :casgn) do |ancestor|
-            namespace, mod_name = *ancestor.defined_module
-            loop do
-              if mod_name == const_name
-                return qualified_name(ancestor.parent_module_name, namespace, mod_name)
-              end
-
-              break if namespace.nil?
-
-              namespace, mod_name = *namespace
-            end
-          end
-        end
-
-        def qualified_name(enclosing, namespace, mod_name)
-          if enclosing != 'Object'
-            if namespace
-              "#{enclosing}::#{namespace.const_name}::#{mod_name}"
-            else
-              "#{enclosing}::#{mod_name}"
-            end
-          elsif namespace
-            "#{namespace.const_name}::#{mod_name}"
-          else
-            mod_name
-          end
-        end
-
-        def source_location(node)
-          range = node.source_range
-          path = smart_path(range.source_buffer.name)
-          "#{path}:#{range.line}"
-        end
-      end
-    end
-  end
-end