sorbet-eraser 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 54913e2de72273efae7221b3dc96923c1b45e7d17020ec47bd9a417bea9a62cc
-  data.tar.gz: 71f3cc0a28acefd20d9a4a1f3a06081a568c5b8276cb1241f34d2bb3e7f64fb8
+  metadata.gz: efd5822039bf577e0c4a37171d7e91abd9c7bed250c9d09c779f52faa0d84cf6
+  data.tar.gz: 1a88eab81b0932ab400f5aeaf08e43cb5107fc08c135e232cc444205f76fdcf3
 SHA512:
-  metadata.gz: 06ca1f48f68eea0d10933f83ffe8ba4b296cda3c87240a5db6704ac27d9d6a12202a46b1af82ee3983ba335d4254f230a8f3d861578556ee76ea3544c551cd70
-  data.tar.gz: 547b88a3fb93e133c69cdd2d05ce684f62cc1650afe836fe9741059d1f567f4704bf11815b3170d8f4df2a9909fcc138fc6d940b45ef5ff615853f93118a2f93
+  metadata.gz: a64889bcbdf6affe397a394ed3a0841a166ff376e806e050967d4676910670a5f75d774e25c2490fae410c2b5e9263f07c07597ae6c0a0c08ae226343032ed0f
+  data.tar.gz: 50b223fde3f5901535888d6e06f685ba128c6bda051d516fe37f8b825ce9c328bfddaff54bb19a52aa1694309be11a74732ceb0b582e00179cf939d8eba760ba

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/Gemfile.lock

@@ -1,16 +1,19 @@
 PATH
   remote: .
   specs:
-    sorbet-eraser (0.1.1)
+    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

data/README.md

@@ -27,17 +27,17 @@ 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.
 
 ### Status
 
@@ -50,7 +50,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 +67,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/patterns.rb

@@ -89,6 +89,17 @@ 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)
@@ -137,17 +148,28 @@ module Sorbet
         super
       end
 
-      # T.must foo => foo
-      # T.reveal_type foo => foo
-      # T.unsafe foo => foo
-      class TMustNoParensPattern < Pattern
+      # prop :foo, String
+      # const :foo, String
+      class PropPattern < Pattern
         def replace(segment)
-          segment.gsub(/(T\s*\.(?:must|reveal_type|unsafe)\s*)(.+)/) do
-            "#{blank($1)}#{$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)
+        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
+
       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

data/lib/sorbet/eraser/version.rb

@@ -2,6 +2,6 @@
 
 module Sorbet
   module Eraser
-    VERSION = "0.1.1"
+    VERSION = "0.2.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,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

@@ -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.2.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.2.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.