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/if_unless_modifier.rb

@@ -0,0 +1,351 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for `if` and `unless` statements that would fit on one line if
+      # written as modifier `if`/`unless`. The cop also checks for modifier
+      # `if`/`unless` lines that exceed the maximum line length.
+      #
+      # The maximum line length is configured in the `Layout/LineLength`
+      # cop. The tab size is configured in the `IndentationWidth` of the
+      # `Layout/IndentationStyle` cop.
+      #
+      # One-line pattern matching is always allowed. To ensure that there are few cases
+      # where the match variable is not used, and to prevent oversights. The variable `x`
+      # becomes undefined and raises `NameError` when the following example is changed to
+      # the modifier form:
+      #
+      # [source,ruby]
+      # ----
+      # if [42] in [x]
+      #   x # `x` is undefined when using modifier form.
+      # end
+      # ----
+      #
+      # The code `def method_name = body if condition` is considered a bad case by
+      # `Style/AmbiguousEndlessMethodDefinition` cop. So, to respect the user's intention to use
+      # an endless method definition in the `if` body, the following code is allowed:
+      #
+      # [source,ruby]
+      # ----
+      # if condition
+      #   def method_name = body
+      # end
+      # ----
+      #
+      # NOTE: It is allowed when `defined?` argument has an undefined value,
+      # because using the modifier form causes the following incompatibility:
+      #
+      # [source,ruby]
+      # ----
+      # unless defined?(undefined_foo)
+      #   undefined_foo = 'default_value'
+      # end
+      # undefined_foo # => 'default_value'
+      #
+      # undefined_bar = 'default_value' unless defined?(undefined_bar)
+      # undefined_bar # => nil
+      # ----
+      #
+      # @example
+      #   # bad
+      #   if condition
+      #     do_stuff(bar)
+      #   end
+      #
+      #   unless qux.empty?
+      #     Foo.do_something
+      #   end
+      #
+      #   do_something_with_a_long_name(arg) if long_condition_that_prevents_code_fit_on_single_line
+      #
+      #   # good
+      #   do_stuff(bar) if condition
+      #   Foo.do_something unless qux.empty?
+      #
+      #   if long_condition_that_prevents_code_fit_on_single_line
+      #     do_something_with_a_long_name(arg)
+      #   end
+      #
+      #   if short_condition # a long comment that makes it too long if it were just a single line
+      #     do_something
+      #   end
+      #
+      class IfUnlessModifier < Base # rubocop:disable Metrics/ClassLength
+        include StatementModifier
+        include LineLengthHelp
+        include AllowedPattern
+        include RangeHelp
+        include CommentsHelp
+        extend AutoCorrector
+
+        MSG_USE_MODIFIER = 'Favor modifier `%<keyword>s` usage when having a ' \
+                           'single-line body. Another good alternative is ' \
+                           'the usage of control flow `&&`/`||`.'
+        MSG_USE_NORMAL = 'Modifier form of `%<keyword>s` makes the line too long.'
+
+        def self.autocorrect_incompatible_with
+          [Style::SoleNestedConditional]
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        def on_if(node)
+          return if endless_method?(node.body)
+
+          condition = node.condition
+          return if defined_nodes(condition).any? { |n| defined_argument_is_undefined?(node, n) } ||
+                    pattern_matching_nodes(condition).any?
+
+          return unless (msg = message(node))
+
+          add_offense(node.loc.keyword, message: format(msg, keyword: node.keyword)) do |corrector|
+            next if part_of_ignored_node?(node)
+
+            autocorrect(corrector, node)
+            ignore_node(node)
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        private
+
+        def endless_method?(body)
+          body&.any_def_type? && body.endless?
+        end
+
+        def defined_nodes(condition)
+          if condition.defined_type?
+            [condition]
+          else
+            condition.each_descendant.select(&:defined_type?)
+          end
+        end
+
+        def defined_argument_is_undefined?(if_node, defined_node)
+          defined_argument = defined_node.first_argument
+          return false unless defined_argument.type?(:lvar, :send)
+
+          if_node.left_siblings.none? do |sibling|
+            sibling.respond_to?(:lvasgn_type?) && sibling.lvasgn_type? &&
+              sibling.name == defined_argument.node_parts[0]
+          end
+        end
+
+        def pattern_matching_nodes(condition)
+          if condition.any_match_pattern_type?
+            [condition]
+          else
+            condition.each_descendant.select(&:any_match_pattern_type?)
+          end
+        end
+
+        def message(node)
+          if single_line_as_modifier?(node) && !named_capture_in_condition?(node)
+            MSG_USE_MODIFIER
+          elsif too_long_due_to_modifier?(node)
+            MSG_USE_NORMAL
+          end
+        end
+
+        def autocorrect(corrector, node)
+          replacement = if node.modifier_form?
+                          replacement_for_modifier_form(corrector, node)
+                        else
+                          to_modifier_form(node)
+                        end
+          corrector.replace(node, replacement)
+        end
+
+        def replacement_for_modifier_form(corrector, node) # rubocop:disable Metrics/AbcSize
+          comment = comment_on_node_line(node)
+          if comment && too_long_due_to_comment_after_modifier?(node, comment)
+            remove_comment(corrector, node, comment)
+
+            return to_modifier_form_with_move_comment(node, indent(node), comment)
+          end
+
+          last_argument = node.if_branch.last_argument if node.if_branch.send_type?
+          if last_argument.respond_to?(:heredoc?) && last_argument.heredoc?
+            heredoc = extract_heredoc_from(last_argument)
+            remove_heredoc(corrector, heredoc)
+
+            return to_normal_form_with_heredoc(node, indent(node), heredoc)
+          end
+
+          to_normal_form(node, indent(node))
+        end
+
+        def too_long_due_to_modifier?(node)
+          node.modifier_form? && too_long_single_line?(node) &&
+            !another_statement_on_same_line?(node)
+        end
+
+        def too_long_due_to_comment_after_modifier?(node, comment)
+          source_length = processed_source.lines[node.first_line - 1].length
+
+          max_line_length.between?(source_length - comment.source_range.length, source_length)
+        end
+
+        def allowed_patterns
+          line_length_config = config.for_cop('Layout/LineLength')
+          line_length_config['AllowedPatterns'] || line_length_config['IgnoredPatterns'] || []
+        end
+
+        def too_long_single_line?(node)
+          return false unless max_line_length
+
+          range = node.source_range
+          return false unless range.single_line?
+          return false unless line_length_enabled_at_line?(range.first_line)
+
+          line = range.source_line
+          return false if line_length(line) <= max_line_length
+
+          too_long_line_based_on_config?(range, line)
+        end
+
+        def too_long_line_based_on_config?(range, line)
+          return false if matches_allowed_pattern?(line)
+
+          too_long = too_long_line_based_on_allow_cop_directives?(range, line)
+          return too_long unless too_long == :undetermined
+
+          too_long_line_based_on_allow_uri?(line)
+        end
+
+        def too_long_line_based_on_allow_cop_directives?(range, line)
+          if allow_cop_directives? && directive_on_source_line?(range.line - 1)
+            return line_length_without_directive(line) > max_line_length
+          end
+
+          :undetermined
+        end
+
+        def too_long_line_based_on_allow_uri?(line)
+          if allow_uri?
+            uri_range = find_excessive_range(line, :uri)
+            return false if uri_range && allowed_position?(line, uri_range)
+          end
+
+          true
+        end
+
+        def line_length_enabled_at_line?(line)
+          processed_source.comment_config.cop_enabled_at_line?('Layout/LineLength', line)
+        end
+
+        def named_capture_in_condition?(node)
+          node.condition.match_with_lvasgn_type?
+        end
+
+        def non_eligible_node?(node)
+          non_simple_if_unless?(node) || node.chained? || node.nested_conditional? ||
+            multiline_inside_collection?(node) || super
+        end
+
+        def multiline_inside_collection?(node)
+          return false if node.modifier_form?
+          return false unless (collection = find_containing_collection(node))
+
+          collection.children.any? { |child| sibling_if_shares_line?(child, node) }
+        end
+
+        def sibling_if_shares_line?(child, node)
+          inner = unwrap_begin(child)
+          inner&.if_type? && !inner.ternary? && shares_line_with?(inner, node)
+        end
+
+        def unwrap_begin(node)
+          return unless node.is_a?(RuboCop::AST::Node)
+
+          node = node.value if node.pair_type?
+          node.begin_type? ? node.children.first : node
+        end
+
+        def shares_line_with?(inner, node)
+          same_line?(inner, node.loc.end) || same_line?(inner.loc.end, node)
+        end
+
+        def find_containing_collection(node)
+          parent = node.parent
+          return collection_from_ancestor(parent) unless parent&.begin_type?
+
+          collection_from_ancestor(parent.parent)
+        end
+
+        def collection_from_ancestor(node)
+          return node if node&.type?(:array, :call)
+
+          node.parent if node&.type?(:pair)
+        end
+
+        def non_simple_if_unless?(node)
+          node.ternary? || node.elsif? || node.else?
+        end
+
+        def another_statement_on_same_line?(node)
+          line_no = node.source_range.last_line
+
+          # traverse the AST upwards until we find a 'begin' node
+          # we want to look at the following child and see if it is on the
+          #   same line as this 'if' node
+          while node && !node.begin_type?
+            index = node.sibling_index
+            node  = node.parent
+          end
+
+          node && (sibling = node.children[index + 1]) && sibling.source_range.first_line == line_no
+        end
+
+        def to_normal_form(node, indentation)
+          <<~RUBY.chomp
+            #{node.keyword} #{node.condition.source}
+            #{indentation}  #{node.body.source}
+            #{indentation}end
+          RUBY
+        end
+
+        def to_normal_form_with_heredoc(node, indentation, heredoc)
+          heredoc_body, heredoc_end = heredoc
+
+          <<~RUBY.chomp
+            #{node.keyword} #{node.condition.source}
+            #{indentation}  #{node.body.source}
+            #{indentation}  #{heredoc_body.source.chomp}
+            #{indentation}  #{heredoc_end.source.chomp}
+            #{indentation}end
+          RUBY
+        end
+
+        def to_modifier_form_with_move_comment(node, indentation, comment)
+          <<~RUBY.chomp
+            #{comment.source}
+            #{indentation}#{node.body.source} #{node.keyword} #{node.condition.source}
+          RUBY
+        end
+
+        def extract_heredoc_from(last_argument)
+          heredoc_body = last_argument.loc.heredoc_body
+          heredoc_end = last_argument.loc.heredoc_end
+
+          [heredoc_body, heredoc_end]
+        end
+
+        def remove_heredoc(corrector, heredoc)
+          heredoc.each do |range|
+            corrector.remove(range_by_whole_lines(range, include_final_newline: true))
+          end
+        end
+
+        def comment_on_node_line(node)
+          processed_source.comments.find { |c| same_line?(c, node) }
+        end
+
+        def remove_comment(corrector, _node, comment)
+          corrector.remove(range_with_surrounding_space(range: comment.source_range, side: :left))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for if and unless statements used as modifiers of other if or
+      # unless statements.
+      #
+      # @example
+      #
+      #   # bad
+      #   tired? ? 'stop' : 'go faster' if running?
+      #
+      #   # bad
+      #   if tired?
+      #     "please stop"
+      #   else
+      #     "keep going"
+      #   end if running?
+      #
+      #   # good
+      #   if running?
+      #     tired? ? 'stop' : 'go faster'
+      #   end
+      class IfUnlessModifierOfIfUnless < Base
+        include StatementModifier
+        extend AutoCorrector
+
+        MSG = 'Avoid modifier `%<keyword>s` after another conditional.'
+
+        # rubocop:disable Metrics/AbcSize
+        def on_if(node)
+          return unless node.modifier_form? && node.body.if_type?
+
+          add_offense(node.loc.keyword, message: format(MSG, keyword: node.keyword)) do |corrector|
+            corrector.wrap(node.if_branch, "#{node.keyword} #{node.condition.source}\n", "\nend")
+            corrector.remove(node.if_branch.source_range.end.join(node.condition.source_range.end))
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+      end
+    end
+  end
+end

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

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for redundant `if` with boolean literal branches.
+      # It checks only conditions to return boolean value (`true` or `false`) for safe detection.
+      # The conditions to be checked are comparison methods, predicate methods, and
+      # double negation (!!).
+      # `nonzero?` method is allowed by default.
+      # These are customizable with `AllowedMethods` option.
+      #
+      # This cop targets only ``if``s with a single `elsif` or `else` branch. The following
+      # code will be allowed, because it has two `elsif` branches:
+      #
+      # [source,ruby]
+      # ----
+      # if foo
+      #   true
+      # elsif bar > baz
+      #   true
+      # elsif qux > quux # Single `elsif` is warned, but two or more `elsif`s are not.
+      #   true
+      # else
+      #   false
+      # end
+      # ----
+      #
+      # @safety
+      #   Autocorrection is unsafe because there is no guarantee that all predicate methods
+      #   will return a boolean value. Those methods can be allowed with `AllowedMethods` config.
+      #
+      # @example
+      #   # bad
+      #   if foo == bar
+      #     true
+      #   else
+      #     false
+      #   end
+      #
+      #   # bad
+      #   foo == bar ? true : false
+      #
+      #   # good
+      #   foo == bar
+      #
+      #   # bad
+      #   if foo.do_something?
+      #     true
+      #   else
+      #     false
+      #   end
+      #
+      #   # good (but potentially an unsafe correction)
+      #   foo.do_something?
+      #
+      # @example AllowedMethods: ['infinite?', 'nonzero?'] (default)
+      #   # good
+      #   num.infinite? ? true : false
+      #
+      #   # good
+      #   num.nonzero? ? true : false
+      #
+      class IfWithBooleanLiteralBranches < Base
+        include AllowedMethods
+        extend AutoCorrector
+
+        MSG = 'Remove redundant %<keyword>s with boolean literal branches.'
+        MSG_FOR_ELSIF = 'Use `else` instead of redundant `elsif` with boolean literal branches.'
+
+        # @!method if_with_boolean_literal_branches?(node)
+        def_node_matcher :if_with_boolean_literal_branches?, <<~PATTERN
+          (if #return_boolean_value? <true false>)
+        PATTERN
+        # @!method double_negative?(node)
+        def_node_matcher :double_negative?, '(send (send _ :!) :!)'
+
+        def on_if(node)
+          return if !if_with_boolean_literal_branches?(node) || multiple_elsif?(node)
+
+          condition = node.condition
+          range, keyword = offense_range_with_keyword(node, condition)
+
+          add_offense(range, message: message(node, keyword)) do |corrector|
+            replacement = replacement_condition(node, condition)
+
+            if node.elsif?
+              corrector.insert_before(node, "else\n")
+              corrector.replace(node, "#{indent(node.if_branch)}#{replacement}")
+            else
+              corrector.replace(node, replacement)
+            end
+          end
+        end
+
+        private
+
+        def multiple_elsif?(node)
+          return false unless (parent = node.parent)
+
+          parent.if_type? && parent.elsif?
+        end
+
+        def offense_range_with_keyword(node, condition)
+          if node.ternary?
+            range = condition.source_range.end.join(node.source_range.end)
+
+            [range, 'ternary operator']
+          else
+            keyword = node.loc.keyword
+
+            [keyword, "`#{keyword.source}`"]
+          end
+        end
+
+        def message(node, keyword)
+          if node.elsif?
+            MSG_FOR_ELSIF
+          else
+            format(MSG, keyword: keyword)
+          end
+        end
+
+        def return_boolean_value?(condition)
+          return false unless condition
+
+          if condition.begin_type?
+            return_boolean_value?(condition.children.first)
+          elsif condition.or_type?
+            return_boolean_value?(condition.lhs) && return_boolean_value?(condition.rhs)
+          elsif condition.and_type?
+            return_boolean_value?(condition.rhs)
+          else
+            assume_boolean_value?(condition)
+          end
+        end
+
+        def assume_boolean_value?(condition)
+          return false unless condition.send_type?
+          return false if allowed_method?(condition.method_name)
+
+          condition.comparison_method? || condition.predicate_method? || double_negative?(condition)
+        end
+
+        def replacement_condition(node, condition)
+          bang = '!' if opposite_condition?(node)
+
+          if bang && require_parentheses?(condition)
+            "#{bang}(#{condition.source})"
+          else
+            "#{bang}#{condition.source}"
+          end
+        end
+
+        def opposite_condition?(node)
+          (!node.unless? && node.if_branch.false_type?) ||
+            (node.unless? && node.if_branch.true_type?)
+        end
+
+        def require_parentheses?(condition)
+          condition.operator_keyword? || (condition.send_type? && condition.comparison_method?)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for use of the lambda.(args) syntax.
+      #
+      # @example EnforcedStyle: call (default)
+      #   # bad
+      #   lambda.(x, y)
+      #
+      #   # good
+      #   lambda.call(x, y)
+      #
+      # @example EnforcedStyle: braces
+      #   # bad
+      #   lambda.call(x, y)
+      #
+      #   # good
+      #   lambda.(x, y)
+      class LambdaCall < Base
+        include ConfigurableEnforcedStyle
+        extend AutoCorrector
+
+        MSG = 'Prefer the use of `%<prefer>s` over `%<current>s`.'
+        RESTRICT_ON_SEND = %i[call].freeze
+
+        def on_send(node)
+          return unless node.receiver
+
+          if offense?(node)
+            prefer = prefer(node)
+            current = node.source
+
+            add_offense(node, message: format(MSG, prefer: prefer, current: current)) do |corrector|
+              next if part_of_ignored_node?(node)
+
+              opposite_style_detected
+              corrector.replace(node, prefer)
+
+              ignore_node(node)
+            end
+          else
+            correct_style_detected
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def offense?(node)
+          (explicit_style? && node.implicit_call?) || (implicit_style? && !node.implicit_call?)
+        end
+
+        def prefer(node)
+          receiver = node.receiver.source
+          dot = node.loc.dot.source
+          call_arguments = if node.arguments.empty?
+                             ''
+                           else
+                             arguments = node.arguments.map(&:source).join(', ')
+                             "(#{arguments})"
+                           end
+          method = explicit_style? ? "call#{call_arguments}" : "(#{arguments})"
+
+          "#{receiver}#{dot}#{method}"
+        end
+
+        def implicit_style?
+          style == :braces
+        end
+
+        def explicit_style?
+          style == :call
+        end
+      end
+    end
+  end
+end