sorbet-eraser 0.1.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 54913e2de72273efae7221b3dc96923c1b45e7d17020ec47bd9a417bea9a62cc
-  data.tar.gz: 71f3cc0a28acefd20d9a4a1f3a06081a568c5b8276cb1241f34d2bb3e7f64fb8
+  metadata.gz: 5ddbc396f3f164a3d0e67e9cf7046733ce52f792eb0abc17e9f5f056f415cd5e
+  data.tar.gz: 965ef9955b75bba0a2702ea127d5923d7e4b1a55ed2b2e6dca239970adbb0fe1
 SHA512:
-  metadata.gz: 06ca1f48f68eea0d10933f83ffe8ba4b296cda3c87240a5db6704ac27d9d6a12202a46b1af82ee3983ba335d4254f230a8f3d861578556ee76ea3544c551cd70
-  data.tar.gz: 547b88a3fb93e133c69cdd2d05ce684f62cc1650afe836fe9741059d1f567f4704bf11815b3170d8f4df2a9909fcc138fc6d940b45ef5ff615853f93118a2f93
+  metadata.gz: 5deb006431e8e31ed089fe6e8fba281f3c65487fc6996a853b05bb0d9600ff034232e7319fb44912a69dc89b60b160900b9b503a17991d19da2bf02f5803c5f8
+  data.tar.gz: a6a20f8aa21b2a2c9e75a4c7e83db5b28556516296d16f55eedd0113da807cbf0c3a827fbeda7eaf9fb95d2a29a9f0c4ddc9090d638e00469989520d2c492f1d

data/.github/workflows/main.yml

@@ -12,7 +12,7 @@ jobs:
     - uses: actions/checkout@master
     - uses: ruby/setup-ruby@v1
       with:
-        ruby-version: 3.0
+        ruby-version: '3.1'
         bundler-cache: true
     - name: Test
       run: bundle exec rake test

data/CHANGELOG.md

@@ -6,11 +6,25 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) a
 
 ## [Unreleased]
 
+## [0.3.0] - 2023-06-27
+
+### Added
+
+- Support for the `default` and `without_accessors` options for `T::Struct`.
+
+## [0.2.0] - 2023-06-26
+
+### Added
+
+- Better support for `T::Struct` subclasses.
+
 ## [0.1.1] - 2021-11-17
 
 ### Changed
 
 - Require MFA for releasing.
 
-[unreleased]: https://github.com/kddnewton/sorbet-eraser/compare/v0.1.1...HEAD
+[unreleased]: https://github.com/kddnewton/sorbet-eraser/compare/v0.3.0...HEAD
+[0.3.0]: https://github.com/kddnewton/sorbet-eraser/compare/v0.2.0...v0.3.0
+[0.2.0]: https://github.com/kddnewton/sorbet-eraser/compare/v0.1.1...v0.2.0
 [0.1.1]: https://github.com/kddnewton/sorbet-eraser/compare/f6a712...v0.1.1

data/Gemfile.lock

@@ -1,16 +1,19 @@
 PATH
   remote: .
   specs:
-    sorbet-eraser (0.1.1)
+    sorbet-eraser (0.3.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    minitest (5.14.4)
+    minitest (5.18.1)
     rake (13.0.6)
 
 PLATFORMS
+  arm64-darwin-22
   x86_64-darwin-19
+  x86_64-darwin-21
+  x86_64-linux
 
 DEPENDENCIES
   bundler

data/README.md

@@ -27,17 +27,19 @@ Or install it yourself as:
 
 ## Usage
 
-Before any code is loaded that would require a `sorbet-runtime` construct, call `require "sorbet/eraser/autoload"`. This will hook into the autoload process to erase all `sorbet-runtime` code before it gets passed to Ruby to parse.
+There are two ways to use this gem, depending on your needs.
 
-Alternatively, you can programmatically use this gem through the `Sorbet::Eraser.erase(source)` API, where `source` is a string that represents valid Ruby code. Ruby code without the listed constructs will be returned.
+The first is that you can hook into the Ruby compilation process and do just-in-time erasure. To do this — before any code is loaded that would require a `sorbet-runtime` construct — call `require "sorbet/eraser/autoload"`. This will hook into the autoload process to erase all `sorbet-runtime` code before it gets passed to Ruby to parse. This eliminates the need for a build step, but slows down your parse/boot time.
 
-Finally, this gem ships with a CLI that you can use to modify source files. This is useful for development of this gem itself, but could be useful for others to ensure they see what this gem actually will be doing in production. To run it, run:
+The second is that you can preprocess your Ruby files using either the CLI or the Ruby API. With the CLI, you would run:
 
-```sh
+```bash
 bundle exec sorbet-eraser '**/*.rb'
 ```
 
-It accepts any number of filepaths/patterns on the command line and will modify the source files with their erased contents.
+It accepts any number of filepaths/patterns on the command line and will modify the source files with their erased contents.  Alternatively, you can programmatically use this gem through the `Sorbet::Eraser.erase(source)` API, where `source` is a string that represents valid Ruby code. Ruby code without the listed constructs will be returned.
+
+If you used any runtime structures like `T::Struct` or `T::Enum` you'll need a runtime shim. For that, you can add `require "t"` to your codebase, which ships with this gem, or in your gemfile `gem "sorbet-eraser", require: "t"`.
 
 ### Status
 
@@ -50,7 +52,12 @@ Below is a table of the status of each `sorbet-runtime` construct and its curren
 | `mixes_in_class_methods(*)`, `requires_ancestor(*)` | ✅     | Shimmed     |
 | `type_member(*)`, `type_template(*)`                | ✅     | Shimmed     |
 | `class Foo < T::Enum`                               | ✅     | Shimmed     |
+| `class Foo < T::InexactStruct`                      | 🛠     | Shimmed     |
 | `class Foo < T::Struct`                             | 🛠     | Shimmed     |
+| `class Foo < T::ImmutableStruct`                    | 🛠     | Shimmed     |
+| `include T::Props`                                  | 🛠     | Shimmed     |
+| `include T::Props::Serializable`                    | 🛠     | Shimmed     |
+| `include T::Props::Constructor`                     | 🛠     | Shimmed     |
 | `sig`                                               | ✅     | Removed     |
 | `T.absurd(foo)`                                     | ✅     | Shimmed     |
 | `T.assert_type!(foo, bar)`                          | ✅     | `foo`       |
@@ -62,7 +69,12 @@ Below is a table of the status of each `sorbet-runtime` construct and its curren
 | `T.type_alias { foo }`                              | ✅     | Shimmed     |
 | `T.unsafe(foo)`                                     | ✅     | `foo`       |
 
-In the above table:
+In the above table, for `Status`:
+
+* ✅ means that we are confident this is replaced 1:1.
+* 🛠 means there may be APIs that are not entirely supported. If you run into something that is missing, please open an issue.
+
+In the above table, for `Replacement`:
 
 * `Shimmed` means that this gem provides a replacement module that will simply do nothing when its respective methods are called. We do this in order to maintain the same interface in the case that someone is doing runtime reflection. Also because anything that is shimmed will not be called that much/will not be in a hot path so performance is not really a consideration for those cases.
 * `Removed` means that the construct is removed entirely from the source.

data/lib/sorbet/eraser/parser.rb

@@ -59,7 +59,10 @@ module Sorbet
         end
 
         def to_s
-          @to_s ||= "<#{event} #{body.map(&:to_s).join(" ")}>"
+          @repr ||= begin
+            children = body.map { |child| child.is_a?(Array) ? child.map(&:to_s) : child }
+            "<#{event} #{children.join(" ")}>"
+          end
         end
       end
 
@@ -108,25 +111,83 @@ module Sorbet
         line_counts[lineno - 1][column]
       end
 
+      def find_loc(args)
+        ranges = []
+
+        args.each do |arg|
+          case arg
+          when Node
+            ranges << arg.range if arg.range
+          when Array
+            ranges << find_loc(arg)
+          end
+        end
+
+        case ranges.length
+        when 0
+          nil
+        when 1
+          ranges.first
+        else
+          ranges.first.begin...ranges.last.end
+        end
+      end
+
       # Loop through all of the scanner events and define a basic method that
       # wraps everything into a node class.
       SCANNER_EVENTS.each do |event|
         define_method(:"on_#{event}") do |value|
-          range = loc.then { |start| start..(start + (value&.size || 0)) }
+          range = loc.then { |start| start...(start + (value&.size || 0)) }
           Node.new(:"@#{event}", [value], range)
         end
       end
 
+      # Better location information for aref.
+      def on_aref(recv, arg)
+        rend = arg.range.end + source[arg.range.end..].index("]") + 1
+        Node.new(:aref, [recv, arg], recv.range.begin...rend)
+      end
+
+      # Better location information for arg_paren.
+      def on_arg_paren(arg)
+        rbegin = source[..arg.range.begin].rindex("(")
+        rend = arg.range.end + source[arg.range.end..].index(")") + 1
+        Node.new(:arg_paren, [arg], rbegin...rend)
+      end
+
+      # Better location information for brace_block.
+      def on_brace_block(params, body)
+        rbegin = source[...(params || body).range.begin].rindex("{")
+        rend = body.range.end + source[body.range.end..].index("}") + 1
+        Node.new(:brace_block, [params, body], rbegin...rend)
+      end
+
+      # Better location information for do_block.
+      def on_do_block(params, body)
+        rbegin = source[...(params || body).range.begin].rindex("do")
+        rend = body.range.end + source[body.range.end..].index("end") + 3
+        Node.new(:do_block, [params, body], rbegin...rend)
+      end
+
+      # Track the parsing errors for nicer error messages.
+      def on_parse_error(error)
+        errors << "line #{lineno}: #{error}"
+      end
+
       # Loop through the parser events and generate a method for each event. If
       # it's one of the _new methods, then use arrays like SexpBuilderPP. If
       # it's an _add method then just append to the array. If it's a normal
       # method, then create a new node and determine its bounds.
+      handled = private_instance_methods(false)
+
       PARSER_EVENT_TABLE.each do |event, arity|
+        next if handled.include?(:"on_#{event}")
+
         if event =~ /\A(.+)_new\z/ && event != :assoc_new
           prefix = $1.to_sym
 
           define_method(:"on_#{event}") do
-            Node.new(prefix, [], loc.then { |start| start..start })
+            Node.new(prefix, [], nil)
           end
         elsif event =~ /_add\z/
           define_method(:"on_#{event}") do |node, value|
@@ -134,29 +195,17 @@ module Sorbet
               if node.body.empty?
                 value.range
               else
-                (node.range.begin..value.range.end)
+                (node.range.begin...value.range.end)
               end
 
             node.class.new(node.event, node.body + [value], range)
           end
-        elsif event == :parse_error
-          # skip this, as we're going to define it below
         else
           define_method(:"on_#{event}") do |*args|
-            first, *, last = args.grep(Node).map(&:range)
-
-            first ||= loc.then { |start| start..start }
-            last ||= first
-
-            Node.new(event, args, first.begin..[last.end, loc].max)
+            Node.new(event, args, find_loc(args))
           end
         end
       end
-
-      # Track the parsing errors for nicer error messages.
-      def on_parse_error(error)
-        errors << "line #{lineno}: #{error}"
-      end
     end
   end
 end

data/lib/sorbet/eraser/patterns.rb

@@ -89,75 +89,104 @@ module Sorbet
         end
       end
 
+      # T.must foo => foo
+      # T.reveal_type foo => foo
+      # T.unsafe foo => foo
+      class TMustNoParensPattern < Pattern
+        def replace(segment)
+          segment.gsub(/(T\s*\.(?:must|reveal_type|unsafe)\s*)(.+)/) do
+            "#{blank($1)}#{$2}"
+          end
+        end
+      end
+
       def on_method_add_arg(call, arg_paren)
-        # T.must(foo)
-        # T.reveal_type(foo)
-        # T.unsafe(foo)
-        if call.match?(/<call <var_ref <@const T>> <@period \.> <@ident (?:must|reveal_type|unsafe)>>/) &&
-          arg_paren.match?(/<arg_paren <args_add_block <args .+> false>>/)
+        if call.match?(/<call <var_ref <@const T>> <@period \.> <@ident (?:must|reveal_type|unsafe)>>/) && arg_paren.match?(/<arg_paren <args_add_block <args .+> false>>/)
+          # T.must(foo)
+          # T.reveal_type(foo)
+          # T.unsafe(foo)
           patterns << TOneArgMethodCallParensPattern.new(call.range.begin...arg_paren.range.end)
+        elsif call.match?(/\A<call <var_ref <@const T>> <@period \.> <@ident (?:assert_type!|cast|let)>>\z/) && arg_paren.match?(/<arg_paren <args_add_block <args .+> false>>/)
+          # T.assert_type!(foo, bar)
+          # T.cast(foo, bar)
+          # T.let(foo, bar)
+          patterns << TTwoArgMethodCallParensPattern.new(
+            call.range.begin...arg_paren.range.end,
+            comma: arg_paren.body[0].body[0].body[0].range.end - call.range.begin
+          )
+        elsif call.match?(/<call <var_ref <@const T>> <@period \.> <@ident bind>>/) && arg_paren.match?(/<arg_paren <args_add_block <args <var_ref <@kw self>> .+> false>>/)
+          # T.bind(self, foo)
+          patterns << TTwoArgMethodCallParensPattern.new(
+            call.range.begin...arg_paren.range.end,
+            comma: arg_paren.body[0].body[0].body[0].range.end - call.range.begin
+          )
+        elsif call.match?(/<fcall <@ident (?:abstract|final|interface)!>>/) && arg_paren.match?("<args >")
+          # abstract!
+          # final!
+          # interface!
+          patterns << DeclarationPattern.new(call.range.begin...arg_paren.range.end)
+        elsif call.match?("<fcall <@ident mixes_in_class_methods>>") && arg_paren.match?(/<arg_paren <args_add_block <args <.+>>> false>>/)
+          # mixes_in_class_methods(foo)
+          patterns << MixesInClassMethodsPattern.new(call.range.begin...arg_paren.range.end)
         end
 
-        # T.assert_type!(foo, bar)
-        # T.cast(foo, bar)
-        # T.let(foo, bar)
-        if call.match?(/\A<call <var_ref <@const T>> <@period \.> <@ident (?:assert_type!|cast|let)>>\z/) &&
-          arg_paren.match?(/<arg_paren <args_add_block <args .+> false>>/)
-          patterns <<
-            TTwoArgMethodCallParensPattern.new(
-              call.range.begin...arg_paren.range.end,
-              comma: arg_paren.body[0].body[0].body[0].range.end - call.range.begin
-            )
-        end
+        super
+      end
 
-        # T.bind(self, foo)
-        if call.match?(/<call <var_ref <@const T>> <@period \.> <@ident bind>>/) &&
-          arg_paren.match?(/<arg_paren <args_add_block <args <var_ref <@kw self>> .+> false>>/)
-          patterns <<
-            TTwoArgMethodCallParensPattern.new(
-              call.range.begin...arg_paren.range.end,
-              comma: arg_paren.body[0].body[0].body[0].range.end - call.range.begin
-            )
+      # prop :foo, String => prop :foo
+      # const :foo, String => const :foo
+      class PropWithoutOptionsPattern < Pattern
+        def replace(segment)
+          segment.dup.tap do |replacement|
+            range = metadata.fetch(:comma)..-1
+            replacement[range] = blank(replacement[range])
+          end
         end
+      end
 
-        # abstract!
-        # final!
-        # interface!
-        if call.match?(/<fcall <@ident (?:abstract|final|interface)!>>/) &&
-          arg_paren.match?("<args >")
-          patterns << DeclarationPattern.new(call.range.begin...arg_paren.range.end)
-        end
+      # prop :foo, String, default: "" => prop :foo, default: ""
+      # const :foo, String, default: "" => const :foo, default: ""
+      class PropWithOptionsPattern < Pattern
+        def replace(segment)
+          segment.dup.tap do |replacement|
+            first_comma = metadata.fetch(:first_comma)
+            second_comma = metadata.fetch(:second_comma)
 
-        # mixes_in_class_methods(foo)
-        if call.match?("<fcall <@ident mixes_in_class_methods>>") &&
-          arg_paren.match?(/<arg_paren <args_add_block <args <.+>>> false>>/)
-          patterns << MixesInClassMethodsPattern.new(call.range.begin...arg_paren.range.end)
+            range = (first_comma + 1)..second_comma
+            replacement[range] = blank(replacement[range])
+          end
         end
-
-        super
       end
 
-      # T.must foo => foo
-      # T.reveal_type foo => foo
-      # T.unsafe foo => foo
-      class TMustNoParensPattern < Pattern
-        def replace(segment)
-          segment.gsub(/(T\s*\.(?:must|reveal_type|unsafe)\s*)(.+)/) do
-            "#{blank($1)}#{$2}"
+      def on_command(ident, args_add_block)
+        if ident.match?(/<@ident (?:const|prop)>/)
+          if args_add_block.match?(/<args_add_block <args <symbol_literal <symbol <@ident .+?>>> <.+> <bare_assoc_hash .+> false>/)
+            # prop :foo, String, default: ""
+            # const :foo, String, default: ""
+            patterns << PropWithOptionsPattern.new(
+              ident.range.begin..args_add_block.range.end,
+              first_comma: args_add_block.body[0].body[0].range.end - ident.range.begin,
+              second_comma: args_add_block.body[0].body[1].range.end - ident.range.begin
+            )
+          elsif args_add_block.match?(/<args_add_block <args <symbol_literal <symbol <@ident .+?>>> <.+> false>/)
+            # prop :foo, String
+            # const :foo, String
+            patterns << PropWithoutOptionsPattern.new(
+              ident.range.begin..args_add_block.range.end,
+              comma: args_add_block.body[0].body[0].range.end - ident.range.begin
+            )
           end
         end
+
+        super
       end
 
       def on_command_call(var_ref, period, ident, args_add_block)
-        if var_ref.match?("<var_ref <@const T>>") && period.match?("<@period .>")
+        if var_ref.match?("<var_ref <@const T>>") && period.match?("<@period .>") && ident.match?(/<@ident (?:must|reveal_type|unsafe)>/) && args_add_block.match?(/<args_add_block <args <.+>> false>/) && args_add_block.body[0].body.length == 1
           # T.must foo
           # T.reveal_type foo
           # T.unsafe foo
-          if ident.match?(/<@ident (?:must|reveal_type|unsafe)>/) &&
-            args_add_block.match?(/<args_add_block <args <.+>> false>/) &&
-            args_add_block.body[0].body.length == 1
-            patterns << TMustNoParensPattern.new(var_ref.range.begin...args_add_block.range.end)
-          end
+          patterns << TMustNoParensPattern.new(var_ref.range.begin..args_add_block.range.end)
         end
 
         super
@@ -172,10 +201,22 @@ module Sorbet
         end
       end
 
+      # sig do foo end =>
+      class SigBlockPattern < Pattern
+        def replace(segment)
+          segment.gsub(/(sig\s*do.+end)(.*)/m) do
+            "#{blank($1)}#{$2}"
+          end
+        end
+      end
+
       def on_stmts_add(node, value)
-        # sig { foo }
         if value.match?(/<method_add_block <method_add_arg <fcall <@ident sig>> <args >> <brace_block  <stmts .+>>>/)
+          # sig { foo }
           patterns << SigBracesPattern.new(value.range)
+        elsif value.match?(/<method_add_block <method_add_arg <fcall <@ident sig>> <args >> <do_block  <bodystmt .+>>>/)
+          # sig do foo end
+          patterns << SigBlockPattern.new(value.range)
         end
 
         super

data/lib/sorbet/eraser/version.rb

@@ -2,6 +2,6 @@
 
 module Sorbet
   module Eraser
-    VERSION = "0.1.1"
+    VERSION = "0.3.0"
   end
 end

data/lib/t/enum.rb

@@ -226,7 +226,7 @@ module T
       @values.freeze
       @mapping.freeze
 
-      orphaned_instances = T.must(@values) - @mapping.values
+      orphaned_instances = @values - @mapping.values
       if !orphaned_instances.empty?
         raise "Enum values must be assigned to constants: #{orphaned_instances.map {|v| v.instance_variable_get('@serialized_val')}}"
       end

data/lib/t/props.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module T
+  # Here is the place we don't match up to sorbet because we simply don't
+  # implement as much as they do in the runtime. If there are pieces of this
+  # that folks would like implemented I'd be happy to include them. This is here
+  # just to get a baseline for folks using T::Struct with basic const/prop
+  # calls.
+  module Props
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    # Here we're implementing a very basic version of the prop/const methods
+    # that are in sorbet-runtime. These are only here to allow consumers to call
+    # them and not raise errors and for bookkeeping.
+    module ClassMethods
+      def props
+        @props ||= []
+      end
+
+      def prop(name, rules = {})
+        create_prop(name, rules)
+        attr_accessor(name) unless rules[:without_accessors]
+      end
+
+      def const(name, rules = {})
+        create_prop(name, rules)
+        attr_reader(name) unless rules[:without_accessors]
+      end
+
+      private
+
+      def create_prop(name, rules)
+        props << [name, rules]
+        props.sort_by!(&:first)
+      end
+    end
+
+    # Here we're going to check against the props that have been defined on the
+    # class level and set appropriate values.
+    def initialize(hash = {})
+      self.class.props.each do |name, rules|
+        if hash.key?(name)
+          instance_variable_set("@#{name}", hash.delete(name))
+        elsif rules.key?(:default)
+          instance_variable_set("@#{name}", rules[:default])
+        else
+          raise ArgumentError, "missing keyword: #{name}"
+        end
+      end
+
+      raise ArgumentError, "unknown keyword: #{hash.keys.first}" unless hash.empty?
+    end
+
+    # This module is entirely empty because we haven't implemented anything from
+    # sorbet-runtime here.
+    module Serializable
+    end
+
+    # This is empty for the same reason.
+    module Constructor
+    end
+  end
+end

data/lib/t/struct.rb

@@ -1,12 +1,52 @@
 # frozen_string_literal: true
 
 module T
+  # This is the actual parent class of T::Struct. It's here to match up the
+  # inheritance chain in case someone is doing reflection.
+  class InexactStruct
+    include Props
+    include Props::Serializable
+    include Props::Constructor
+  end
+
   # This is a shim for the T::Struct class because since you're actually
   # inheriting from the class there's not really a way to remove it from the
   # source.
-  class Struct
-    # include T::Props
-    # include T::Props::Serializable
-    # include T::Props::Constructor
+  class Struct < InexactStruct
+    def self.inherited(child)
+      super(child)
+
+      child.define_singleton_method(:inherited) do |grandchild|
+        super(grandchild)
+        raise "#{grandchild.name} is a subclass of T::Struct and cannot be subclassed"
+      end
+    end
+  end
+
+  class ImmutableStruct < InexactStruct
+    def self.inherited(child)
+      super(child)
+  
+      child.define_singleton_method(:inherited) do |grandchild|
+        super(grandchild)
+        raise "#{grandchild.name} is a subclass of T::ImmutableStruct and cannot be subclassed"
+      end
+    end
+  
+    def initialize(hash = {})
+      super
+      freeze
+    end
+  
+    # Matches the signature in Props, but raises since this is an immutable struct and only const is allowed
+    def self.prop(name, rules = {})
+      return super if rules[:immutable]
+  
+      raise "Cannot use `prop` in #{self.name} because it is an immutable struct. Use `const` instead"
+    end
+  
+    def with(changed_props)
+      raise "Cannot use `with` in #{self.class.name} because it is an immutable struct"
+    end
   end
 end

data/lib/t.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "t/enum"
+require "t/props"
 require "t/struct"
 
 # For some constructs, it doesn't make as much sense to entirely remove them

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-eraser
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Kevin Newton
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-11-18 00:00:00.000000000 Z
+date: 2023-06-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -80,6 +80,7 @@ files:
 - lib/sorbet/eraser/version.rb
 - lib/t.rb
 - lib/t/enum.rb
+- lib/t/props.rb
 - lib/t/struct.rb
 - sorbet-eraser.gemspec
 homepage: https://github.com/kddnewton/sorbet-eraser
@@ -87,7 +88,7 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/kddnewton/sorbet-eraser/issues
-  changelog_uri: https://github.com/kddnewton/sorbet-eraser/blob/v0.1.1/CHANGELOG.md
+  changelog_uri: https://github.com/kddnewton/sorbet-eraser/blob/v0.3.0/CHANGELOG.md
   source_code_uri: https://github.com/kddnewton/sorbet-eraser
   rubygems_mfa_required: 'true'
 post_install_message:
@@ -105,7 +106,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
+rubygems_version: 3.4.1
 signing_key:
 specification_version: 4
 summary: Erase all traces of sorbet-runtime code.