rubyzen-lint 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7ce170df4572f8af2962998ff57160f0027b39288a5f53d566234ff5e1442b43
-  data.tar.gz: 1189a743bb4de63887b7f45d4387a3b3fb6571ef5cb4a67763bbc0f69c31bde8
+  metadata.gz: 500e791179afc539a3b93a9300c55661567131776188a7ae484e5a2cffa3e12d
+  data.tar.gz: 1793077a6d2cfaa933c8a607cab96a3f84afe97e58f1a1926eaf6d60d2febed6
 SHA512:
-  metadata.gz: c424e1404f091fa5c965a4253f15b853e031b9078b305df0fa770d94fa545524f5f17776100bc7986ff630cb10c9506338886604d3a0c6b11f77058b66725a9b
-  data.tar.gz: 4275ca620f94b150758f12222064d2ec5b0314502a4a3da4a8bed40d1d937fc580f8f8d23878dfd74933a59615843c6bc5b35c0ff106fb525c816d2c1419c224
+  metadata.gz: fc076838beaafc1461c8c650e7a50e92ad0f4d32adc1c7f2ee15e9b47aeb9ac33a4742b2a98d47c23c2a73085f58b9cbbaa16d6a0d03526866472462bcb8f71f
+  data.tar.gz: b26b14d82f55b207b61601dd629154765488bf6154256738e11b1e96dfe14669109406513a12d4814c128e2cfbfc97b697c88ae68910d9d6c6c03a96c0d62164

data/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## [0.3.0]
+
+### Added
+
+- **`ExpressionDeclaration`** — a value-expression primitive wrapping any AST node, with
+  predicates (`constant?`, `local_variable?`, `method_call?`, `constructor?`, `hash_literal?`,
+  `symbol?`, `string?`) and accessors (`constant_name`, `method_name`, `name`).
+- **`#returns`** on `MethodDeclaration` and `BlockDeclaration` — the points at which it yields a
+  value (the implicit final expression plus explicit `return`s) as `ReturnDeclaration`s
+  (`#explicit?`, `#implicit?`, `#expression`), collected in a `ReturnsCollection` (`#expressions`).
+  `#return_expressions` remains as a shortcut for `returns.expressions` — an `ExpressionsCollection`
+  (`#hash_literals`, `#constants`). Both are bridged on `MethodsCollection` and `BlocksCollection`.
+- **`CallSiteDeclaration#arguments`** — the call's arguments as an `ArgumentsCollection`
+  (a subclass of `ExpressionsCollection`, so it keeps `#hash_literals`/`#constants`).
+- **`CallSiteDeclaration#receiver_expression`** — the receiver modeled structurally (constant /
+  constructor / local variable). `#receiver` (String const-name) is unchanged.
+- **`CallSiteDeclaration#enclosing_blocks`** — the chain of enclosing `do..end`/`{ }` blocks
+  (innermost first), as a `BlocksCollection`.
+- **`#assignments`** on `MethodDeclaration` and `BlockDeclaration` — local-variable assignments
+  (`AssignmentDeclaration`, with `#name` and `#value`) as an `AssignmentsCollection`. Bridged on
+  `MethodsCollection` and `BlocksCollection`.
+
+All additions are backward-compatible; no existing API changed.
+
 ## [0.2.0]
 
 ### Added

data/lib/rubyzen/collections/arguments_collection.rb

@@ -0,0 +1,16 @@
+module Rubyzen
+  module Collections
+    # Collection of {Rubyzen::Declarations::ExpressionDeclaration} representing the arguments
+    # passed at a call site.
+    #
+    # A specialization of {ExpressionsCollection}: arguments are value-expressions, so this
+    # inherits the value-expression filters (`#hash_literals`, `#constants`) and remains a
+    # drop-in `ExpressionsCollection`. It exists as a distinct type so argument-specific
+    # filters (e.g. positional vs keyword) can be added later without a breaking change.
+    #
+    # @example
+    #   call_site.arguments.first.constant_name
+    class ArgumentsCollection < ExpressionsCollection
+    end
+  end
+end

data/lib/rubyzen/collections/assignments_collection.rb

@@ -0,0 +1,11 @@
+module Rubyzen
+  module Collections
+    # Collection of {Rubyzen::Declarations::AssignmentDeclaration} (local-variable assignments).
+    #
+    # @example
+    #   method.assignments.with_name('user')
+    class AssignmentsCollection < BaseCollection
+      include Rubyzen::Providers::CollectionFilterProvider
+    end
+  end
+end

data/lib/rubyzen/collections/blocks_collection.rb

@@ -22,6 +22,27 @@ module Rubyzen
         all_call_sites = flat_map(&:call_sites)
         CallSiteCollection.new(all_call_sites)
       end
+
+      # Returns all return points across every block.
+      #
+      # @return [ReturnsCollection]
+      def returns
+        ReturnsCollection.new(flat_map(&:returns))
+      end
+
+      # Returns all return expressions across every block.
+      #
+      # @return [ExpressionsCollection]
+      def return_expressions
+        returns.expressions
+      end
+
+      # Returns all local-variable assignments across every block.
+      #
+      # @return [AssignmentsCollection]
+      def assignments
+        AssignmentsCollection.new(flat_map(&:assignments))
+      end
     end
   end
 end

data/lib/rubyzen/collections/expressions_collection.rb

@@ -0,0 +1,27 @@
+module Rubyzen
+  module Collections
+    # Collection of {Rubyzen::Declarations::ExpressionDeclaration} — return values,
+    # call arguments, and other value-expressions.
+    #
+    # @example
+    #   method.return_expressions.hash_literals
+    class ExpressionsCollection < BaseCollection
+      include Rubyzen::Providers::CollectionFilterProvider
+
+      # Filters to only braced Hash-literal expressions.
+      #
+      # @return [ExpressionsCollection]
+      def hash_literals
+        filter(&:hash_literal?)
+      end
+
+      # Filters to only constant expressions, including constructors of a constant
+      # (e.g. both +Repos::Foo+ and +Repos::Foo.new+).
+      #
+      # @return [ExpressionsCollection]
+      def constants
+        filter(&:constant_name)
+      end
+    end
+  end
+end

data/lib/rubyzen/collections/methods_collection.rb

@@ -62,6 +62,35 @@ module Rubyzen
           end
         )
       end
+
+      # Returns all return points across every method.
+      #
+      # @return [ReturnsCollection]
+      def returns
+        ReturnsCollection.new(
+          flat_map do |method|
+            method.returns
+          end
+        )
+      end
+
+      # Returns all return expressions across every method.
+      #
+      # @return [ExpressionsCollection]
+      def return_expressions
+        returns.expressions
+      end
+
+      # Returns all local-variable assignments across every method.
+      #
+      # @return [AssignmentsCollection]
+      def assignments
+        AssignmentsCollection.new(
+          flat_map do |method|
+            method.assignments
+          end
+        )
+      end
     end
   end
 end

data/lib/rubyzen/collections/returns_collection.rb

@@ -0,0 +1,20 @@
+module Rubyzen
+  module Collections
+    # Collection of {Rubyzen::Declarations::ReturnDeclaration} — the points at which a
+    # method or block yields a value.
+    #
+    # @example
+    #   method.returns.expressions.hash_literals
+    class ReturnsCollection < BaseCollection
+      include Rubyzen::Providers::CollectionFilterProvider
+
+      # The value expressions of every return. Bare +return+s (which have no value)
+      # are omitted.
+      #
+      # @return [ExpressionsCollection]
+      def expressions
+        ExpressionsCollection.new(filter_map(&:expression))
+      end
+    end
+  end
+end

data/lib/rubyzen/declarations/assignment_declaration.rb

@@ -0,0 +1,57 @@
+module Rubyzen
+  module Declarations
+    # Represents a local-variable assignment (an +lvasgn+ node), e.g. +x = Repos::Foo.new+.
+    #
+    # @example
+    #   assignment = method.assignments.first
+    #   assignment.name                 #=> "x"
+    #   assignment.value.constructor?   #=> true
+    #   assignment.value.constant_name  #=> "Repos::Foo"
+    #
+    # NOTE: Multiple assignment (+a, b = ...+) is only partially modelled. Each target is
+    # surfaced as its own AssignmentDeclaration with a correct {#name}, but {#value} is +nil+:
+    # in the AST the right-hand side lives on the enclosing +masgn+ node, not on the per-target
+    # +lvasgn+, and which value each variable receives generally cannot be known statically
+    # (e.g. +a, b = build_pair+). If a rule ever needs to trace destructured assignments, model
+    # the shared source explicitly (a +multiple_assignment?+ predicate + +shared_source+) rather
+    # than attributing the shared right-hand side to each variable's {#value}.
+    #
+    class AssignmentDeclaration
+      include Rubyzen::Providers::FilePathProvider
+      include Rubyzen::Providers::LineNumberProvider
+      include Rubyzen::Providers::ClassNameProvider
+      include Rubyzen::Providers::SourceCodeProvider
+
+      # @return [RuboCop::AST::Node]
+      attr_reader :node
+
+      # @return [MethodDeclaration, BlockDeclaration]
+      attr_reader :parent
+
+      # @param node [RuboCop::AST::Node] the +lvasgn+ node
+      # @param parent [MethodDeclaration, BlockDeclaration] the enclosing declaration
+      def initialize(node, parent)
+        @node = node
+        @parent = parent
+      end
+
+      # Returns the name of the assigned local variable.
+      #
+      # @return [String] e.g. +"x"+
+      def name
+        node.children.first.to_s
+      end
+
+      # Returns the assigned value as an expression, or +nil+ when there is no value
+      # node (e.g. the per-variable targets of a multiple assignment, +a, b = foo+).
+      #
+      # @return [ExpressionDeclaration, nil]
+      def value
+        value_node = node.children[1]
+        return nil if value_node.nil?
+
+        ExpressionDeclaration.new(value_node, self)
+      end
+    end
+  end
+end

data/lib/rubyzen/declarations/block_declaration.rb

@@ -17,6 +17,8 @@ module Rubyzen
       include Rubyzen::Providers::RaisesProvider
       include Rubyzen::Providers::SourceCodeProvider
       include Rubyzen::Providers::CallSiteProvider
+      include Rubyzen::Providers::ReturnsProvider
+      include Rubyzen::Providers::AssignmentsProvider
 
       # @return [RuboCop::AST::Node]
       attr_reader :node

data/lib/rubyzen/declarations/call_site_declaration.rb

@@ -13,6 +13,8 @@ module Rubyzen
       include Rubyzen::Providers::LineNumberProvider
       include Rubyzen::Providers::ClassNameProvider
       include Rubyzen::Providers::SourceCodeProvider
+      include Rubyzen::Providers::ArgumentsProvider
+      include Rubyzen::Providers::EnclosingBlocksProvider
 
       # @return [RuboCop::AST::Node]
       attr_reader :node
@@ -41,6 +43,18 @@ module Rubyzen
         node.receiver&.type == :const ? node.receiver.const_name : nil
       end
 
+      # Returns the receiver as an expression, or +nil+ for a receiverless call (e.g. +save+).
+      #
+      # Unlike {#receiver} (which returns a constant-name String), this models the receiver
+      # structurally — constant, constructor, or local variable.
+      #
+      # @return [Rubyzen::Declarations::ExpressionDeclaration, nil]
+      def receiver_expression
+        return nil if node.receiver.nil?
+
+        ExpressionDeclaration.new(node.receiver, self)
+      end
+
       # Returns the called method name.
       #
       # @return [String]

data/lib/rubyzen/declarations/expression_declaration.rb

@@ -0,0 +1,99 @@
+module Rubyzen
+  module Declarations
+    # Represents an arbitrary Ruby value-expression node — the value a method returns,
+    # the receiver of a call, a positional argument, the value of an assignment, and so on.
+    # Wraps any AST node and exposes its "kind" through predicates, so rules can ask
+    # structural questions without touching the raw AST.
+    #
+    # @example
+    #   expr = call_site.receiver_expression
+    #   expr.constructor?     #=> true   (for Repos::Foo.new.bar)
+    #   expr.constant_name    #=> "Repos::Foo"
+    #
+    class ExpressionDeclaration
+      include Rubyzen::Providers::FilePathProvider
+      include Rubyzen::Providers::LineNumberProvider
+      include Rubyzen::Providers::ClassNameProvider
+      include Rubyzen::Providers::SourceCodeProvider
+
+      # @return [RuboCop::AST::Node]
+      attr_reader :node
+
+      # @return [Object] the declaration that produced this expression
+      attr_reader :parent
+
+      # @param node [RuboCop::AST::Node] the value-expression node
+      # @param parent [Object] the declaration that produced this expression
+      def initialize(node, parent)
+        @node = node
+        @parent = parent
+      end
+
+      # Returns a short identifier: the constant, variable, or method name, falling
+      # back to the node type.
+      #
+      # @return [String]
+      def name
+        constant_name || local_variable_name || (method_call? ? method_name : node.type.to_s)
+      end
+
+      # @return [Boolean] true if the expression is a bare constant, e.g. +Repos::Foo+
+      def constant?
+        node.const_type?
+      end
+
+      # @return [Boolean] true if the expression references a local variable
+      def local_variable?
+        node.lvar_type?
+      end
+
+      # @return [Boolean] true if the expression is a method call (a +send+ node)
+      def method_call?
+        node.send_type?
+      end
+
+      # @return [Boolean] true if the expression is a constructor call, e.g. +Repos::Foo.new+
+      def constructor?
+        method_call? && node.method_name == :new
+      end
+
+      # @return [Boolean] true if the expression is a braced Hash literal with at least one pair
+      def hash_literal?
+        node.hash_type? && node.braces? && node.pairs.any?
+      end
+
+      # @return [Boolean] true if the expression is a symbol literal
+      def symbol?
+        node.sym_type?
+      end
+
+      # @return [Boolean] true if the expression is a string literal
+      def string?
+        node.str_type?
+      end
+
+      # Returns the constant name when the expression is a constant or constructs from one.
+      #
+      # @return [String, nil] e.g. +"Repos::Foo"+ for both +Repos::Foo+ and +Repos::Foo.new+
+      def constant_name
+        return node.const_name if constant?
+        return node.receiver.const_name if constructor? && node.receiver&.const_type?
+
+        nil
+      end
+
+      # Returns the called method name when the expression is a method call.
+      #
+      # @return [String, nil]
+      def method_name
+        node.method_name.to_s if method_call?
+      end
+
+      private
+
+      def local_variable_name
+        node.children.first.to_s if local_variable?
+      end
+    end
+  end
+end

data/lib/rubyzen/declarations/method_declaration.rb

@@ -21,6 +21,8 @@ module Rubyzen
       include Rubyzen::Providers::VisibilityProvider
       include Rubyzen::Providers::RescuesProvider
       include Rubyzen::Providers::RaisesProvider
+      include Rubyzen::Providers::ReturnsProvider
+      include Rubyzen::Providers::AssignmentsProvider
 
       # @return [RuboCop::AST::Node]
       attr_reader :node

data/lib/rubyzen/declarations/return_declaration.rb

@@ -0,0 +1,51 @@
+module Rubyzen
+  module Declarations
+    # Represents a single point at which a method or block yields a value: the
+    # implicit final expression of its body, or an explicit +return+ statement.
+    #
+    # @example
+    #   ret = method.returns.first
+    #   ret.explicit?                 #=> false
+    #   ret.expression.hash_literal?  #=> true
+    #
+    class ReturnDeclaration
+      include Rubyzen::Providers::FilePathProvider
+      include Rubyzen::Providers::LineNumberProvider
+      include Rubyzen::Providers::ClassNameProvider
+      include Rubyzen::Providers::SourceCodeProvider
+
+      # @return [RuboCop::AST::Node] the +return+ node, or the implicit final-expression node
+      attr_reader :node
+
+      # @return [MethodDeclaration, BlockDeclaration] the declaration that returns this value
+      attr_reader :parent
+
+      # @param node [RuboCop::AST::Node] the +return+ node, or the implicit final-expression node
+      # @param parent [MethodDeclaration, BlockDeclaration] the enclosing declaration
+      def initialize(node, parent)
+        @node = node
+        @parent = parent
+      end
+
+      # @return [Boolean] true if this is an explicit +return+ statement
+      def explicit?
+        node.return_type?
+      end
+
+      # @return [Boolean] true if this is the implicit final expression of the body
+      def implicit?
+        !explicit?
+      end
+
+      # The value expression being returned.
+      #
+      # @return [ExpressionDeclaration, nil] +nil+ for a bare +return+ with no value
+      def expression
+        value_node = explicit? ? node.children.first : node
+        return nil if value_node.nil?
+
+        ExpressionDeclaration.new(value_node, self)
+      end
+    end
+  end
+end

data/lib/rubyzen/providers/arguments_provider.rb

@@ -0,0 +1,15 @@
+module Rubyzen
+  module Providers
+    # Provides the arguments passed at a call site (or macro), as expressions.
+    module ArgumentsProvider
+      # @return [Rubyzen::Collections::ArgumentsCollection]
+      def arguments
+        Collections::ArgumentsCollection.new(
+          node.arguments.map do |argument_node|
+            Declarations::ExpressionDeclaration.new(argument_node, self)
+          end
+        )
+      end
+    end
+  end
+end

data/lib/rubyzen/providers/assignments_provider.rb

@@ -0,0 +1,15 @@
+module Rubyzen
+  module Providers
+    # Provides local-variable assignments within a method or block.
+    module AssignmentsProvider
+      # @return [Rubyzen::Collections::AssignmentsCollection]
+      def assignments
+        Collections::AssignmentsCollection.new(
+          node.each_descendant(:lvasgn).map do |assignment_node|
+            Declarations::AssignmentDeclaration.new(assignment_node, self)
+          end
+        )
+      end
+    end
+  end
+end

data/lib/rubyzen/providers/enclosing_blocks_provider.rb

@@ -0,0 +1,16 @@
+module Rubyzen
+  module Providers
+    # Provides the chain of blocks (do..end / { }) that lexically enclose a declaration,
+    # innermost first.
+    module EnclosingBlocksProvider
+      # @return [Rubyzen::Collections::BlocksCollection]
+      def enclosing_blocks
+        Collections::BlocksCollection.new(
+          node.each_ancestor(:block).map do |block_node|
+            Declarations::BlockDeclaration.new(block_node, parent)
+          end
+        )
+      end
+    end
+  end
+end

data/lib/rubyzen/providers/returns_provider.rb

@@ -0,0 +1,49 @@
+module Rubyzen
+  module Providers
+    # Provides the points at which a method or block yields a value: the implicit final
+    # expression of its body, plus every explicit +return+. Each is wrapped in a
+    # {Rubyzen::Declarations::ReturnDeclaration}, which knows how to extract its own value.
+    module ReturnsProvider
+      # @return [Rubyzen::Collections::ReturnsCollection]
+      def returns
+        Collections::ReturnsCollection.new(
+          return_nodes.map do |return_node|
+            Declarations::ReturnDeclaration.new(return_node, self)
+          end
+        )
+      end
+
+      # The value-expression(s) this method or block evaluates to, as a flat collection.
+      # A shortcut for +returns.expressions+.
+      #
+      # @return [Rubyzen::Collections::ExpressionsCollection]
+      def return_expressions
+        returns.expressions
+      end
+
+      private
+
+      # The return points to wrap: the implicit final expression of the body (unless it is
+      # itself an explicit +return+, which is collected separately to avoid double-counting),
+      # followed by every explicit +return+.
+      def return_nodes
+        nodes = []
+        final = implicit_final_node
+        nodes << final unless final.nil?
+        node.each_descendant(:return) { |return_node| nodes << return_node }
+        nodes
+      end
+
+      # The node a body implicitly evaluates to: the last statement of a multi-statement
+      # body (+begin+) or an explicit +begin..end+ (+kwbegin+), otherwise the body itself.
+      # Returns +nil+ when that node is an explicit +return+ (collected separately).
+      def implicit_final_node
+        body = node.body
+        return nil if body.nil?
+
+        final = body.begin_type? || body.kwbegin_type? ? body.children.last : body
+        final unless final.return_type?
+      end
+    end
+  end
+end

data/lib/rubyzen/version.rb

@@ -1,4 +1,4 @@
 module Rubyzen
   # @return [String] the current gem version
-  VERSION = '0.2.0'
+  VERSION = '0.3.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubyzen-lint
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Perry Street Software
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-06-03 00:00:00.000000000 Z
+date: 2026-06-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop-ast
@@ -90,7 +90,7 @@ description: Rubyzen is a modern linter for Ruby that allows you to write archit
   lint rules as unit tests. In the era of AI-generated code, it provides your team
   with deterministic guardrails to keep your codebase clean, maintainable, and consistent
   as it grows.
-email: 
+email:
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -105,6 +105,8 @@ files:
 - lib/rubyzen/assertions/assert_zen_true.rb
 - lib/rubyzen/assertions/zen_assertions.rb
 - lib/rubyzen/cache/parse_cache.rb
+- lib/rubyzen/collections/arguments_collection.rb
+- lib/rubyzen/collections/assignments_collection.rb
 - lib/rubyzen/collections/attributes_collection.rb
 - lib/rubyzen/collections/base_collection.rb
 - lib/rubyzen/collections/blocks_collection.rb
@@ -112,6 +114,7 @@ files:
 - lib/rubyzen/collections/classes_collection.rb
 - lib/rubyzen/collections/constants_collection.rb
 - lib/rubyzen/collections/declaration_collection.rb
+- lib/rubyzen/collections/expressions_collection.rb
 - lib/rubyzen/collections/file_collection.rb
 - lib/rubyzen/collections/macros_collection.rb
 - lib/rubyzen/collections/methods_collection.rb
@@ -120,12 +123,15 @@ files:
 - lib/rubyzen/collections/raises_collection.rb
 - lib/rubyzen/collections/requires_collection.rb
 - lib/rubyzen/collections/rescues_collection.rb
+- lib/rubyzen/collections/returns_collection.rb
 - lib/rubyzen/core.rb
+- lib/rubyzen/declarations/assignment_declaration.rb
 - lib/rubyzen/declarations/attribute_declaration.rb
 - lib/rubyzen/declarations/block_declaration.rb
 - lib/rubyzen/declarations/call_site_declaration.rb
 - lib/rubyzen/declarations/class_declaration.rb
 - lib/rubyzen/declarations/constant_declaration.rb
+- lib/rubyzen/declarations/expression_declaration.rb
 - lib/rubyzen/declarations/file_declaration.rb
 - lib/rubyzen/declarations/if_statement_declaration.rb
 - lib/rubyzen/declarations/macro_declaration.rb
@@ -135,6 +141,7 @@ files:
 - lib/rubyzen/declarations/raise_declaration.rb
 - lib/rubyzen/declarations/require_declaration.rb
 - lib/rubyzen/declarations/rescue_declaration.rb
+- lib/rubyzen/declarations/return_declaration.rb
 - lib/rubyzen/expectation_helpers.rb
 - lib/rubyzen/lint.rb
 - lib/rubyzen/matchers/zen_empty_matcher.rb
@@ -143,12 +150,15 @@ files:
 - lib/rubyzen/minitest.rb
 - lib/rubyzen/parsers/a_s_t_parser.rb
 - lib/rubyzen/project.rb
+- lib/rubyzen/providers/arguments_provider.rb
+- lib/rubyzen/providers/assignments_provider.rb
 - lib/rubyzen/providers/attributes_provider.rb
 - lib/rubyzen/providers/blocks_provider.rb
 - lib/rubyzen/providers/call_site_provider.rb
 - lib/rubyzen/providers/class_name_provider.rb
 - lib/rubyzen/providers/collection_filter_provider.rb
 - lib/rubyzen/providers/constants_provider.rb
+- lib/rubyzen/providers/enclosing_blocks_provider.rb
 - lib/rubyzen/providers/file_path_provider.rb
 - lib/rubyzen/providers/if_statements_provider.rb
 - lib/rubyzen/providers/line_number_provider.rb
@@ -157,6 +167,7 @@ files:
 - lib/rubyzen/providers/raises_provider.rb
 - lib/rubyzen/providers/requires_provider.rb
 - lib/rubyzen/providers/rescues_provider.rb
+- lib/rubyzen/providers/returns_provider.rb
 - lib/rubyzen/providers/source_code_provider.rb
 - lib/rubyzen/providers/visibility_provider.rb
 - lib/rubyzen/rspec.rb
@@ -170,7 +181,7 @@ metadata:
   bug_tracker_uri: https://github.com/perrystreetsoftware/Rubyzen/issues
   documentation_uri: https://perrystreetsoftware.github.io/Rubyzen
   changelog_uri: https://github.com/perrystreetsoftware/Rubyzen/blob/main/CHANGELOG.md
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -185,8 +196,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3.1
-signing_key: 
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
 summary: Architectural linter for Ruby — write lint rules as unit tests
 test_files: []