sorbet-eraser 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 839924a4d5d33c9f00287b6be5151b263ef6b4446b524568ee0bbb212f2a4584
-  data.tar.gz: 5658154f4303ffa3f547992d679f62efa5f613eb0cf7cb871e51cecb21d7c329
+  metadata.gz: efd5822039bf577e0c4a37171d7e91abd9c7bed250c9d09c779f52faa0d84cf6
+  data.tar.gz: 1a88eab81b0932ab400f5aeaf08e43cb5107fc08c135e232cc444205f76fdcf3
 SHA512:
-  metadata.gz: ae54ad36caaee0aaf2f70eba22fa6e1e9fe3b00b682d00a2007b50076e211d5e4922474a59820193a673e26f76f3b0f63bc2662021577e07cccc5f9d5a8ec55f
-  data.tar.gz: 257cb54108d56dbe36bf10316a2191bc594c59bfa4c4eff358b005703b2a01767ca432c558cc6785f5ad0ac4a918eddef3fca3c15b1c3b17941ca085c8f784fd
+  metadata.gz: a64889bcbdf6affe397a394ed3a0841a166ff376e806e050967d4676910670a5f75d774e25c2490fae410c2b5e9263f07c07597ae6c0a0c08ae226343032ed0f
+  data.tar.gz: 50b223fde3f5901535888d6e06f685ba128c6bda051d516fe37f8b825ce9c328bfddaff54bb19a52aa1694309be11a74732ceb0b582e00179cf939d8eba760ba

data/.github/dependabot.yml

@@ -0,0 +1,6 @@
+version: 2
+updates:
+  - package-ecosystem: "bundler"
+    directory: "/"
+    schedule:
+      interval: "daily"

data/.github/workflows/main.yml

@@ -0,0 +1,32 @@
+name: Main
+on:
+- push
+- pull_request_target
+jobs:
+  ci:
+    name: CI
+    runs-on: ubuntu-latest
+    env:
+      CI: true
+    steps:
+    - uses: actions/checkout@master
+    - uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: '3.1'
+        bundler-cache: true
+    - name: Test
+      run: bundle exec rake test
+  automerge:
+    name: AutoMerge
+    needs: ci
+    runs-on: ubuntu-latest
+    if: github.event_name == 'pull_request_target' && (github.actor == github.repository_owner || github.actor == 'dependabot[bot]')
+    steps:
+    - uses: actions/github-script@v3
+      with:
+        script: |
+          github.pulls.merge({
+            owner: context.payload.repository.owner.login,
+            repo: context.payload.repository.name,
+            pull_number: context.payload.pull_request.number
+          })

data/CHANGELOG.md

@@ -0,0 +1,16 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.1.1] - 2021-11-17
+
+### Changed
+
+- Require MFA for releasing.
+
+[unreleased]: https://github.com/kddnewton/sorbet-eraser/compare/v0.1.1...HEAD
+[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.0)
+    sorbet-eraser (0.2.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
@@ -19,4 +22,4 @@ DEPENDENCIES
   sorbet-eraser!
 
 BUNDLED WITH
-   2.2.24
+   2.2.15

data/README.md

@@ -1,5 +1,8 @@
 # Sorbet::Eraser
 
+[![Build Status](https://github.com/kddnewton/sorbet-eraser/workflows/Main/badge.svg)](https://github.com/kddnewton/sorbet-eraser/actions)
+[![Gem](https://img.shields.io/gem/v/sorbet-eraser.svg)](https://rubygems.org/gems/sorbet-eraser)
+
 Erase all traces of `sorbet-runtime` code.
 
 `sorbet` is a great tool for development. However, in production, it incurs a penalty because it still functions as Ruby code. Even if you completely shim all `sorbet-runtime` method calls (for example by replacing `sig {} ` with a method that immediately returns) you still pay the cost of a method call in the first place.
@@ -11,7 +14,7 @@ This gem takes a different approach, but entirely eliminating the `sig` method c
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'sorbet-eraser'
+gem "sorbet-eraser"
 ```
 
 And then execute:
@@ -24,36 +27,56 @@ 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.
+
+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.
+
+The second is that you can preprocess your Ruby files using either the CLI or the Ruby API. With the CLI, you would run:
+
+```bash
+bundle exec sorbet-eraser '**/*.rb'
+```
 
-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.
+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.
 
 ### Status
 
 Below is a table of the status of each `sorbet-runtime` construct and its current support status.
 
-| Construct | Status | Replacement |
-| --------- | ------ | ----------- |
-| `include T::Generic` | 🛠 | |
-| `include T::Helpers` | 🛠 | |
-| `extend T::Sig` | ✅ | |
-| `class Foo < T::Enum` | 🛠 | `class Foo < ::Sorbet::Eraser::Enum` |
-| `class Foo < T::Struct` | 🛠 | `class Foo < ::Sorbet::Eraser::Struct` |
-| `abstract!` | 🛠 | |
-| `final!` | 🛠 | |
-| `interface!` | 🛠 | |
-| `mixes_in_class_methods(foo)` | 🛠 | `foo` |
-| `sig` | ✅ | |
-| `T.absurd(foo)` | ✅ | `raise ::Sorbet::Eraser::AbsurdError` |
-| `T.assert_type!(foo)` | ✅ | `foo` |
-| `T.bind(self, foo)` | ✅ | `self` |
-| `T.cast(foo, bar)` | ✅ | `foo` |
-| `T.let(foo, bar)` | ✅ | `foo` |
-| `T.must(foo)` | ✅ | `foo` |
-| `T.must foo` | ✅ | `foo` |
-| `T.reveal_type(foo)` | ✅ | `foo` |
-| `T.type_alias { foo }` | ✅ | `::Sorbet::Eraser::TypeAlias` |
-| `T.unsafe(foo)` | 🛠 | `foo` |
+| 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`       |
+
+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.
+* Anything else means that the inputted code is replaced with that output.
 
 ## Development
 

data/exe/sorbet-eraser

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+$:.unshift(File.expand_path("../lib", __dir__))
+require "sorbet/eraser"
+require "sorbet/eraser/cli"
+
+Sorbet::Eraser::CLI.start(ARGV)

data/lib/sorbet/eraser/cli.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Sorbet
+  module Eraser
+    # A small CLI that takes filepaths and erases them by writing back to the
+    # original file.
+    class CLI
+      POOL_SIZE = 4
+
+      attr_reader :filepaths
+
+      def initialize(filepaths)
+        @filepaths = filepaths
+      end
+
+      def start
+        queue = Queue.new
+        filepaths.each { |filepath| queue << filepath }
+
+        workers =
+          POOL_SIZE.times.map do
+            # push a symbol onto the queue for each thread so that it knows when
+            # the end of the queue is and will exit its infinite loop
+            queue << :eoq
+
+            Thread.new do
+              while filepath = queue.shift
+                break if filepath == :eoq
+                process(filepath)
+              end
+            end
+          end
+
+        workers.each(&:join)
+      end
+
+      def self.start(argv)
+        new(argv.flat_map { |pattern| Dir.glob(pattern) }).start
+      end
+
+      private
+
+      def process(filepath)
+        File.write(filepath, Eraser.erase(File.read(filepath)))
+      rescue Parser::ParsingError => error
+        warn("Could not parse #{filepath}: #{error}")
+      rescue => error
+        warn("Could not parse #{filepath}: #{error}")
+      end
+    end
+  end
+end

data/lib/sorbet/eraser/parser.rb

@@ -35,7 +35,10 @@ module Sorbet
         end
 
         def [](byteindex)
-          @indices[byteindex]
+          # Why the || byteindex? I'm not sure. For some reason ripper is
+          # returning very odd column values when you have a multibyte line.
+          # This is the only way I could find to make it work.
+          @indices[byteindex] || byteindex
         end
       end
 
@@ -60,11 +63,16 @@ module Sorbet
         end
       end
 
-      attr_reader :line_counts, :patterns
+      # Raised in the case that source can't be parsed.
+      class ParsingError < StandardError
+      end
+
+      attr_reader :source, :line_counts, :errors, :patterns
 
       def initialize(source)
         super(source)
 
+        @source = source
         @line_counts = []
         last_index = 0
 
@@ -78,6 +86,7 @@ module Sorbet
           last_index += line.size
         end
 
+        @errors = []
         @patterns = []
       end
 
@@ -85,7 +94,7 @@ module Sorbet
         parser = new(source)
 
         if parser.parse.nil? || parser.error?
-          raise "Invalid source"
+          raise ParsingError, parser.errors.join("\n")
         else
           parser.patterns.inject(source) do |current, pattern|
             pattern.erase(current)
@@ -113,14 +122,13 @@ module Sorbet
       # 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.
       PARSER_EVENT_TABLE.each do |event, arity|
-        case event
-        when /\A(.+)_new\z/
+        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 })
           end
-        when /_add\z/
+        elsif event =~ /_add\z/
           define_method(:"on_#{event}") do |node, value|
             range =
               if node.body.empty?
@@ -131,6 +139,8 @@ module Sorbet
 
             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)
@@ -142,6 +152,11 @@ module Sorbet
           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

@@ -5,10 +5,11 @@ module Sorbet
     module Patterns
       # A pattern in code that represents a call to a special Sorbet method.
       class Pattern
-        attr_reader :range
+        attr_reader :range, :metadata
 
-        def initialize(range)
+        def initialize(range, **metadata)
           @range = range
+          @metadata = metadata
         end
 
         def erase(source)
@@ -22,27 +23,25 @@ module Sorbet
           source
         end
 
-        def replace(segment)
-          segment
+        def blank(segment)
+          # This is deceptive in that it hides that it actually replaces
+          # everything with spaces _except_ newline characters, which is keeps
+          # in place.
+          segment.gsub(/./, " ")
         end
-      end
 
-      # T.absurd(foo) => raise ::Sorbet::Eraser::AbsurdError
-      class TAbsurdParensPattern < Pattern
         def replace(segment)
-          segment.gsub(/(T\s*\.absurd\(\s*.+\s*\))(.*)/) do
-            replacement = "raise ::Sorbet::Eraser::AbsurdError"
-            "#{replacement}#{" " * [$1.length - replacement.length, 0].max}#{$2}"
-          end
+          segment
         end
       end
 
       # T.must(foo) => foo
       # T.reveal_type(foo) => foo
+      # T.unsafe(foo) => foo
       class TOneArgMethodCallParensPattern < Pattern
         def replace(segment)
-          segment.gsub(/(T\s*\.(?:must|reveal_type)\(\s*)(.+)(\s*\))(.*)/) do
-            "#{" " * $1.length}#{$2}#{" " * $3.length}#{$4}"
+          segment.gsub(/(T\s*\.(?:must|reveal_type|unsafe)\(\s*)(.+)(\s*\))(.*)/m) do
+            "#{blank($1)}#{$2}#{blank($3)}#{$4}"
           end
         end
       end
@@ -53,98 +52,133 @@ module Sorbet
       # T.let(foo, bar) => let
       class TTwoArgMethodCallParensPattern < Pattern
         def replace(segment)
-          segment.gsub(/(T\s*\.(?:assert_type!|bind|cast|let)\(\s*)(.+)(\s*,.+\))(.*)/) do
-            "#{" " * $1.length}#{$2}#{" " * $3.length}#{$4}"
+          replacement = segment.dup
+
+          # 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
+
+          replacement[pre] =
+            replacement[pre].gsub(/(T\s*\.(?:assert_type!|bind|cast|let)\(\s*)(.+)(\s*,)(.*)/m) do
+              "#{blank($1)}#{$2}#{blank($3)}#{$4}"
+            end
+
+          replacement[post] = blank(replacement[post])
+          replacement
+        end
+      end
+
+      # abstract! =>
+      # final! =>
+      # interface! =>
+      class DeclarationPattern < Pattern
+        def replace(segment)
+          segment.gsub(/((?:abstract|final|interface)!(?:\(\s*\))?)(.*)/) do
+            "#{blank($1)}#{$2}"
           end
         end
       end
 
-      def on_method_add_arg(call, arg_paren)
-        # T.absurd(foo)
-        if call.match?(/<call <var_ref <@const T>> <@period \.> <@ident absurd>>/) &&
-          arg_paren.match?(/<arg_paren <args_add_block <args .+> false>>/)
-          patterns << TAbsurdParensPattern.new(call.range.begin..arg_paren.range.end)
+      # mixes_in_class_methods(foo) => foo
+      class MixesInClassMethodsPattern < Pattern
+        def replace(segment)
+          segment.gsub(/(mixes_in_class_methods\(\s*)(.+)(\s*\))(.*)/m) do
+            "#{blank($1)}#{$2}#{blank($3)}#{$4}"
+          end
         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)
-        if call.match?(/<call <var_ref <@const T>> <@period \.> <@ident (?:must|reveal_type)>>/) &&
+        # 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>>/)
-          patterns << TOneArgMethodCallParensPattern.new(call.range.begin..arg_paren.range.end)
+          patterns << TOneArgMethodCallParensPattern.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?(/<call <var_ref <@const T>> <@period \.> <@ident (?:assert_type!|cast|let)>>/) &&
+        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)
+          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
 
         # 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)
+          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.type_alias { foo } => ::Sorbet::Eraser::TypeAlias
-      class TTypeAliasBraceBlockPattern < Pattern
-        def replace(segment)
-          segment.gsub(/(T\s*\.type_alias\s*\{.*\})(.*)/) do
-            replacement = "::Sorbet::Eraser::TypeAlias"
-            "#{replacement}#{" " * [$1.length - replacement.length, 0].max}#{$2}"
-          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
-      end
 
-      def on_method_add_block(method_add_arg, block)
-        # T.type_alias { foo }
-        if method_add_arg.match?("<call <var_ref <@const T>> <@period .> <@ident type_alias>>") &&
-          block.match?(/<brace_block  <stmts .+>>/)
-          patterns << TTypeAliasBraceBlockPattern.new(method_add_arg.range.begin..block.range.end)
+        # 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)
         end
 
         super
       end
 
-      # extend T::Sig =>
-      class ExtendTSigPattern < Pattern
+      # prop :foo, String
+      # const :foo, String
+      class PropPattern < Pattern
         def replace(segment)
-          segment.gsub(/(extend\s+T::Sig)(.*)/) do
-            "#{" " * $1.length}#{$2}"
+          segment.gsub(/((?:prop|const)\s+:.+),(\s*)([^\n;,]+)(.*)/m) do
+            "#{$1} #{$2}#{blank($3)}#{$4}"
           end
         end
       end
 
       def on_command(ident, args_add_block)
-        # extend T::Sig
-        if ident.match?("<@ident extend>") &&
-          args_add_block.match?("<args_add_block <args <const_path_ref <var_ref <@const T>> <@const Sig>>> false>")
-          patterns << ExtendTSigPattern.new(ident.range.begin..args_add_block.range.end)
+        if ident.match?(/<@ident (?:const|prop)>/)
+          # prop :foo, String
+          # const :foo, String
+          if args_add_block.match?(/<args_add_block <args <symbol_literal <symbol <@ident .+>>> <.+> false>/)
+            patterns << PropPattern.new(ident.range.begin...args_add_block.range.end)
+          end
         end
 
         super
       end
 
-      # T.must foo => foo
-      class TMustNoParensPattern < Pattern
-        def replace(segment)
-          segment.gsub(/(T\s*\.must\s*)(.+)/) do
-            "#{" " * $1.length}#{$2}"
-          end
-        end
-      end
-
       def on_command_call(var_ref, period, ident, args_add_block)
         if var_ref.match?("<var_ref <@const T>>") && period.match?("<@period .>")
           # T.must foo
-          if ident.match?("<@ident must>") &&
+          # 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)
+            patterns << TMustNoParensPattern.new(var_ref.range.begin...args_add_block.range.end)
           end
         end
 
@@ -154,8 +188,8 @@ module Sorbet
       # sig { foo } =>
       class SigBracesPattern < Pattern
         def replace(segment)
-          segment.gsub(/(sig\s*\{.+\})(.*)/) do
-            "#{" " * $1.length}#{$2}"
+          segment.gsub(/(sig\s*\{.+\})(.*)/m) do
+            "#{blank($1)}#{$2}"
           end
         end
       end

data/lib/sorbet/eraser/version.rb

@@ -2,6 +2,6 @@
 
 module Sorbet
   module Eraser
-    VERSION = "0.1.0"
+    VERSION = "0.2.0"
   end
 end

data/lib/sorbet/eraser.rb

@@ -5,17 +5,10 @@ require "ripper"
 require "sorbet/eraser/parser"
 require "sorbet/eraser/patterns"
 require "sorbet/eraser/version"
+require "t"
 
 module Sorbet
   module Eraser
-    # This error gets raise in place of any T.absurd calls.
-    class AbsurdError < StandardError
-    end
-
-    # This class gets put in place of any existing T.type_alias calls.
-    class TypeAlias
-    end
-
     # Hook the patterns into the parser so that the correct methods get
     # overridden and will trigger replacements.
     Parser.prepend(Patterns)

data/lib/t/enum.rb

@@ -0,0 +1,252 @@
+# frozen_string_literal: true
+
+module T
+  # This is mostly copy-pasted from sorbet-runtime since we have to maintain the
+  # same behavior.
+  class T::Enum
+    ## Enum class methods ##
+
+    def self.values
+      if @values.nil?
+        raise "Attempting to access values of #{self.class} before it has been initialized." \
+          " Enums are not initialized until the 'enums do' block they are defined in has finished running."
+      end
+      @values
+    end
+
+    # This exists for compatibility with the interface of `Hash` & mostly to support
+    # the HashEachMethods Rubocop.
+    def self.each_value(&blk)
+      if blk
+        values.each(&blk)
+      else
+        values.each
+      end
+    end
+
+    # Convert from serialized value to enum instance
+    def self.try_deserialize(serialized_val)
+      if @mapping.nil?
+        raise "Attempting to access serialization map of #{self.class} before it has been initialized." \
+          " Enums are not initialized until the 'enums do' block they are defined in has finished running."
+      end
+      @mapping[serialized_val]
+    end
+
+    # Convert from serialized value to enum instance.
+    #
+    # @return [self]
+    # @raise [KeyError] if serialized value does not match any instance.
+    def self.from_serialized(serialized_val)
+      res = try_deserialize(serialized_val)
+      if res.nil?
+        raise KeyError.new("Enum #{self} key not found: #{serialized_val.inspect}")
+      end
+      res
+    end
+
+    # Note: It would have been nice to make this method final before people started overriding it.
+    # @return [Boolean] Does the given serialized value correspond with any of this enum's values.
+    def self.has_serialized?(serialized_val)
+      if @mapping.nil?
+        raise "Attempting to access serialization map of #{self.class} before it has been initialized." \
+          " Enums are not initialized until the 'enums do' block they are defined in has finished running."
+      end
+      @mapping.include?(serialized_val)
+    end
+
+    def self.serialize(instance)
+      return nil if instance.nil?
+
+      if self == T::Enum
+        raise "Cannot call T::Enum.serialize directly. You must call on a specific child class."
+      end
+      if instance.class != self
+        raise "Cannot call #serialize on a value that is not an instance of #{self}."
+      end
+      instance.serialize
+    end
+
+    # Note: Failed CriticalMethodsNoRuntimeTypingTest
+    def self.deserialize(mongo_value)
+      if self == T::Enum
+        raise "Cannot call T::Enum.deserialize directly. You must call on a specific child class."
+      end
+      self.from_serialized(mongo_value)
+    end
+
+    ## Enum instance methods ##
+
+    def dup
+      self
+    end
+
+    def clone
+      self
+    end
+
+    def serialize
+      assert_bound!
+      @serialized_val
+    end
+
+    def to_json(*args)
+      serialize.to_json(*args)
+    end
+
+    def to_s
+      inspect
+    end
+
+    def inspect
+      "#<#{self.class.name}::#{@const_name || '__UNINITIALIZED__'}>"
+    end
+
+    def <=>(other)
+      case other
+      when self.class
+        self.serialize <=> other.serialize
+      else
+        nil
+      end
+    end
+
+    # NB: Do not call this method. This exists to allow for a safe migration path in places where enum
+    # values are compared directly against string values.
+    #
+    # Ruby's string has a weird quirk where `'my_string' == obj` calls obj.==('my_string') if obj
+    # responds to the `to_str` method. It does not actually call `to_str` however.
+    #
+    # See https://ruby-doc.org/core-2.4.0/String.html#method-i-3D-3D
+    def to_str
+      msg = 'Implicit conversion of Enum instances to strings is not allowed. Call #serialize instead.'
+      raise NoMethodError.new(msg)
+    end
+
+    def ==(other)
+      case other
+      when String
+        false
+      else
+        super(other)
+      end
+    end
+
+    def ===(other)
+      case other
+      when String
+        false
+      else
+        super(other)
+      end
+    end
+
+    ## Private implementation ##
+
+    def initialize(serialized_val=nil)
+      raise 'T::Enum is abstract' if self.class == T::Enum
+      if !self.class.started_initializing?
+        raise "Must instantiate all enum values of #{self.class} inside 'enums do'."
+      end
+      if self.class.fully_initialized?
+        raise "Cannot instantiate a new enum value of #{self.class} after it has been initialized."
+      end
+
+      serialized_val = serialized_val.frozen? ? serialized_val : serialized_val.dup.freeze
+      @serialized_val = serialized_val
+      @const_name = nil
+      self.class._register_instance(self)
+    end
+
+    private def assert_bound!
+      if @const_name.nil?
+        raise "Attempting to access Enum value on #{self.class} before it has been initialized." \
+          " Enums are not initialized until the 'enums do' block they are defined in has finished running."
+      end
+    end
+
+    def _bind_name(const_name)
+      @const_name = const_name
+      @serialized_val = const_to_serialized_val(const_name) if @serialized_val.nil?
+      freeze
+    end
+
+    private def const_to_serialized_val(const_name)
+      # Historical note: We convert to lowercase names because the majority of existing calls to
+      # `make_accessible` were arrays of lowercase strings. Doing this conversion allowed for the
+      # least amount of repetition in migrated declarations.
+      const_name.to_s.downcase.freeze
+    end
+
+    def self.started_initializing?
+      @started_initializing ||= false
+    end
+
+    def self.fully_initialized?
+      @fully_initialized ||= false
+    end
+
+    # Maintains the order in which values are defined
+    def self._register_instance(instance)
+      @values ||= []
+      @values << instance
+    end
+
+    # Entrypoint for allowing people to register new enum values.
+    # All enum values must be defined within this block.
+    def self.enums(&blk)
+      raise "enums cannot be defined for T::Enum" if self == T::Enum
+      raise "Enum #{self} was already initialized" if @fully_initialized
+      raise "Enum #{self} is still initializing" if @started_initializing
+
+      @started_initializing = true
+
+      @values = nil
+
+      yield
+
+      @mapping = nil
+      @mapping = {}
+
+      # Freeze the Enum class and bind the constant names into each of the instances.
+      self.constants(false).each do |const_name|
+        instance = self.const_get(const_name, false)
+        if !instance.is_a?(self)
+          raise "Invalid constant #{self}::#{const_name} on enum. " \
+            "All constants defined for an enum must be instances itself (e.g. `Foo = new`)."
+        end
+
+        instance._bind_name(const_name)
+        serialized = instance.serialize
+        if @mapping.include?(serialized)
+          raise "Enum values must have unique serializations. Value '#{serialized}' is repeated on #{self}."
+        end
+        @mapping[serialized] = instance
+      end
+      @values.freeze
+      @mapping.freeze
+
+      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
+
+      @fully_initialized = true
+    end
+
+    def self.inherited(child_class)
+      super
+
+      raise "Inheriting from children of T::Enum is prohibited" if self != T::Enum
+    end
+
+    # Marshal support
+    def _dump(_level)
+      Marshal.dump(serialize)
+    end
+
+    def self._load(args)
+      deserialize(Marshal.load(args))
+    end
+  end
+end

data/lib/t/props.rb

@@ -0,0 +1,59 @@
+# 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)
+        attr_accessor name
+      end
+
+      def const(name, rules = {})
+        create_prop(name)
+        attr_reader name
+      end
+
+      private
+
+      def create_prop(name)
+        props << name
+        props.sort!
+      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 = {})
+      if self.class.props == hash.keys.sort
+        hash.each { |key, value| instance_variable_set("@#{key}", value) }
+      else
+        raise ArgumentError, "Expected keys #{self.class.props} but got #{hash.keys.sort}"
+      end
+    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

@@ -0,0 +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 < 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

@@ -0,0 +1,47 @@
+# 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
+
+  # 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/sorbet-eraser.gemspec

@@ -1,22 +1,31 @@
 # frozen_string_literal: true
 
-lib = File.expand_path("../lib", __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "sorbet/eraser/version"
+require_relative "lib/sorbet/eraser/version"
+
+version = Sorbet::Eraser::VERSION
+repository = "https://github.com/kddnewton/sorbet-eraser"
 
 Gem::Specification.new do |spec|
   spec.name          = "sorbet-eraser"
-  spec.version       = Sorbet::Eraser::VERSION
+  spec.version       = version
   spec.authors       = ["Kevin Newton"]
   spec.email         = ["kddnewton@gmail.com"]
 
   spec.summary       = "Erase all traces of sorbet-runtime code."
-  spec.homepage      = "https://github.com/kddnewton/sorbet-eraser"
+  spec.homepage      = repository
   spec.license       = "MIT"
 
-  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+  spec.metadata = {
+    "bug_tracker_uri" => "#{repository}/issues",
+    "changelog_uri" => "#{repository}/blob/v#{version}/CHANGELOG.md",
+    "source_code_uri" => repository,
+    "rubygems_mfa_required" => "true"
+  }
+
+  spec.files = Dir.chdir(File.expand_path('..', __FILE__)) do
     `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   end
+
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-eraser
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Kevin Newton
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-08-17 00:00:00.000000000 Z
+date: 2023-06-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -55,11 +55,15 @@ dependencies:
 description:
 email:
 - kddnewton@gmail.com
-executables: []
+executables:
+- sorbet-eraser
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/dependabot.yml"
+- ".github/workflows/main.yml"
 - ".gitignore"
+- CHANGELOG.md
 - Gemfile
 - Gemfile.lock
 - LICENSE
@@ -67,16 +71,26 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- exe/sorbet-eraser
 - lib/sorbet/eraser.rb
 - lib/sorbet/eraser/autoload.rb
+- lib/sorbet/eraser/cli.rb
 - lib/sorbet/eraser/parser.rb
 - lib/sorbet/eraser/patterns.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: {}
+metadata:
+  bug_tracker_uri: https://github.com/kddnewton/sorbet-eraser/issues
+  changelog_uri: https://github.com/kddnewton/sorbet-eraser/blob/v0.2.0/CHANGELOG.md
+  source_code_uri: https://github.com/kddnewton/sorbet-eraser
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -92,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.