sorbet-eraser 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: efd5822039bf577e0c4a37171d7e91abd9c7bed250c9d09c779f52faa0d84cf6
-  data.tar.gz: 1a88eab81b0932ab400f5aeaf08e43cb5107fc08c135e232cc444205f76fdcf3
+  metadata.gz: 5ddbc396f3f164a3d0e67e9cf7046733ce52f792eb0abc17e9f5f056f415cd5e
+  data.tar.gz: 965ef9955b75bba0a2702ea127d5923d7e4b1a55ed2b2e6dca239970adbb0fe1
 SHA512:
-  metadata.gz: a64889bcbdf6affe397a394ed3a0841a166ff376e806e050967d4676910670a5f75d774e25c2490fae410c2b5e9263f07c07597ae6c0a0c08ae226343032ed0f
-  data.tar.gz: 50b223fde3f5901535888d6e06f685ba128c6bda051d516fe37f8b825ce9c328bfddaff54bb19a52aa1694309be11a74732ceb0b582e00179cf939d8eba760ba
+  metadata.gz: 5deb006431e8e31ed089fe6e8fba281f3c65487fc6996a853b05bb0d9600ff034232e7319fb44912a69dc89b60b160900b9b503a17991d19da2bf02f5803c5f8
+  data.tar.gz: a6a20f8aa21b2a2c9e75a4c7e83db5b28556516296d16f55eedd0113da807cbf0c3a827fbeda7eaf9fb95d2a29a9f0c4ddc9090d638e00469989520d2c492f1d

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,7 +1,7 @@
 PATH
   remote: .
   specs:
-    sorbet-eraser (0.2.0)
+    sorbet-eraser (0.3.0)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -39,6 +39,8 @@ 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.  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
 
 Below is a table of the status of each `sorbet-runtime` construct and its current support status.

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

@@ -101,69 +101,80 @@ module Sorbet
       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)
-        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
-
-        # 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
-            )
-        end
-
-        # abstract!
-        # final!
-        # interface!
-        if call.match?(/<fcall <@ident (?:abstract|final|interface)!>>/) &&
-          arg_paren.match?("<args >")
+        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)
-        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>>/)
+        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
 
         super
       end
 
-      # prop :foo, String
-      # const :foo, String
-      class PropPattern < Pattern
+      # prop :foo, String => prop :foo
+      # const :foo, String => const :foo
+      class PropWithoutOptionsPattern < Pattern
         def replace(segment)
-          segment.gsub(/((?:prop|const)\s+:.+),(\s*)([^\n;,]+)(.*)/m) do
-            "#{$1} #{$2}#{blank($3)}#{$4}"
+          segment.dup.tap do |replacement|
+            range = metadata.fetch(:comma)..-1
+            replacement[range] = blank(replacement[range])
+          end
+        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)
+
+            range = (first_comma + 1)..second_comma
+            replacement[range] = blank(replacement[range])
           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)
+          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
 
@@ -171,15 +182,11 @@ module Sorbet
       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
@@ -194,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.2.0"
+    VERSION = "0.3.0"
   end
 end

data/lib/t/props.rb

@@ -20,31 +20,37 @@ module T
       end
 
       def prop(name, rules = {})
-        create_prop(name)
-        attr_accessor name
+        create_prop(name, rules)
+        attr_accessor(name) unless rules[:without_accessors]
       end
 
       def const(name, rules = {})
-        create_prop(name)
-        attr_reader name
+        create_prop(name, rules)
+        attr_reader(name) unless rules[:without_accessors]
       end
 
       private
 
-      def create_prop(name)
-        props << name
-        props.sort!
+      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 = {})
-      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}"
+      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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-eraser
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Kevin Newton
@@ -88,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.2.0/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: