lexxy-variables 0.0.2 → 0.0.3

data/vendor/bundle/ruby/3.4.0/gems/{rubocop-1.88.1 → rubocop-1.88.2}/lib/rubocop/cop/style/if_unless_modifier.rb

@@ -91,7 +91,7 @@ module RuboCop
 
         # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def on_if(node)
-          return if endless_method?(node.body) || node.ancestors.any?(&:dstr_type?)
+          return if endless_method?(node.body) || node.each_ancestor(:dstr).any?
 
           condition = node.condition
           return if defined_nodes(condition).any? { |n| defined_argument_is_undefined?(node, n) } ||
@@ -119,7 +119,7 @@ module RuboCop
           if condition.defined_type?
             [condition]
           else
-            condition.each_descendant.select(&:defined_type?)
+            condition.each_descendant(:defined?)
           end
         end
 
@@ -137,7 +137,7 @@ module RuboCop
           if condition.any_match_pattern_type?
             [condition]
           else
-            condition.each_descendant.select(&:any_match_pattern_type?)
+            condition.each_descendant(:any_match_pattern)
           end
         end
 
@@ -350,7 +350,7 @@ module RuboCop
         end
 
         def comment_on_node_line(node)
-          processed_source.comments.find { |c| same_line?(c, node) }
+          processed_source.comment_at_line(node.first_line)
         end
 
         def remove_comment(corrector, _node, comment)

data/vendor/bundle/ruby/3.4.0/gems/{rubocop-1.88.1 → rubocop-1.88.2}/lib/rubocop/cop/style/invertible_unless_condition.rb

@@ -75,7 +75,9 @@ module RuboCop
         def invertible?(node) # rubocop:disable Metrics/CyclomaticComplexity
           case node&.type
           when :begin
-            invertible?(node.children.first)
+            # A multi-statement `begin` evaluates to its last expression, so it
+            # cannot be inverted by negating a single child.
+            node.children.one? && invertible?(node.children.first)
           when :send
             return false if inheritance_check?(node)
 
@@ -124,12 +126,17 @@ module RuboCop
         end
 
         def preferred_logical_condition(node)
-          preferred_lhs = preferred_condition(node.lhs)
-          preferred_rhs = preferred_condition(node.rhs)
+          preferred_lhs = preferred_operand(node, node.lhs)
+          preferred_rhs = preferred_operand(node, node.rhs)
 
           "#{preferred_lhs} #{node.inverse_operator} #{preferred_rhs}"
         end
 
+        def preferred_operand(node, operand)
+          preferred = preferred_condition(operand)
+          parenthesize_inverted_operand?(node, operand) ? "(#{preferred})" : preferred
+        end
+
         def autocorrect(corrector, node)
           case node.type
           when :begin
@@ -138,11 +145,24 @@ module RuboCop
             autocorrect_send_node(corrector, node)
           when :or, :and
             corrector.replace(node.loc.operator, node.inverse_operator)
-            autocorrect(corrector, node.lhs)
-            autocorrect(corrector, node.rhs)
+            autocorrect_operand(corrector, node, node.lhs)
+            autocorrect_operand(corrector, node, node.rhs)
           end
         end
 
+        def autocorrect_operand(corrector, node, operand)
+          autocorrect(corrector, operand)
+          corrector.wrap(operand, '(', ')') if parenthesize_inverted_operand?(node, operand)
+        end
+
+        # When an `and` is nested in an `or`, inverting both operators turns the
+        # `and` into an `or` that now binds looser than its parent, so it must be
+        # parenthesized to keep the original grouping (`a && b || c` inverts to
+        # `(!a || !b) && !c`, not `!a || !b && !c`).
+        def parenthesize_inverted_operand?(node, operand)
+          node.or_type? && operand.and_type?
+        end
+
         def autocorrect_send_node(corrector, node)
           if node.method?(:!)
             corrector.remove(node.loc.selector)

data/vendor/bundle/ruby/3.4.0/gems/{rubocop-1.88.1 → rubocop-1.88.2}/lib/rubocop/cop/style/lambda_call.rb

@@ -27,6 +27,9 @@ module RuboCop
 
         def on_send(node)
           return unless node.receiver
+          # Rewriting the call rebuilds it as a single expression, which would drop
+          # any comments inside the argument list, so leave it to be fixed manually.
+          return if comments_in_node?(node)
 
           if offense?(node)
             prefer = prefer(node)
@@ -48,6 +51,14 @@ module RuboCop
 
         private
 
+        def comments_in_node?(node)
+          range = node.source_range
+          processed_source.comments.any? do |comment|
+            range.begin_pos <= comment.source_range.begin_pos &&
+              comment.source_range.end_pos <= range.end_pos
+          end
+        end
+
         def offense?(node)
           (explicit_style? && node.implicit_call?) || (implicit_style? && !node.implicit_call?)
         end

data/vendor/bundle/ruby/3.4.0/gems/{rubocop-1.88.1 → rubocop-1.88.2}/lib/rubocop/cop/style/method_call_without_args_parentheses.rb

@@ -50,9 +50,11 @@ module RuboCop
         private
 
         def register_offense(node)
-          add_offense(offense_range(node)) do |corrector|
-            corrector.remove(node.loc.begin)
-            corrector.remove(node.loc.end)
+          range = offense_range(node)
+          return if processed_source.contains_comment?(range)
+
+          add_offense(range) do |corrector|
+            corrector.remove(range)
           end
         end
 

data/vendor/bundle/ruby/3.4.0/gems/{rubocop-1.88.1 → rubocop-1.88.2}/lib/rubocop/cop/style/method_def_parentheses.rb

@@ -102,6 +102,10 @@ module RuboCop
         MSG_PRESENT = 'Use def without parentheses.'
         MSG_MISSING = 'Use def with parentheses when there are parameters.'
 
+        def self.autocorrect_incompatible_with
+          [Style::ArgumentsForwarding]
+        end
+
         def on_def(node)
           args = node.arguments
 

data/vendor/bundle/ruby/3.4.0/gems/{rubocop-1.88.1 → rubocop-1.88.2}/lib/rubocop/cop/style/missing_respond_to_missing.rb

@@ -65,16 +65,19 @@ module RuboCop
         private
 
         def implements_respond_to_missing?(node)
-          return false unless (grand_parent = node.parent.parent)
+          scope = enclosing_scope(node)
+          search_root = scope || node.parent
+          return false unless search_root
 
-          grand_parent.each_descendant(node.type) do |descendant|
-            return true if descendant.method?(:respond_to_missing?)
-
-            child = descendant.children.first
-            return true if child.respond_to?(:method?) && child.method?(:respond_to_missing?)
+          search_root.each_descendant(node.type).any? do |descendant|
+            descendant.method?(:respond_to_missing?) && enclosing_scope(descendant).equal?(scope)
           end
+        end
 
-          false
+        # The class/module/`class << self` body that lexically contains `node`,
+        # or `nil` when `node` is defined at the top level.
+        def enclosing_scope(node)
+          node.each_ancestor(:class, :module, :sclass).first
         end
       end
     end

data/vendor/bundle/ruby/3.4.0/gems/{rubocop-1.88.1 → rubocop-1.88.2}/lib/rubocop/cop/style/mixin_usage.rb

@@ -47,7 +47,7 @@ module RuboCop
         # @!method include_statement(node)
         def_node_matcher :include_statement, <<~PATTERN
           (send nil? ${:include :extend :prepend}
-            const)
+            const+)
         PATTERN
 
         # @!method in_top_level_scope?(node)

data/vendor/bundle/ruby/3.4.0/gems/{rubocop-1.88.1 → rubocop-1.88.2}/lib/rubocop/cop/style/module_function.rb

@@ -110,9 +110,11 @@ module RuboCop
         def_node_matcher :private_directive?, '(send nil? :private ...)'
 
         def on_module(node)
-          return unless node.body&.begin_type?
+          return unless node.body
 
-          each_wrong_style(node.body.children) do |child_node|
+          body_nodes = node.body.begin_type? ? node.body.children : [node.body]
+
+          each_wrong_style(body_nodes) do |child_node|
             add_offense(child_node) do |corrector|
               next if style == :forbidden
 

data/vendor/bundle/ruby/3.4.0/gems/{rubocop-1.88.1 → rubocop-1.88.2}/lib/rubocop/cop/style/redundant_current_directory_in_path.rb

@@ -26,7 +26,9 @@ module RuboCop
         def on_send(node)
           return unless (first_argument = node.first_argument)
           return unless (index = first_argument.source.index(CURRENT_DIRECTORY_PREFIX))
-          return unless (redundant_length = redundant_path_length(first_argument.str_content))
+
+          content = leading_path_content(first_argument)
+          return unless (redundant_length = redundant_path_length(content))
 
           begin_pos = first_argument.source_range.begin.begin_pos + index
           end_pos = begin_pos + redundant_length
@@ -39,6 +41,16 @@ module RuboCop
 
         private
 
+        # The literal text at the start of the path, which is the whole string
+        # for a plain string and the leading literal segment for an interpolated
+        # one (`nil` when it starts with interpolation).
+        def leading_path_content(node)
+          return node.str_content if node.str_type?
+          return unless node.dstr_type? && (first = node.children.first)&.str_type?
+
+          first.str_content
+        end
+
         def redundant_path_length(path)
           return unless (match = path&.match(REDUNDANT_CURRENT_DIRECTORY_PREFIX))
 

data/vendor/bundle/ruby/3.4.0/gems/{rubocop-1.88.1 → rubocop-1.88.2}/lib/rubocop/cop/style/redundant_heredoc_delimiter_quotes.rb

@@ -48,8 +48,13 @@ module RuboCop
         def need_heredoc_delimiter_quotes?(node)
           heredoc_delimiter = node.source.delete(heredoc_type(node))
           return true unless heredoc_delimiter.start_with?("'", '"')
+          return true if node.loc.heredoc_end.source.strip.match?(/\W/)
 
-          node.loc.heredoc_end.source.strip.match?(/\W/) ||
+          # A double-quoted delimiter interpolates exactly like an unquoted one,
+          # so its quotes are always redundant. A single-quoted delimiter is
+          # required when the body contains interpolation or escapes that would
+          # otherwise be evaluated.
+          heredoc_delimiter.start_with?("'") &&
             node.loc.heredoc_body.source.match?(STRING_INTERPOLATION_OR_ESCAPED_CHARACTER_PATTERN)
         end
       end

data/vendor/bundle/ruby/3.4.0/gems/{rubocop-1.88.1 → rubocop-1.88.2}/lib/rubocop/cop/style/struct_inheritance.rb

@@ -41,7 +41,9 @@ module RuboCop
           return unless struct_constructor?(node.parent_class)
 
           add_offense(node.parent_class) do |corrector|
-            corrector.remove(range_with_surrounding_space(node.loc.keyword, newlines: false))
+            corrector.remove(
+              range_with_surrounding_space(node.loc.keyword, side: :right, newlines: false)
+            )
             corrector.replace(node.loc.operator, '=')
 
             correct_parent(node.parent_class, corrector)

data/vendor/bundle/ruby/3.4.0/gems/{rubocop-1.88.1 → rubocop-1.88.2}/lib/rubocop/cop/style/trivial_accessors.rb

@@ -234,7 +234,7 @@ module RuboCop
         def autocorrect_class(corrector, node)
           kind = trivial_accessor_kind(node)
 
-          return unless names_match?(node) && kind
+          return unless names_match?(node) && !node.predicate_method? && kind
 
           indent = ' ' * node.loc.column
           corrector.replace(

data/vendor/bundle/ruby/3.4.0/gems/{rubocop-1.88.1 → rubocop-1.88.2}/lib/rubocop/cop/team.rb

@@ -59,6 +59,16 @@ module RuboCop
 
       attr_reader :errors, :warnings, :updated_source_file, :cops
 
+      # When set to true, the corrected source is not written back to the
+      # inspected file; it is exposed through `#updated_source` instead.
+      # @api private
+      attr_accessor :defer_corrections
+
+      # The corrected source of the last investigation, if corrections were
+      # made with `#defer_corrections` enabled.
+      # @api private
+      attr_reader :updated_source
+
       alias updated_source_file? updated_source_file
 
       def initialize(cops, config = nil, options = {})
@@ -135,20 +145,24 @@ module RuboCop
 
       def autocorrect(processed_source, corrector)
         @updated_source_file = false
+        @updated_source = nil
         return unless autocorrect?
         return unless corrector
         return if corrector.empty?
 
-        new_source = corrector.rewrite
+        apply_correction(processed_source, corrector.rewrite)
+        @updated_source_file = true
+      end
 
+      def apply_correction(processed_source, new_source)
         if @options[:stdin]
           # holds source read in from stdin, when --stdin option is used
           @options[:stdin] = new_source
+        elsif defer_corrections
+          @updated_source = new_source
         else
-          filename = processed_source.file_path
-          File.write(filename, new_source)
+          File.write(processed_source.file_path, new_source)
         end
-        @updated_source_file = true
       end
 
       def be_ready

data/vendor/bundle/ruby/3.4.0/gems/{rubocop-1.88.1 → rubocop-1.88.2}/lib/rubocop/runner.rb

@@ -346,16 +346,18 @@ module RuboCop
       # inspection iteration. This is used to output meaningful infinite loop
       # error message.
       offenses_by_iteration = []
+      corrected_source = nil
 
-      # When running with --autocorrect, we need to inspect the file (which
-      # includes writing a corrected version of it) until no more corrections
-      # are made. This is because automatic corrections can introduce new
-      # offenses. In the normal case the loop is only executed once.
+      # When running with --autocorrect, we need to inspect the file until no
+      # more corrections are made. This is because automatic corrections can
+      # introduce new offenses. In the normal case the loop is only executed
+      # once. The corrections are kept in memory while iterating and written
+      # back to the file when the loop is done.
       iterate_until_no_changes(processed_source, offenses_by_iteration) do
         # The offenses that couldn't be corrected will be found again so we
         # only keep the corrected ones in order to avoid duplicate reporting.
         !offenses_by_iteration.empty? && offenses_by_iteration.last.select!(&:corrected?)
-        new_offenses, updated_source_file = inspect_file(processed_source)
+        team, new_offenses, updated_source_file = inspect_iteration(processed_source)
         offenses_by_iteration.push(new_offenses)
 
         # We have to reprocess the source to pickup the changes. Since the
@@ -364,12 +366,43 @@ module RuboCop
         break unless updated_source_file
 
         # Autocorrect has happened, don't use the prism result since it is stale.
-        processed_source = get_processed_source(file, nil)
+        # With --stdin the corrected source is kept in @options[:stdin] instead.
+        corrected_source = team.updated_source
+        processed_source = get_processed_source(file, nil, source: corrected_source)
       end
 
       # Return summary of corrected offenses after all iterations
-      offenses = offenses_by_iteration.flatten.uniq
-      [processed_source, offenses]
+      [processed_source, offenses_by_iteration.flatten.uniq]
+    ensure
+      # Write the file once, even when the loop was left through an exception
+      # (e.g. an infinite correction loop), like the per-iteration writes
+      # used to be.
+      File.write(file, corrected_source) if corrected_source
+    end
+
+    def inspect_iteration(processed_source)
+      team = mobilize_team(processed_source)
+      team.defer_corrections = in_memory_corrections_possible?
+      offenses, updated_source_file = inspect_file(processed_source, team)
+      [team, offenses, updated_source_file]
+    end
+
+    # When corrections were written to disk and read back between iterations,
+    # the text-mode write converted LF to CRLF on Windows, and cops like
+    # `Layout/EndOfLine` rely on seeing the source as it would be on disk.
+    # Apply the same conversion to the in-memory source. The final `File.write`
+    # still performs it for the file itself.
+    def emulate_write_read_cycle(source)
+      return source unless Platform.windows?
+
+      source.encode(source.encoding, crlf_newline: true)
+    end
+
+    # Custom ruby extractors may derive their fragments from the file on
+    # disk rather than from the passed processed source, so corrections can
+    # only be kept in memory when the default extractor is used.
+    def in_memory_corrections_possible?
+      self.class.ruby_extractors.one?
     end
 
     def iterate_until_no_changes(source, offenses_by_iteration)
@@ -552,12 +585,19 @@ module RuboCop
     end
 
     # rubocop:disable Metrics/MethodLength
-    def get_processed_source(file, prism_result)
+    def get_processed_source(file, prism_result, source: nil)
       config = @config_store.for_file(file)
       ruby_version = config.target_ruby_version
       parser_engine = config.parser_engine
 
-      processed_source = if @options[:stdin]
+      processed_source = if source
+                           ProcessedSource.new(
+                             emulate_write_read_cycle(source),
+                             ruby_version,
+                             file,
+                             parser_engine: parser_engine
+                           )
+                         elsif @options[:stdin]
                            ProcessedSource.new(
                              @options[:stdin],
                              ruby_version,

data/vendor/bundle/ruby/3.4.0/gems/{rubocop-1.88.1 → rubocop-1.88.2}/lib/rubocop/version.rb

@@ -3,7 +3,7 @@
 module RuboCop
   # This module holds the RuboCop version information.
   module Version
-    STRING = '1.88.1'
+    STRING = '1.88.2'
 
     MSG = '%<version>s (using %<parser_version>s, ' \
           'rubocop-ast %<rubocop_ast_version>s, ' \

data/vendor/bundle/ruby/3.4.0/gems/{rubocop-rails-2.35.5 → rubocop-rails-2.36.0}/lib/rubocop/cop/rails/eager_evaluation_log_message.rb

@@ -42,7 +42,7 @@ module RuboCop
         end
 
         def on_send(node)
-          return if node.parent&.block_type?
+          return if node.block_literal?
 
           interpolated_string_passed_to_debug(node) do |arguments|
             range = replacement_range(node)

data/vendor/bundle/ruby/3.4.0/gems/{rubocop-rails-2.35.5 → rubocop-rails-2.36.0}/lib/rubocop/cop/rails/reversible_migration.rb

@@ -294,6 +294,8 @@ module RuboCop
             false
           when :remove
             target_rails_version >= 6.1 && all_hash_key?(node.last_argument, :type)
+          when :remove_index
+            reversible_remove_index?(node)
           when :change_default, :change_column_default, :change_table_comment,
                :change_column_comment
             all_hash_key?(node.last_argument, :from, :to)
@@ -302,6 +304,12 @@ module RuboCop
           end
         end
 
+        def reversible_remove_index?(node)
+          return true if node.arguments.any? { |arg| !arg.hash_type? }
+
+          all_hash_key?(node.last_argument, :column)
+        end
+
         def within_change_method?(node)
           node.each_ancestor(:def).any? do |ancestor|
             ancestor.method?(:change)

data/vendor/bundle/ruby/3.4.0/gems/{rubocop-rails-2.35.5 → rubocop-rails-2.36.0}/lib/rubocop/cop/rails/safe_navigation.rb

@@ -12,8 +12,10 @@ module RuboCop
       #   foo.try!(:bar)
       #   foo.try!(:bar, baz)
       #   foo.try!(:bar) { |e| e.baz }
+      #   foo.try!(&:bar)
       #
       #   foo.try!(:[], 0)
+      #   foo.try!(:==, baz)
       #
       #   # good
       #   foo.try(:bar)
@@ -23,20 +25,28 @@ module RuboCop
       #   foo&.bar
       #   foo&.bar(baz)
       #   foo&.bar { |e| e.baz }
+      #   foo&.[](0)
+      #   foo&.==(baz)
       #
       # @example ConvertTry: true
       #   # bad
       #   foo.try!(:bar)
       #   foo.try!(:bar, baz)
       #   foo.try!(:bar) { |e| e.baz }
+      #   foo.try!(&:bar)
       #   foo.try(:bar)
       #   foo.try(:bar, baz)
       #   foo.try(:bar) { |e| e.baz }
+      #   foo.try(&:bar)
+      #   foo.try(:[], 0)
+      #   foo.try(:==, baz)
       #
       #   # good
       #   foo&.bar
       #   foo&.bar(baz)
       #   foo&.bar { |e| e.baz }
+      #   foo&.[](0)
+      #   foo&.==(baz)
       class SafeNavigation < Base
         include RangeHelp
         extend AutoCorrector
@@ -51,6 +61,11 @@ module RuboCop
           (send _ ${:try :try!} $_ ...)
         PATTERN
 
+        # Extracts the method name from a symbol-to-proc block argument, e.g. `:foo` from `try(&:foo)`.
+        def_node_matcher :symbol_proc_method, <<~PATTERN
+          (block_pass (sym $_))
+        PATTERN
+
         def self.autocorrect_incompatible_with
           [Style::RedundantSelf]
         end
@@ -58,11 +73,16 @@ module RuboCop
         def on_send(node)
           try_call(node) do |try_method, dispatch|
             return if try_method == :try && !cop_config['ConvertTry']
-            return unless dispatch.sym_type? && dispatch.value.match?(/\w+[=!?]?/)
+            return unless dispatch.sym_type? || symbol_proc_method(dispatch)
+            # When a `try` is nested in another `try`'s argument, correcting both at once
+            # produces overlapping replacements. Correct the outer one first and defer the
+            # inner one to a subsequent pass.
+            return if part_of_ignored_node?(node)
 
             add_offense(node, message: format(MSG, try: try_method)) do |corrector|
               autocorrect(corrector, node)
             end
+            ignore_node(node)
           end
         end
 
@@ -70,7 +90,6 @@ module RuboCop
 
         def autocorrect(corrector, node)
           method_node, *params = *node.arguments
-          method = method_node.source[1..]
 
           range = if node.receiver
                     range_between(node.loc.dot.begin_pos, node.source_range.end_pos)
@@ -79,13 +98,16 @@ module RuboCop
                     node
                   end
 
-          corrector.replace(range, replacement(method, params))
+          corrector.replace(range, replacement(method_node, params))
         end
 
-        def replacement(method, params)
+        def replacement(method_node, params)
+          return "&.#{symbol_proc_method(method_node)}" if method_node.block_pass_type?
+
+          method = method_node.source[1..]
           new_params = params.map(&:source).join(', ')
 
-          if method.end_with?('=')
+          if setter_method?(method)
             "&.#{method[0...-1]} = #{new_params}"
           elsif params.empty?
             "&.#{method}"
@@ -93,6 +115,12 @@ module RuboCop
             "&.#{method}(#{new_params})"
           end
         end
+
+        # Operator methods such as `==` and `[]=` also end with `=`, but they are not setters
+        # and must keep the explicit call form (e.g. `&.==(bar)`, `&.[]=(key, value)`).
+        def setter_method?(method)
+          method.match?(/\A\w+=\z/)
+        end
       end
     end
   end

data/vendor/bundle/ruby/3.4.0/gems/{rubocop-rails-2.35.5 → rubocop-rails-2.36.0}/lib/rubocop/rails/migration_file_skippable.rb

@@ -29,10 +29,6 @@ module RuboCop
         super if method(__method__).super_method
       end
 
-      def self.apply_to_cops!
-        RuboCop::Cop::Registry.all.each { |cop| cop.prepend(MigrationFileSkippable) }
-      end
-
       private
 
       def already_migrated_file?

data/vendor/bundle/ruby/3.4.0/gems/{rubocop-rails-2.35.5 → rubocop-rails-2.36.0}/lib/rubocop/rails/version.rb

@@ -4,7 +4,7 @@ module RuboCop
   module Rails
     # This module holds the RuboCop Rails version information.
     module Version
-      STRING = '2.35.5'
+      STRING = '2.36.0'
 
       def self.document_version
         STRING.match('\d+\.\d+').to_s

data/vendor/bundle/ruby/3.4.0/gems/{rubocop-rails-2.35.5 → rubocop-rails-2.36.0}/lib/rubocop-rails.rb

@@ -12,7 +12,8 @@ require_relative 'rubocop/rails/plugin'
 require_relative 'rubocop/cop/rails_cops'
 
 require_relative 'rubocop/rails/migration_file_skippable'
-RuboCop::Rails::MigrationFileSkippable.apply_to_cops!
+
+RuboCop::Cop::Base.prepend(RuboCop::Rails::MigrationFileSkippable)
 
 RuboCop::Cop::Style::HashExcept.minimum_target_ruby_version(2.0)
 
@@ -39,3 +40,11 @@ RuboCop::Cop::Style::RedundantSelf.singleton_class.prepend(
     end
   end
 )
+
+RuboCop::Cop::Style::TrailingCommaInArguments.singleton_class.prepend(
+  Module.new do
+    def autocorrect_incompatible_with
+      super.push(RuboCop::Cop::Rails::LinkToBlank)
+    end
+  end
+)

data/vendor/bundle/ruby/3.4.0/specifications/{lexxy-0.9.23.gemspec → lexxy-0.9.24.gemspec}

@@ -1,10 +1,10 @@
 # -*- encoding: utf-8 -*-
-# stub: lexxy 0.9.23 ruby lib
+# stub: lexxy 0.9.24 ruby lib
 # stub: ext/Rakefile
 
 Gem::Specification.new do |s|
   s.name = "lexxy".freeze
-  s.version = "0.9.23".freeze
+  s.version = "0.9.24".freeze
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
   s.metadata = { "changelog_uri" => "https://github.com/basecamp/lexxy", "homepage_uri" => "https://github.com/basecamp/lexxy", "source_code_uri" => "https://github.com/basecamp/lexxy" } if s.respond_to? :metadata=

data/vendor/bundle/ruby/3.4.0/specifications/{rubocop-1.88.1.gemspec → rubocop-1.88.2.gemspec}

@@ -1,12 +1,12 @@
 # -*- encoding: utf-8 -*-
-# stub: rubocop 1.88.1 ruby lib
+# stub: rubocop 1.88.2 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "rubocop".freeze
-  s.version = "1.88.1".freeze
+  s.version = "1.88.2".freeze
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
-  s.metadata = { "bug_tracker_uri" => "https://github.com/rubocop/rubocop/issues", "changelog_uri" => "https://github.com/rubocop/rubocop/releases/tag/v1.88.1", "documentation_uri" => "https://docs.rubocop.org/rubocop/1.88/", "homepage_uri" => "https://rubocop.org/", "rubygems_mfa_required" => "true", "source_code_uri" => "https://github.com/rubocop/rubocop/" } if s.respond_to? :metadata=
+  s.metadata = { "bug_tracker_uri" => "https://github.com/rubocop/rubocop/issues", "changelog_uri" => "https://github.com/rubocop/rubocop/releases/tag/v1.88.2", "documentation_uri" => "https://docs.rubocop.org/rubocop/1.88/", "homepage_uri" => "https://rubocop.org/", "rubygems_mfa_required" => "true", "source_code_uri" => "https://github.com/rubocop/rubocop/" } if s.respond_to? :metadata=
   s.require_paths = ["lib".freeze]
   s.authors = ["Bozhidar Batsov".freeze, "Jonas Arvidsson".freeze, "Yuji Nakayama".freeze]
   s.bindir = "exe".freeze

data/vendor/bundle/ruby/3.4.0/specifications/{rubocop-rails-2.35.5.gemspec → rubocop-rails-2.36.0.gemspec}

@@ -1,12 +1,12 @@
 # -*- encoding: utf-8 -*-
-# stub: rubocop-rails 2.35.5 ruby lib
+# stub: rubocop-rails 2.36.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "rubocop-rails".freeze
-  s.version = "2.35.5".freeze
+  s.version = "2.36.0".freeze
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
-  s.metadata = { "bug_tracker_uri" => "https://github.com/rubocop/rubocop-rails/issues", "changelog_uri" => "https://github.com/rubocop/rubocop-rails/blob/master/CHANGELOG.md", "default_lint_roller_plugin" => "RuboCop::Rails::Plugin", "documentation_uri" => "https://docs.rubocop.org/rubocop-rails/2.35/", "homepage_uri" => "https://docs.rubocop.org/rubocop-rails/", "rubygems_mfa_required" => "true", "source_code_uri" => "https://github.com/rubocop/rubocop-rails/" } if s.respond_to? :metadata=
+  s.metadata = { "bug_tracker_uri" => "https://github.com/rubocop/rubocop-rails/issues", "changelog_uri" => "https://github.com/rubocop/rubocop-rails/blob/master/CHANGELOG.md", "default_lint_roller_plugin" => "RuboCop::Rails::Plugin", "documentation_uri" => "https://docs.rubocop.org/rubocop-rails/2.36/", "homepage_uri" => "https://docs.rubocop.org/rubocop-rails/", "rubygems_mfa_required" => "true", "source_code_uri" => "https://github.com/rubocop/rubocop-rails/" } if s.respond_to? :metadata=
   s.require_paths = ["lib".freeze]
   s.authors = ["Bozhidar Batsov".freeze, "Jonas Arvidsson".freeze, "Yuji Nakayama".freeze]
   s.date = "1980-01-02"