pry-sorbet 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bfc26a70315521bb64ed1dd37c0d5270d33821417a0630052092b0f2efebba0f
-  data.tar.gz: bd69b579be964eb4f007a4506e58aad3f864f392004aa27bd56941081d45feba
+  metadata.gz: a7c71e9c8280b7f14bada6f48eaa62582a74e09f578759dee11dcdcd47cc0d68
+  data.tar.gz: 47d8f52a4134feb895c9177344e658147c4cc15896dea9c2f8abd5d574e44c8f
 SHA512:
-  metadata.gz: ece438c8451b3c4831d9714514e2c0cc516d0a40cf97173aff42abe76798d87f449b4701118411f76ad46f15cf965eacd28041458e3f253164b4c275cc0f79a9
-  data.tar.gz: 7c0810dc4586b041fad1c8e734a41dbd38a8b5dfc484c9b8ac8ce7df0e23222c18e01d23034e077cce5ff00ac6c97e27b27917390f6389d57eb2282f3207188c
+  metadata.gz: 122b2f0548e65dd58265eab021a97b5ef16cb30b101cffe467d06ce4ca3fd332e67285da0679ed2af78e2c48539f8cdecfc40c5605612411b6a3f5ae8f04851f
+  data.tar.gz: be0143342a9cdd1f73227348bca5f90dcb0eb6fd8d432f5b175f9a9b3c0c7dc8d099485c2de9dc72d723d9c127fceec34d6649c65ea872c230bf25b3f5bf0dfe

data/README.md

@@ -3,11 +3,41 @@
 pry-sorbet is a Pry extension which enables it to work seamlessly with Sorbet
 projects.
 
-**Before:** Incorrect method source
+## Installation
+
+Add this line to your application's Gemfile:
 
+```ruby
+gem 'pry-sorbet'
 ```
-From: /home/aaron/.rbenv/versions/2.6.3/lib/ruby/gems/2.6.0/gems/sorbet-runtime-0.4.4929/lib/types/private/methods/_methods.rb @ line 208:
-Owner: #<Class:Foo>
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install pry-sorbet
+
+## Usage
+
+### Fixes method source
+
+Since Sorbet runtime wraps methods with a signature to execute runtime checks
+on parameters and return values, the source location of methods end up pointing
+to a file location in the `sorbet-runtime` gem.
+
+`pry-sorbet` automatically fixes the information returned by the `show-source`
+(also known as `$`) command to list the correct method source location.
+
+Moreover, an extra entry is added to the header of the method listing, named
+`Sorbet`, which displays the method signature if it exists.
+
+**Before:** Incorrect method source, no method signature
+
+```
+From: /Users/user/.gem/ruby/2.6.5/gems/sorbet-runtime-0.5.5427/lib/types/private/methods/_methods.rb @ line 208:
+Owner: Foo
 Visibility: public
 Number of lines: 35
 
@@ -16,42 +46,110 @@ T::Private::ClassUtils.replace_method(mod, method_name) do |*args, &blk|
     # This should only happen if the user used alias_method to grab a handle
     # to the original pre-unwound `sig` method. I guess we'll just proxy the
     # call forever since we don't know who is holding onto this handle to
+    # replace it.
 ```
 
 **After:** Method source and a signature!
 
 ```
-From: playground/test.rb @ line 9:
-Owner: #<Class:Foo>
+From: test/test.rb @ line 8:
+Owner: Foo
 Visibility: public
-Sorbet: sig { returns(Integer) }
+Sorbet: sig { params(bar: Symbol, baz: Integer).returns(String) }
 Number of lines: 3
 
-def self.bar
-  3
+def foo(bar, baz)
+  [baz.to_s, bar.to_s].join(":")
 end
 ```
 
-## Installation
+### Helps with debugging
 
-Add this line to your application's Gemfile:
+Because of the same method wrapping, debugging source code that has Sorbet signatures
+becomes really painful. When stepping through the code, one always hits code locations
+that are in the `sorbet-runtime` library and most of the time it makes people end up
+missing the actual method invocation.
 
-```ruby
-gem 'pry-sorbet'
-```
+`pry-sorbet` adds a Sorbet specific command, `sorbet-unwrap` that can be ran to unwrap
+all Sorbet wrapped methods. This allows developers to easily step through their code
+without having to deal with the `sorbet-runtime` library.
 
-And then execute:
+**Before**
 
-    $ bundle
+```
+$ ruby -I lib -r pry-sorbet test/test.rb
+
+From: test/test.rb @ line 14 :
+
+     4: class Foo
+     5:   extend T::Sig
+     6:
+     7:   sig { params(bar: Symbol, baz: Integer).returns(String) }
+     8:   def foo(bar, baz)
+     9:     [baz.to_s, bar.to_s].join(":")
+    10:   end
+    11: end
+    12:
+    13: binding.pry
+ => 14: puts Foo.new.foo(:bar, 1)
+
+[1] pry(main)> step
+
+From: /Users/user/.gem/ruby/2.6.5/gems/sorbet-runtime-0.5.5427/lib/types/private/methods/_methods.rb @ line 209 Foo#foo:
+
+    204:     # which is called only on the *first* invocation.
+    205:     # This wrapper is very slow, so it will subsequently re-wrap with a much faster wrapper
+    206:     # (or unwrap back to the original method).
+    207:     new_method = nil
+    208:     T::Private::ClassUtils.replace_method(mod, method_name) do |*args, &blk|
+ => 209:       if !T::Private::Methods.has_sig_block_for_method(new_method)
+    210:         # This should only happen if the user used alias_method to grab a handle
+    211:         # to the original pre-unwound `sig` method. I guess we'll just proxy the
+    212:         # call forever since we don't know who is holding onto this handle to
+    213:         # replace it.
+    214:         new_new_method = mod.instance_method(method_name)
+```
 
-Or install it yourself as:
+**After**
 
-    $ gem install pry-sorbet
+```
+$ ruby -I lib -r pry-sorbet test/test.rb
+
+From: test/test.rb @ line 14 :
+
+     4: class Foo
+     5:   extend T::Sig
+     6:
+     7:   sig { params(bar: Symbol, baz: Integer).returns(String) }
+     8:   def foo(bar, baz)
+     9:     [baz.to_s, bar.to_s].join(":")
+    10:   end
+    11: end
+    12:
+    13: binding.pry
+ => 14: puts Foo.new.foo(:bar, 1)
+
+[1] pry(main)> sorbet-unwrap
+[2] pry(main)> step
+
+From: test/test.rb @ line 9 Foo#foo:
+
+     8: def foo(bar, baz)
+ =>  9:   [baz.to_s, bar.to_s].join(":")
+    10: end
+```
 
-## Usage
+Method unwrapping is not done automatically, you still need to call the `sorbet-unwrap`
+command before stepping through code. However, you can make this automatic by adding the
+following snippet to your  `~/.pryrc` file:
 
-Make sure you've required `pry-sorbet`. The `$` command in Pry will be
-automatically overwritten to add the Sorbet-specific functionality.
+```ruby
+if defined?(PrySorbet)
+  Pry.hooks.add_hook(:before_session, "sorbet-unwrap") do |output, binding, pry|
+    pry.run_command "sorbet-unwrap"
+  end
+end
+```
 
 ## Contributing
 

data/lib/pry-sorbet.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'pry'
+
+module PrySorbet
+end
+
+require 'pry-sorbet/version'
+require 'pry-sorbet/extensions.rb'
+require 'pry-sorbet/commands.rb'

data/lib/pry-sorbet/commands.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "pry-sorbet/commands/unwrap_command"

data/lib/pry-sorbet/commands/unwrap_command.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module PrySorbet
+  class UnwrapCommand < Pry::ClassCommand
+    match "sorbet-unwrap"
+    group "Sorbet"
+    description "Unwrap all methods wrapped by Sorbet runtime"
+    command_options requires_gem: "sorbet-runtime"
+
+    banner <<~BANNER
+      Usage: sorbet-unwrap
+
+      Unwrap all methods wrapped by Sorbet runtime
+    BANNER
+
+    def process
+      return unless defined?(T::Private::Methods)
+
+      # For each signature wrapper, call the lambda associated with the wrapper
+      # to finalize the method wrapping
+      sig_wrappers = T::Private::Methods.instance_variable_get(:@sig_wrappers) || {}
+      sig_wrappers.values.each do |sig_wrapper|
+        sig_wrapper.call
+      rescue NameError
+      end
+
+      # Now that all methods are properly wrapped with optimized wrappers
+      # we can replace them with the original methods
+      signatures_by_method = T::Private::Methods.instance_variable_get(:@signatures_by_method) || {}
+      signatures_by_method.values.each do |signature|
+        T::Configuration.without_ruby_warnings do
+          T::Private::DeclState.current.without_on_method_added do
+            signature.owner.send(:define_method, signature.method_name, signature.method)
+          end
+        end
+      end
+    end
+  end
+end
+
+Pry::Commands.add_command(PrySorbet::UnwrapCommand)

data/lib/pry-sorbet/extensions.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+class Pry
+  class Command
+    class ShowInfo
+      old_method_sections = instance_method(:method_sections)
+
+      define_method(:method_sections) do |code_object|
+        signature = defined?(T::Private::Methods) && T::Private::Methods.signature_for_method(code_object)
+
+        signature_string = if signature
+          build_signature_string(signature)
+        else
+          "Unknown"
+        end
+
+        old_method_sections.bind(self).(code_object).merge({
+          sorbet: "\n\e[1mSorbet:\e[0m #{signature_string}"
+        })
+      end
+
+      old_method_header = instance_method(:method_header)
+
+      define_method(:method_header) do |code_object, line_num|
+        old_method_header.bind(self).(code_object, line_num) \
+          + method_sections(code_object)[:sorbet]
+      end
+
+      private
+
+      def build_signature_string(signature)
+        call_chain = []
+
+        # Modifiers
+        if signature.mode != "standard"
+          # This is a string like "overridable_override"
+          call_chain += signature.mode.split("_")
+        end
+
+        # Parameters
+        all_parameters = []
+
+        #   Positional
+        all_parameters += signature.arg_types.map do |(name, type)|
+          "#{name}: #{type}"
+        end
+
+        #   Splat
+        if signature.rest_type
+          all_parameters << "#{signature.rest_name}: #{signature.rest_type}"
+        end
+
+        #   Keyword
+        all_parameters += signature.kwarg_types.map do |(name, type)|
+          "#{name}: #{type}"
+        end
+
+        #   Double-splat
+        if signature.rest_type
+          all_parameters << "#{signature.keyrest_name}: #{signature.keyrest_type}"
+        end
+
+        #   Block
+        if signature.block_type
+          all_parameters << "#{signature.block_name}: #{signature.block_type}"
+        end
+
+        call_chain << "params(#{all_parameters.join(", ")})" if all_parameters.any?
+
+        # Returns
+        if signature.return_type.is_a?(T::Private::Types::Void)
+          call_chain << "void"
+        else
+          call_chain << "returns(#{signature.return_type})"
+        end
+
+        "sig { #{call_chain.join(".")} }"
+      end
+    end
+  end
+
+  class Method
+    # Maybe use a dict or something, I think methods are suitable keys
+    define_method(:source_location) do
+      loc = super()
+
+      return loc unless defined?(T::Private::Methods)
+      signature = T::Private::Methods.signature_for_method(@method)
+      return loc unless signature
+
+      return signature.method.source_location
+    end
+  end
+end

data/lib/pry-sorbet/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module PrySorbet
+  VERSION = '0.2.0'
+end

data/pry-sorbet.gemspec

@@ -1,11 +1,12 @@
 lib = File.expand_path("lib", __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "pry-sorbet"
 
 Gem::Specification.new do |spec|
   spec.name          = "pry-sorbet"
-  spec.version       = "0.1.0"
-  spec.authors       = ["Aaron Christiansen"]
-  spec.email         = ["aaronc20000@gmail.com"]
+  spec.version       = PrySorbet::VERSION
+  spec.authors       = ["Aaron Christiansen", "Ufuk Kayserilioglu"]
+  spec.email         = ["aaronc20000@gmail.com", "ufuk.kayserilioglu@shopify.com"]
 
   spec.summary       = %q{Pry plugin for Sorbet}
   spec.homepage      = "https://github.com/AaronC81/pry-sorbet"
@@ -24,6 +25,9 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
+  spec.add_dependency "pry"
+
   spec.add_development_dependency "bundler", "~> 2.0"
   spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "sorbet-runtime"
 end

metadata

@@ -1,15 +1,30 @@
 --- !ruby/object:Gem::Specification
 name: pry-sorbet
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Aaron Christiansen
+- Ufuk Kayserilioglu
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-10-28 00:00:00.000000000 Z
+date: 2020-03-12 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -38,9 +53,24 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: sorbet-runtime
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 
 email:
 - aaronc20000@gmail.com
+- ufuk.kayserilioglu@shopify.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -50,8 +80,11 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
-- lib/extension.rb
-- lib/pry_sorbet.rb
+- lib/pry-sorbet.rb
+- lib/pry-sorbet/commands.rb
+- lib/pry-sorbet/commands/unwrap_command.rb
+- lib/pry-sorbet/extensions.rb
+- lib/pry-sorbet/version.rb
 - pry-sorbet.gemspec
 homepage: https://github.com/AaronC81/pry-sorbet
 licenses:

data/lib/extension.rb

@@ -1,101 +0,0 @@
-require 'sorbet-runtime'
-require 'pry'
-
-class Pry
-  class Command
-    class ShowInfo
-      old_method_sections = instance_method(:method_sections)
-
-      define_method(:method_sections) do |code_object|
-        sorbet_object = T::Private::Methods.signature_for_method(code_object)
-
-        if sorbet_object
-          call_chain = []
-
-          # Modifiers
-          call_chain << "generated" if sorbet_object.generated
-
-          if sorbet_object.mode != "standard"
-            # This is a string like "overridable_override"
-            call_chain += sorbet_object.mode.split("_")
-          end
-
-          # Parameters
-          all_parameters = []
-
-          #   Positional
-          all_parameters += sorbet_object.arg_types.map do |(name, type)|
-            "#{name}: #{type}"
-          end
-
-          #   Splat
-          if sorbet_object.rest_type
-            all_parameters << "#{sorbet_object.rest_name}: #{sorbet_object.rest_type}"
-          end
-
-          #   Keyword
-          all_parameters += sorbet_object.kwarg_types.map do |(name, type)|
-            "#{name}: #{type}"
-          end
-
-          #   Double-splat
-          if sorbet_object.rest_type
-            all_parameters << "#{sorbet_object.keyrest_name}: #{sorbet_object.keyrest_type}"
-          end
-
-          #   Block
-          if sorbet_object.block_type
-            all_parameters << "#{sorbet_object.block_name}: #{sorbet_object.block_type}"
-          end          
-
-          call_chain << "params(#{all_parameters.join(", ")})" if all_parameters.any?
-
-          # Returns
-          if sorbet_object.return_type.is_a?(T::Private::Types::Void)
-            call_chain << "void"
-          else
-            call_chain << "returns(#{sorbet_object.return_type})"
-          end
-
-          sorbet_string = "sig { #{call_chain.join(".")} }"
-        else
-          sorbet_string = "Unknown"
-        end
-
-        old_method_sections.bind(self).(code_object).merge({
-          sorbet: "\n\e[1mSorbet:\e[0m #{sorbet_string}"
-        })
-      end
-
-      old_method_header = instance_method(:method_header)
-
-      define_method(:method_header) do |code_object, line_num|
-        old_method_header.bind(self).(code_object, line_num) \
-          + method_sections(code_object)[:sorbet]
-      end
-    end
-  end
-
-  class Method
-    # Maybe use a dict or something, I think methods are suitable keys
-    define_method(:source_location) do
-      loc = super()
-
-      file_path, line = loc
-      return loc unless file_path && File.exists?(file_path)
-
-      first_source_line = IO.readlines(file_path)[line - 1]
-
-      # This is how Sorbet replaces methods.
-      # If Sorbet undergoes drastic refactorings, this may need to be updated!
-      initial_sorbet_line = "T::Private::ClassUtils.replace_method(mod, method_name) do |*args, &blk|"
-      replaced_sorbet_line = "mod.send(:define_method, method_sig.method_name) do |*args, &blk|"
-
-      if [initial_sorbet_line, replaced_sorbet_line].include?(first_source_line.strip)
-        T::Private::Methods.signature_for_method(@method).method.source_location
-      else
-        loc
-      end
-    end
-  end
-end

data/lib/pry_sorbet.rb

@@ -1 +0,0 @@
-require_relative 'extension.rb'