lightning_ui_kit 0.3.5 → 0.4.1

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

@@ -0,0 +1,321 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Use a guard clause instead of wrapping the code inside a conditional
+      # expression
+      #
+      # A condition with an `elsif` or `else` branch is allowed unless
+      # one of `return`, `break`, `next`, `raise`, or `fail` is used
+      # in the body of the conditional expression.
+      #
+      # NOTE: Autocorrect works in most cases except with if-else statements
+      #   that contain logical operators such as `foo || raise('exception')`
+      #
+      # @example
+      #   # bad
+      #   def test
+      #     if something
+      #       work
+      #     end
+      #   end
+      #
+      #   # good
+      #   def test
+      #     return unless something
+      #
+      #     work
+      #   end
+      #
+      #   # also good
+      #   def test
+      #     work if something
+      #   end
+      #
+      #   # bad
+      #   if something
+      #     raise 'exception'
+      #   else
+      #     ok
+      #   end
+      #
+      #   # good
+      #   raise 'exception' if something
+      #   ok
+      #
+      #   # bad
+      #   define_method(:test) do
+      #     if something
+      #       work
+      #     end
+      #   end
+      #
+      #   # good
+      #   define_method(:test) do
+      #     return unless something
+      #
+      #     work
+      #   end
+      #
+      #   # also good
+      #   define_method(:test) do
+      #     work if something
+      #   end
+      #
+      # @example AllowConsecutiveConditionals: false (default)
+      #   # bad
+      #   def test
+      #     if foo?
+      #       work
+      #     end
+      #
+      #     if bar?  # <- reports an offense
+      #       work
+      #     end
+      #   end
+      #
+      # @example AllowConsecutiveConditionals: true
+      #   # good
+      #   def test
+      #     if foo?
+      #       work
+      #     end
+      #
+      #     if bar?
+      #       work
+      #     end
+      #   end
+      #
+      #   # bad
+      #   def test
+      #     if foo?
+      #       work
+      #     end
+      #
+      #     do_something
+      #
+      #     if bar?  # <- reports an offense
+      #       work
+      #     end
+      #   end
+      #
+      class GuardClause < Base
+        extend AutoCorrector
+        include RangeHelp
+        include MinBodyLength
+        include StatementModifier
+
+        MSG = 'Use a guard clause (`%<example>s`) instead of wrapping the ' \
+              'code inside a conditional expression.'
+
+        def on_def(node)
+          body = node.body
+
+          return unless body
+
+          check_ending_body(body)
+        end
+        alias on_defs on_def
+
+        def on_block(node)
+          return unless node.method?(:define_method) || node.method?(:define_singleton_method)
+
+          on_def(node)
+        end
+        alias on_numblock on_block
+        alias on_itblock on_block
+
+        def on_if(node)
+          return if accepted_form?(node)
+
+          if (guard_clause = node.if_branch&.guard_clause?)
+            kw = node.loc.keyword.source
+            guard = :if
+          elsif (guard_clause = node.else_branch&.guard_clause?)
+            kw = node.inverse_keyword
+            guard = :else
+          else
+            return
+          end
+
+          guard = nil if and_or_guard_clause?(guard_clause)
+
+          register_offense(node, guard_clause_source(guard_clause), kw, guard)
+        end
+
+        private
+
+        def check_ending_body(body)
+          return if body.nil?
+
+          if body.if_type?
+            check_ending_if(body)
+          elsif body.begin_type?
+            final_expression = body.children.last
+            check_ending_if(final_expression) if final_expression&.if_type?
+          end
+        end
+
+        def check_ending_if(node)
+          return if accepted_form?(node, ending: true) || !min_body_length?(node)
+          return if allowed_consecutive_conditionals? &&
+                    consecutive_conditionals?(node.parent, node)
+
+          register_offense(node, 'return', node.inverse_keyword)
+
+          check_ending_body(node.if_branch)
+        end
+
+        def consecutive_conditionals?(parent, node)
+          parent.each_child_node.inject(false) do |if_type, child|
+            break if_type if node == child
+
+            child.if_type?
+          end
+        end
+
+        def register_offense(node, scope_exiting_keyword, conditional_keyword, guard = nil)
+          condition, = node.node_parts
+          example = [scope_exiting_keyword, conditional_keyword, condition.source].join(' ')
+          if too_long_for_single_line?(node, example)
+            return if trivial?(node)
+
+            example = "#{conditional_keyword} #{condition.source}; #{scope_exiting_keyword}; end"
+            replacement = <<~RUBY.chomp
+              #{conditional_keyword} #{condition.source}
+                #{scope_exiting_keyword}
+              end
+            RUBY
+          end
+
+          add_offense(node.loc.keyword, message: format(MSG, example: example)) do |corrector|
+            next if node.else? && guard.nil?
+
+            autocorrect(corrector, node, condition, replacement || example, guard)
+          end
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        def autocorrect(corrector, node, condition, replacement, guard)
+          corrector.replace(node.loc.keyword.join(condition.source_range), replacement)
+
+          if_branch = node.if_branch
+          else_branch = node.else_branch
+
+          corrector.replace(node.loc.begin, "\n") if node.then?
+
+          if (if_heredoc = find_heredoc_argument(if_branch))
+            autocorrect_heredoc_argument(corrector, node, if_heredoc, else_branch, guard)
+          elsif (else_heredoc = find_heredoc_argument(else_branch))
+            autocorrect_heredoc_argument(corrector, node, else_heredoc, if_branch, guard)
+          else
+            corrector.remove(node.loc.end)
+            return unless node.else?
+
+            corrector.remove(node.loc.else)
+            corrector.remove(range_of_branch_to_remove(node, guard))
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        def heredoc?(argument)
+          argument.respond_to?(:heredoc?) && argument.heredoc?
+        end
+
+        def find_heredoc_argument(node)
+          return unless node&.call_type?
+
+          last_arg = node.last_argument
+
+          if heredoc?(last_arg)
+            last_arg
+          elsif last_arg&.call_type?
+            find_heredoc_argument(last_arg)
+          end
+        end
+
+        def autocorrect_heredoc_argument(corrector, node, heredoc_node, leave_branch, guard)
+          remove_whole_lines(corrector, node.loc.end)
+          return unless node.else?
+
+          if leave_branch
+            remove_whole_lines(corrector, leave_branch.source_range)
+            corrector.insert_after(heredoc_node.loc.heredoc_end, "\n#{leave_branch.source}")
+          end
+
+          remove_whole_lines(corrector, node.loc.else)
+          remove_whole_lines(corrector, range_of_branch_to_remove(node, guard))
+        end
+
+        def range_of_branch_to_remove(node, guard)
+          branch = case guard
+                   when :if then node.if_branch
+                   when :else then node.else_branch
+                   end
+
+          branch.source_range
+        end
+
+        def guard_clause_source(guard_clause)
+          if and_or_guard_clause?(guard_clause)
+            guard_clause.parent.source
+          else
+            guard_clause.source
+          end
+        end
+
+        def and_or_guard_clause?(guard_clause)
+          parent = guard_clause.parent
+          parent.operator_keyword?
+        end
+
+        def too_long_for_single_line?(node, example)
+          max = max_line_length
+          max && node.source_range.column + example.length > max
+        end
+
+        def accepted_form?(node, ending: false)
+          accepted_if?(node, ending) || node.condition.multiline? || node.parent&.assignment?
+        end
+
+        def trivial?(node)
+          return false unless node.if_branch
+
+          node.branches.one? && !node.if_branch.if_type? && !node.if_branch.begin_type?
+        end
+
+        def accepted_if?(node, ending)
+          return true if node.modifier_form? || node.ternary? || node.elsif_conditional? ||
+                         assigned_lvar_used_in_if_branch?(node)
+
+          if ending
+            node.else?
+          else
+            !node.else? || node.elsif?
+          end
+        end
+
+        def assigned_lvar_used_in_if_branch?(node)
+          return false unless (if_branch = node.if_branch)
+
+          assigned_lvars_in_condition = node.condition.each_descendant(:lvasgn).map do |lvasgn|
+            lvar_name, = *lvasgn
+            lvar_name.to_s
+          end
+          used_lvars_in_branch = if_branch.each_descendant(:lvar).map(&:source) || []
+
+          (assigned_lvars_in_condition & used_lvars_in_branch).any?
+        end
+
+        def remove_whole_lines(corrector, range)
+          corrector.remove(range_by_whole_lines(range, include_final_newline: true))
+        end
+
+        def allowed_consecutive_conditionals?
+          cop_config.fetch('AllowConsecutiveConditionals', false)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for presence or absence of braces around hash literal as a last
+      # array item depending on configuration.
+      #
+      # NOTE: This cop will ignore arrays where all items are hashes, regardless of
+      # EnforcedStyle.
+      #
+      # @example EnforcedStyle: braces (default)
+      #   # bad
+      #   [1, 2, one: 1, two: 2]
+      #
+      #   # good
+      #   [1, 2, { one: 1, two: 2 }]
+      #
+      #   # good
+      #   [{ one: 1 }, { two: 2 }]
+      #
+      # @example EnforcedStyle: no_braces
+      #   # bad
+      #   [1, 2, { one: 1, two: 2 }]
+      #
+      #   # good
+      #   [1, 2, one: 1, two: 2]
+      #
+      #   # good
+      #   [{ one: 1 }, { two: 2 }]
+      class HashAsLastArrayItem < Base
+        include RangeHelp
+        include ConfigurableEnforcedStyle
+        extend AutoCorrector
+
+        def on_hash(node)
+          return if node.children.first&.kwsplat_type?
+          return unless (array = containing_array(node))
+          return unless expected_braced_last_array_item?(array, node) && explicit_array?(array)
+
+          if braces_style?
+            check_braces(node)
+          else
+            check_no_braces(node)
+          end
+        end
+
+        private
+
+        def containing_array(hash_node)
+          parent = hash_node.parent
+          parent if parent&.array_type?
+        end
+
+        def expected_braced_last_array_item?(array, node)
+          return false if array.each_value.all? do |node|
+            node.hash_type? && (braces_style? ? node.braces? : !node.braces?)
+          end
+
+          !array.values[-2]&.hash_type? && array.values.last.equal?(node)
+        end
+
+        def explicit_array?(array)
+          # an implicit array cannot have an "unbraced" hash
+          array.square_brackets?
+        end
+
+        def check_braces(node)
+          return if node.braces?
+
+          add_offense(node, message: 'Wrap hash in `{` and `}`.') do |corrector|
+            corrector.wrap(node, '{', '}')
+          end
+        end
+
+        def check_no_braces(node)
+          return unless node.braces?
+          return if node.children.empty? # Empty hash cannot be "unbraced"
+
+          add_offense(node, message: 'Omit the braces around the hash.') do |corrector|
+            remove_last_element_trailing_comma(corrector, node.parent)
+            corrector.remove(node.loc.begin)
+            corrector.remove(node.loc.end)
+          end
+        end
+
+        def braces_style?
+          style == :braces
+        end
+
+        def remove_last_element_trailing_comma(corrector, node)
+          range = range_with_surrounding_space(
+            node.children.last.source_range,
+            side: :right
+          ).end.resize(1)
+
+          corrector.remove(range) if range.source == ','
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Enforces the use of either `Hash#[]` or `Hash#fetch` for hash lookup.
+      #
+      # This cop can be configured to prefer either bracket-style (`[]`)
+      # or fetch-style lookup. It is disabled by default.
+      #
+      # When enforcing `fetch` style, only single-argument bracket access is flagged.
+      # When enforcing `brackets` style, only `fetch` calls with a single key
+      # argument are flagged (not those with default values or blocks).
+      #
+      # @safety
+      #   This cop is unsafe because `Hash#[]` and `Hash#fetch` have different
+      #   semantics. `Hash#[]` returns `nil` for missing keys, while `Hash#fetch`
+      #   raises a `KeyError`. Replacing one with the other can change program
+      #   behavior in cases where the key is missing.
+      #
+      #   Additionally, it cannot be guaranteed that the receiver is a `Hash`
+      #   or responds to the replacement method.
+      #
+      # @example EnforcedStyle: brackets (default)
+      #   # bad
+      #   hash.fetch(key)
+      #
+      #   # good
+      #   hash[key]
+      #
+      #   # good - fetch with default value is allowed
+      #   hash.fetch(key, default)
+      #
+      #   # good - fetch with block is allowed
+      #   hash.fetch(key) { default }
+      #
+      # @example EnforcedStyle: fetch
+      #   # bad
+      #   hash[key]
+      #
+      #   # good
+      #   hash.fetch(key)
+      #
+      class HashLookupMethod < Base
+        include ConfigurableEnforcedStyle
+        extend AutoCorrector
+
+        BRACKET_MSG = 'Use `Hash#[]` instead of `Hash#fetch`.'
+        FETCH_MSG = 'Use `Hash#fetch` instead of `Hash#[]`.'
+
+        RESTRICT_ON_SEND = %i[[] fetch].freeze
+
+        def on_send(node)
+          if offense_for_brackets?(node)
+            add_offense(node.loc.selector, message: BRACKET_MSG) do |corrector|
+              correct_fetch_to_brackets(corrector, node)
+            end
+          elsif offense_for_fetch?(node)
+            add_offense(node, message: FETCH_MSG) do |corrector|
+              correct_brackets_to_fetch(corrector, node)
+            end
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def offense_for_brackets?(node)
+          style == :brackets && node.receiver && node.method?(:fetch) && node.arguments.one? &&
+            !node.block_literal?
+        end
+
+        def offense_for_fetch?(node)
+          style == :fetch && node.method?(:[]) && node.arguments.one?
+        end
+
+        def correct_fetch_to_brackets(corrector, node)
+          receiver = node.receiver.source
+          key = node.first_argument.source
+          replacement = "#{receiver}[#{key}]"
+          replacement = "(#{replacement})" if node.csend_type?
+          corrector.replace(node, replacement)
+        end
+
+        def correct_brackets_to_fetch(corrector, node)
+          receiver = node.receiver.source
+          key = node.first_argument.source
+          operator = node.csend_type? ? '&.' : '.'
+          corrector.replace(node, "#{receiver}#{operator}fetch(#{key})")
+        end
+      end
+    end
+  end
+end