sorbet-eraser 0.3.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cbfc0c7e028bd4e712e64d29a7c74e65d45937087a3f510f01afab434250b3d5
-  data.tar.gz: 6a89286f19c7ae6ed8e838beba49fcb799426fb14a58ed4b5c3b32d9b59935dc
+  metadata.gz: 420576226d037471f75759599ea53397cd251dd546431b24e9d3cf556285902a
+  data.tar.gz: 7c6d09a382019245254f55d0a9eff1b4cd2430d066c364efde59567ada2f56c0
 SHA512:
-  metadata.gz: efe378c67fa4749ac7461496d895c69e89ef28ca1f71d6c9385952a96320e8849a6ed15604d8219560903d047b0f9a1eda60fb938b07dc633f55da95a1082119
-  data.tar.gz: af3a02739fbbfdec2fd98c1bbb749b74a2a7f088c237f339966b186ad4b565e8cd353bac2bd4989f2fba8ae7435a096a058c4aca5cded0f209113826e284e994
+  metadata.gz: 5478636318a06fe00d279813bd724659d6653efef7364ea583e11566e455cf9528e8c14338dfdab11298e329225ca9ef2c0847df4125b0edea09f4ca5a953452
+  data.tar.gz: 26d79c3b183ef5f7a629205b94e61a09862db83ca50884d68e1e7d22954b1543355787e7fd798223ff8b483bdbdcbb5c14a49959d72f19a12bfcedd13f8f51e8

data/.gitignore

@@ -6,3 +6,5 @@
 /pkg/
 /spec/reports/
 /tmp/
+
+test.rb

data/CHANGELOG.md

@@ -6,6 +6,22 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) a
 
 ## [Unreleased]
 
+## [0.5.0] - 2023-07-13
+
+### Added
+
+- Replace `typed: strict` comments with empty comments.
+- Replace all `typed:` sigil comments with empty comments instead of `typed: ignore`. Do this because `typed: ignore` longer than other options, which can cause issues with byte ranges, and violates an assumption by this gem that it is only erasing, not adding content.
+- Add a `--verify` option to the CLI to ensure output is valid Ruby.
+- Enhance `sorbet/eraser/autoload` to hook into `load_iseq` even if bootsnap is not present.
+
+## [0.4.0] - 2023-07-03
+
+### Added
+
+- `require "t"` now requires a file that only requires `"sorbet/eraser/t"`, so they are effectively the same thing. If you're in a situation where you need to load a different `"t"`, then you can manually require `"sorbet/eraser/t"` and it should work.
+- Replace all `typed:` comments with `typed: ignore`.
+
 ## [0.3.1] - 2023-06-27
 
 ### Added
@@ -34,7 +50,10 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) a
 
 - Require MFA for releasing.
 
-[unreleased]: https://github.com/kddnewton/sorbet-eraser/compare/v0.3.0...HEAD
+[unreleased]: https://github.com/kddnewton/sorbet-eraser/compare/v0.4.1...HEAD
+[0.4.1]: https://github.com/kddnewton/sorbet-eraser/compare/v0.4.0...v0.4.1
+[0.4.0]: https://github.com/kddnewton/sorbet-eraser/compare/v0.3.1...v0.4.0
+[0.3.1]: https://github.com/kddnewton/sorbet-eraser/compare/v0.3.0...v0.3.1
 [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,7 +1,7 @@
 PATH
   remote: .
   specs:
-    sorbet-eraser (0.3.1)
+    sorbet-eraser (0.5.0)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -12,6 +12,8 @@ Sometimes, you want to use Sorbet for development, but don't want to run `sorbet
 To handle these use cases, `sorbet-eraser` provides a way to erase all traces of `sorbet-runtime` code from your source code. This means that you can use Sorbet for development, but not have to worry about `sorbet-runtime` in production. For example,
 
 ```ruby
+# typed: true
+
 class HelloWorld
   extend T::Sig
 
@@ -25,6 +27,8 @@ end
 will be transformed into
 
 ```ruby
+#
+
 class HelloWorld
                
 
@@ -93,27 +97,28 @@ Below is a table of the status of each `sorbet-runtime` construct and its curren
 
 | Construct                                           | Status | Replacement |
 | --------------------------------------------------- | ------ | ----------- |
-| `extend T::*`                                       | ✅     | Shimmed     |
-| `abstract!`, `final!`, `interface!`, `sealed!`      | ✅     | Shimmed     |
-| `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`       |
-| `T.bind(self, foo)`                                 | ✅     | `self`      |
-| `T.cast(foo, bar)`                                  | ✅     | `foo`       |
-| `T.let(foo, bar)`                                   | ✅     | `foo`       |
-| `T.must(foo)`                                       | ✅     | `foo`       |
-| `T.reveal_type(foo)`                                | ✅     | `foo`       |
-| `T.type_alias { foo }`                              | ✅     | Shimmed     |
-| `T.unsafe(foo)`                                     | ✅     | `foo`       |
+| `# typed: foo`                                      | ✅      | `#        ` |
+| `extend T::*`                                       | ✅      | Shimmed     |
+| `abstract!`, `final!`, `interface!`, `sealed!`      | ✅      | Shimmed     |
+| `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`       |
+| `T.bind(self, foo)`                                 | ✅      | `self`      |
+| `T.cast(foo, bar)`                                  | ✅      | `foo`       |
+| `T.let(foo, bar)`                                   | ✅      | `foo`       |
+| `T.must(foo)`                                       | ✅      | `foo`       |
+| `T.reveal_type(foo)`                                | ✅      | `foo`       |
+| `T.type_alias { foo }`                              | ✅      | Shimmed     |
+| `T.unsafe(foo)`                                     | ✅      | `foo`       |
 
 In the above table, for `Status`:
 

data/lib/sorbet/eraser/autoload.rb

@@ -2,21 +2,22 @@
 
 require "sorbet/eraser"
 
-# Hook into bootsnap so that before the source is compiled through
-# RubyVM::InstructionSequence it gets erased through the eraser.
-if RubyVM::InstructionSequence.method_defined?(:load_iseq)
-  load_iseq, = RubyVM::InstructionSequence.method(:load_iseq).source_location
-
-  if load_iseq.include?("/bootsnap/")
-    module Sorbet::Eraser::Patch
-      def input_to_storage(contents, filepath)
-        erased = Sorbet::Eraser.erase(contents)
-        RubyVM::InstructionSequence.compile(erased, filepath, filepath).to_binary
-      rescue SyntaxError
-        raise ::Bootsnap::CompileCache::Uncompilable, "syntax error"
-      end
+if RubyVM::InstructionSequence.method_defined?(:load_iseq) &&
+   RubyVM::InstructionSequence.method(:load_iseq).source_location[0].include?("/bootsnap/")
+  # If the load_iseq method is defined by bootsnap, then we need to override it.
+  module Sorbet::Eraser::Patch
+    def input_to_storage(contents, filepath)
+      super(Sorbet::Eraser.erase(contents), filepath)
     end
+  end
 
-    Bootsnap::CompileCache::ISeq.singleton_class.prepend(Sorbet::Eraser::Patch)
+  Bootsnap::CompileCache::ISeq.singleton_class.prepend(Sorbet::Eraser::Patch)
+else
+  # Otherwise if the method isn't defined by bootsnap, then we'll define it
+  # ourselves.
+  def (RubyVM::InstructionSequence).load_iseq(filepath)
+    contents = File.read(filepath)
+    erased = Sorbet::Eraser.erase(contents)
+    RubyVM::InstructionSequence.compile(erased, filepath, filepath)
   end
 end

data/lib/sorbet/eraser/cli.rb

@@ -7,9 +7,10 @@ module Sorbet
     class CLI
       POOL_SIZE = 4
 
-      attr_reader :filepaths
+      attr_reader :verify, :filepaths
 
-      def initialize(filepaths)
+      def initialize(verify, filepaths)
+        @verify = verify
         @filepaths = filepaths
       end
 
@@ -28,20 +29,36 @@ module Sorbet
                 break if filepath == :eoq
                 process(filepath)
               end
-            end
+            end.tap { |thread| thread.abort_on_exception = true }
           end
 
         workers.each(&:join)
       end
 
       def self.start(argv)
-        new(argv.flat_map { |pattern| Dir.glob(pattern) }).start
+        verify = false
+
+        if argv.first == "--verify"
+          verify = true
+          argv.shift
+        end
+
+        filepaths = []
+        argv.each { |pattern| filepaths.concat(Dir.glob(pattern)) }
+
+        new(verify, filepaths).start
       end
 
       private
 
       def process(filepath)
-        File.write(filepath, Eraser.erase(File.read(filepath)))
+        contents = Eraser.erase(File.read(filepath))
+
+        if verify && Ripper.sexp_raw(contents).nil?
+          warn("Internal error while parsing #{filepath}")
+        else
+          File.write(filepath, contents)
+        end
       rescue Parser::ParsingError => error
         warn("Could not parse #{filepath}: #{error}")
       rescue => error

data/lib/sorbet/eraser/parser.rb

@@ -86,7 +86,7 @@ module Sorbet
             @line_counts << MultiByteString.new(last_index, line)
           end
 
-          last_index += line.size
+          last_index += line.bytesize
         end
 
         @errors = []
@@ -136,18 +136,18 @@ module Sorbet
 
       # Better location information for aref.
       def on_aref(recv, arg)
-        rend = arg.range.end + source[arg.range.end..].index("]") + 1
+        rend = arg.range.end + source.byteslice(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)
         if arg
-          rbegin = source[..arg.range.begin].rindex("(")
-          rend = arg.range.end + source[arg.range.end..].index(")") + 1
+          rbegin = source.byteslice(..arg.range.begin).rindex("(")
+          rend = arg.range.end + source.byteslice(arg.range.end..).index(")") + 1
           Node.new(:arg_paren, [arg], rbegin...rend)
         else
-          segment = source[..loc]
+          segment = source.byteslice(..loc)
           Node.new(:arg_paren, [arg], segment.rindex("(")...(segment.rindex(")") + 1))
         end
       end
@@ -159,11 +159,11 @@ module Sorbet
       def on_array(arg)
         case arg&.event
         when nil
-          segment = source[..loc]
+          segment = source.byteslice(..loc)
           Node.new(:array, [arg], segment.rindex("[")...(segment.rindex("]") + 1))
         when :qsymbols, :qwords, :symbols, :words
-          rbegin = source[...arg.range.begin].rindex(LISTS.fetch(arg.event))
-          rend = source[arg.range.end..].index(TERMINATORS.fetch(source[rbegin + 2]) { source[rbegin + 2] }) + arg.range.end + 1
+          rbegin = source.byteslice(...arg.range.begin).rindex(LISTS.fetch(arg.event))
+          rend = source.byteslice(arg.range.end..).index(TERMINATORS.fetch(source.byteslice(rbegin + 2)) { source.byteslice(rbegin + 2) }) + arg.range.end + 1
           Node.new(:array, [arg], rbegin...rend)
         else
           Node.new(:array, [arg], arg.range)
@@ -173,14 +173,14 @@ module Sorbet
       # Better location information for brace_block.
       def on_brace_block(params, body)
         if params || body.range
-          rbegin = source[...(params || body).range.begin].rindex("{")
+          rbegin = source.byteslice(...(params || body).range.begin).rindex("{")
 
           rend = body.range&.end || params.range.end
-          rend = rend + source[rend..].index("}") + 1
+          rend = rend + source.byteslice(rend..).index("}") + 1
 
           Node.new(:brace_block, [params, body], rbegin...rend)
         else
-          segment = source[..loc]
+          segment = source.byteslice(..loc)
           Node.new(:brace_block, [params, body], segment.rindex("{")...(segment.rindex("}") + 1))
         end
       end
@@ -188,14 +188,14 @@ module Sorbet
       # Better location information for do_block.
       def on_do_block(params, body)
         if params || body.range
-          rbegin = source[...(params || body).range.begin].rindex("do")
+          rbegin = source.byteslice(...(params || body).range.begin).rindex("do")
 
           rend = body.range&.end || params.range.end
-          rend = rend + source[rend..].index("end") + 3
+          rend = rend + source.byteslice(rend..).index("end") + 3
 
           Node.new(:do_block, [params, body], rbegin...rend)
         else
-          segment = source[..loc]
+          segment = source.byteslice(..loc)
           Node.new(:do_block, [params, body], segment.rindex("do")...(segment.rindex("end") + 3))
         end
       end
@@ -205,7 +205,7 @@ module Sorbet
         if arg
           Node.new(:hash, [arg], arg.range)
         else
-          segment = source[..loc]
+          segment = source.byteslice(..loc)
           Node.new(:hash, [arg], segment.rindex("{")...(segment.rindex("}") + 1))
         end
       end
@@ -213,7 +213,7 @@ module Sorbet
       # Track the open heredocs so we can replace the string literal ranges with
       # the range of their declarations.
       def on_heredoc_beg(value)
-        range = loc.then { |start| start...(start + value.size) }
+        range = loc.then { |start| start...(start + value.bytesize) }
         heredocs << [range, value, nil]
 
         Node.new(:@heredoc_beg, [value], range)
@@ -222,7 +222,7 @@ module Sorbet
       # If a heredoc ends, then the next string literal event will be the
       # heredoc.
       def on_heredoc_end(value)
-        range = loc.then { |start| start...(start + value.size) }
+        range = loc.then { |start| start...(start + value.bytesize) }
         heredocs.find { |(_, beg_arg, end_arg)| beg_arg.include?(value.strip) && end_arg.nil? }[2] = value
 
         Node.new(:@heredoc_end, [value], range)
@@ -239,7 +239,7 @@ module Sorbet
         if heredoc = heredocs.find { |(_, _, end_arg)| end_arg }
           Node.new(:string_literal, [arg], heredocs.delete(heredoc)[0])
         else
-          Node.new(:string_literal, [arg], arg.range)
+          Node.new(:string_literal, [arg], (arg.range.begin - 1)...(arg.range.end + 1))
         end
       end
 
@@ -251,7 +251,7 @@ module Sorbet
         next if handled.include?(:"on_#{event}")
 
         define_method(:"on_#{event}") do |value|
-          range = loc.then { |start| start...(start + (value&.size || 0)) }
+          range = loc.then { |start| start...(start + (value&.bytesize || 0)) }
           Node.new(:"@#{event}", [value], range)
         end
       end

data/lib/sorbet/eraser/patterns.rb

@@ -13,14 +13,11 @@ module Sorbet
         end
 
         def erase(source)
-          original = source[range]
-          replaced = replace(original)
+          encoding = source.encoding
+          source.force_encoding(Encoding::ASCII_8BIT)
 
-          # puts "Replacing #{original} (len=#{original.length}) " \
-          #      "with #{replaced} (len=#{replaced.length})"
-
-          source[range] = replaced
-          source
+          source[range] = replace(source[range])
+          source.force_encoding(encoding)
         end
 
         def blank(segment)
@@ -57,11 +54,11 @@ module Sorbet
           # We can't really rely on regex here because commas have semantic
           # meaning and you might have some in the value of the first argument.
           comma = metadata.fetch(:comma)
-          pre, post = 0..comma, (comma + 1)..-1
+          pre, post = 0...comma, comma..-1
 
           replacement[pre] =
-            replacement[pre].gsub(/(T\s*\.(?:assert_type!|bind|cast|let)\(\s*)(.+)(\s*,)(.*)/m) do
-              "#{blank($1)}#{$2}#{blank($3)}#{$4}"
+            replacement[pre].gsub(/(T\s*\.(?:assert_type!|bind|cast|let)\(\s*)(.+)/m) do
+              "#{blank($1)}#{$2}"
             end
 
           replacement[post] = blank(replacement[post])
@@ -100,6 +97,32 @@ module Sorbet
         end
       end
 
+      # typed: ignore => #
+      # typed: false => #
+      # typed: true => #
+      # typed: strict => #
+      # typed: strong => #
+      class TypedCommentPattern < Pattern
+        def replace(segment)
+          segment.gsub(/\A#(\s*typed:\s*(?:ignore|false|true|strict|strong)(\s*))\z/) do
+            "##{blank($1)}"
+          end
+        end
+      end
+
+      def on_comment(comment)
+        super.tap do |node|
+          if lineno == 1 && comment.match?(/\A#\s*typed:\s*(?:ignore|false|true|strict|strong)\s*\z/)
+            # typed: ignore
+            # typed: false
+            # typed: true
+            # typed: strict
+            # typed: strong
+            patterns << TypedCommentPattern.new(node.range)
+          end
+        end
+      end
+
       def on_method_add_arg(call, arg_paren)
         if call.match?(/\A<call <var_ref <@const T>> <@period \.> <@ident (?:must|reveal_type|unsafe)>>\z/) && arg_paren.match?(/\A<arg_paren <args_add_block <args .+> false>>\z/)
           # T.must(foo)

data/lib/sorbet/eraser/t.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "sorbet/eraser/t/enum"
+require "sorbet/eraser/t/props"
+require "sorbet/eraser/t/struct"
+
+# For some constructs, it doesn't make as much sense to entirely remove them
+# since they're actually used to change runtime behavior. For example, T.absurd
+# will always raise an error. In this case instead of removing the content, we
+# can just shim it.
+module T
+  # These methods should really not be being called in a loop or any other kind
+  # of hot path, so here we're just going to shim them.
+  module Helpers
+    def abstract!; end
+    def interface!; end
+    def final!; end
+    def sealed!; end
+    def mixes_in_class_methods(*); end
+    def requires_ancestor(*); end
+  end
+
+  # Similar to the Helpers module, these things should only be called a couple
+  # of times, so shimming them here.
+  module Generic
+    include Helpers
+    def type_member(*, **); end
+    def type_template(*, **); end
+  end
+
+  # Keeping this module as a thing so that if there's any kind of weird
+  # reflection going on like is_a?(T::Sig) it will still work.
+  module Sig
+  end
+
+  # I really don't want to be shimming this, but there are places where people
+  # try to reference these values.
+  module Private
+    module RuntimeLevels
+      def self.default_checked_level; :never; end
+    end
+  
+    module Methods
+      module MethodHooks
+      end
+
+      module SingletonMethodHooks
+      end
+
+      def self.signature_for_method(method); method; end
+    end
+  end
+
+  # I also don't want to shim this, but there are places where people will
+  # reference it.
+  module Configuration
+    class << self
+      attr_accessor :inline_type_error_handler,
+                    :call_validation_error_handler,
+                    :sig_builder_error_handler
+    end
+  end
+
+  # Type aliases don't actually do anything, but they are usually assigned to
+  # constants, so in that case we need to return something.
+  def self.type_alias
+    Object.new
+  end
+
+  # Absurd always raises a TypeError within Sorbet, so mirroring that behavior
+  # here when T.absurd is called.
+  def self.absurd(value)
+    raise TypeError, value
+  end
+end

data/lib/sorbet/eraser/version.rb

@@ -2,6 +2,6 @@
 
 module Sorbet
   module Eraser
-    VERSION = "0.3.1"
+    VERSION = "0.5.0"
   end
 end

data/lib/t.rb

@@ -1,75 +1,3 @@
 # 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
-# since they're actually used to change runtime behavior. For example, T.absurd
-# will always raise an error. In this case instead of removing the content, we
-# can just shim it.
-module T
-  # These methods should really not be being called in a loop or any other kind
-  # of hot path, so here we're just going to shim them.
-  module Helpers
-    def abstract!; end
-    def interface!; end
-    def final!; end
-    def sealed!; end
-    def mixes_in_class_methods(*); end
-    def requires_ancestor(*); end
-  end
-
-  # Similar to the Helpers module, these things should only be called a couple
-  # of times, so shimming them here.
-  module Generic
-    include Helpers
-    def type_member(*, **); end
-    def type_template(*, **); end
-  end
-
-  # Keeping this module as a thing so that if there's any kind of weird
-  # reflection going on like is_a?(T::Sig) it will still work.
-  module Sig
-  end
-
-  # I really don't want to be shimming this, but there are places where people
-  # try to reference these values.
-  module Private
-    module RuntimeLevels
-      def self.default_checked_level; :never; end
-    end
-  
-    module Methods
-      module MethodHooks
-      end
-
-      module SingletonMethodHooks
-      end
-
-      def self.signature_for_method(method); method; end
-    end
-  end
-
-  # I also don't want to shim this, but there are places where people will
-  # reference it.
-  module Configuration
-    class << self
-      attr_accessor :inline_type_error_handler,
-                    :call_validation_error_handler,
-                    :sig_builder_error_handler
-    end
-  end
-
-  # Type aliases don't actually do anything, but they are usually assigned to
-  # constants, so in that case we need to return something.
-  def self.type_alias
-    Object.new
-  end
-
-  # Absurd always raises a TypeError within Sorbet, so mirroring that behavior
-  # here when T.absurd is called.
-  def self.absurd(value)
-    raise TypeError, value
-  end
-end
+require "sorbet/eraser/t"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-eraser
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Kevin Newton
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-06-27 00:00:00.000000000 Z
+date: 2023-07-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -77,18 +77,19 @@ files:
 - lib/sorbet/eraser/cli.rb
 - lib/sorbet/eraser/parser.rb
 - lib/sorbet/eraser/patterns.rb
+- lib/sorbet/eraser/t.rb
+- lib/sorbet/eraser/t/enum.rb
+- lib/sorbet/eraser/t/props.rb
+- lib/sorbet/eraser/t/struct.rb
 - 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
 licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/kddnewton/sorbet-eraser/issues
-  changelog_uri: https://github.com/kddnewton/sorbet-eraser/blob/v0.3.1/CHANGELOG.md
+  changelog_uri: https://github.com/kddnewton/sorbet-eraser/blob/v0.5.0/CHANGELOG.md
   source_code_uri: https://github.com/kddnewton/sorbet-eraser
   rubygems_mfa_required: 'true'
 post_install_message: