yard-sorbet 0.0.1 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0877d9e7c2166c05eaf8b6e758ca07e046258053458a33cc6847b8103ba998b0'
-  data.tar.gz: 1a2ec7ab8d6e8036c53a816053e91abb117a7330fb52aaeba692a5331d2f597b
+  metadata.gz: f5adecef50618ea39bdb103aa89d5a6561e838ad9860b7b4103fc39eeb268f5b
+  data.tar.gz: 33a6ce0b55c6a9934e3491a1a1feff06da39919d6b5196a67bab5d3861cd9425
 SHA512:
-  metadata.gz: 8c32134d99eb150900275db0a7c34f7e3e1c08deb1c6fbee35d8303aa3ed0ad98dc1453268fc2a97a4f23fdf9c5969f2edff6bfc62ba271e8c9af70708ab385c
-  data.tar.gz: e3de167e4393f4a832e65e4d91459e17f7218423e392df25b405c0cdbf3a16e9f4ebaefd3f3ec71efc6b62330942cef98267545c7410305487efabbacf805715
+  metadata.gz: '0139df44b176ef888fb74101915593dd43349133abc0cec0e60a16be72c72ddbbfdefa1ded2dc535764ef898a44156e8a5d74ff40d62ab109818277666f2e44f'
+  data.tar.gz: 2015b2b80680fcea678afc3b5d1a68350218904cc97a93ef4dec35cb1e07918d8766c77f309b21371dd52609c98a348bcb932899c360f721e0a00d3aedf0f175

data/lib/yard-sorbet.rb

@@ -1,12 +1,14 @@
-# frozen_string_literal: true
 # typed: strong
+# frozen_string_literal: true
+
 require 'sorbet-runtime'
 require 'yard'
 
 # top-level namespace
 module YARDSorbet; end
 
-require_relative 'yard-sorbet/directives.rb'
+require_relative 'yard-sorbet/directives'
 require_relative 'yard-sorbet/sig_handler'
 require_relative 'yard-sorbet/sig_to_yard'
 require_relative 'yard-sorbet/struct_handler'
+require_relative 'yard-sorbet/version'

data/lib/yard-sorbet/directives.rb

@@ -1,8 +1,11 @@
-# frozen_string_literal: true
 # typed: strict
+# frozen_string_literal: true
 
 # Extract & re-add directives to a docstring
 module YARDSorbet::Directives
+  extend T::Sig
+
+  sig { params(docstring: T.nilable(String)).returns([YARD::Docstring, T::Array[String]]) }
   def self.extract_directives(docstring)
     parser = YARD::DocstringParser.new.parse(docstring)
     # Directives are already parsed at this point, and there doesn't
@@ -16,6 +19,7 @@ module YARDSorbet::Directives
     [parser.to_docstring, directives]
   end
 
+  sig { params(docstring: String, directives: T::Array[String]).void }
   def self.add_directives(docstring, directives)
     directives.each do |directive|
       docstring.concat("\n#{directive}")

data/lib/yard-sorbet/sig_handler.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 # A YARD Handler for Sorbet type declarations
@@ -6,35 +6,74 @@ class YARDSorbet::SigHandler < YARD::Handlers::Ruby::Base
   extend T::Sig
   handles :class, :module, :singleton_class?
 
-  sig { returns(String).checked(:never) }
+  # A struct that holds the parsed contents of a Sorbet type signature
+  class ParsedSig < T::Struct
+    prop :abstract, T::Boolean, default: false
+    prop :params, T::Hash[String, T::Array[String]], default: {}
+    prop :return, T.nilable(T::Array[String])
+  end
+
+  PARAM_EXCLUDES = T.let(%i[array call hash].freeze, T::Array[Symbol])
+  PROCESSABLE_NODES = T.let(%i[def defs command].freeze, T::Array[Symbol])
+  SIG_EXCLUDES = T.let(%i[array hash].freeze, T::Array[Symbol])
+  SIG_NODE_TYPES = T.let(%i[call fcall vcall].freeze, T::Array[Symbol])
+
+  private_constant :ParsedSig, :PARAM_EXCLUDES, :PROCESSABLE_NODES, :SIG_EXCLUDES, :SIG_NODE_TYPES
+
+  sig { void }
   def process
     # Find the list of declarations inside the class
     class_def = statement.children.find { |c| c.type == :list }
     class_contents = class_def.children
 
+    process_class_contents(class_contents)
+  end
+
+  sig { params(class_contents: T::Array[YARD::Parser::Ruby::MethodCallNode]).void }
+  private def process_class_contents(class_contents)
     class_contents.each_with_index do |child, i|
+      if child.type == :sclass && child.children.size == 2 && child.children[1].type == :list
+        singleton_class_contents = child.children[1]
+        process_class_contents(singleton_class_contents)
+      end
       next unless type_signature?(child)
 
       next_statement = class_contents[i + 1]
-      if %i[def defs command].include?(next_statement&.type) && !next_statement.docstring
-        # Swap the method definition docstring and the sig docstring.
-        # Parse relevant parts of the `sig` and include them as well.
-        docstring, directives = YARDSorbet::Directives.extract_directives(child.docstring)
-        parsed_sig = parse_sig(child)
-        enhance_tag(docstring, :abstract, parsed_sig)
-        enhance_tag(docstring, :return, parsed_sig)
-        if next_statement.type != :command
-          parsed_sig[:params]&.each do |name, types|
-            enhance_param(docstring, name, types)
-          end
-        end
-        next_statement.docstring = docstring.to_raw
-        YARDSorbet::Directives.add_directives(next_statement.docstring, directives)
-        child.docstring = nil
+      next unless processable_method?(next_statement)
+
+      process_method_definition(T.must(next_statement), child)
+    end
+  end
+
+  sig { params(next_statement: T.nilable(YARD::Parser::Ruby::AstNode)).returns(T::Boolean) }
+  private def processable_method?(next_statement)
+    PROCESSABLE_NODES.include?(next_statement&.type)
+  end
+
+  sig do
+    params(
+      method_node: YARD::Parser::Ruby::AstNode,
+      sig_node: YARD::Parser::Ruby::MethodCallNode
+    ).void
+  end
+  private def process_method_definition(method_node, sig_node)
+    # Swap the method definition docstring and the sig docstring.
+    # Parse relevant parts of the `sig` and include them as well.
+    docstring, directives = YARDSorbet::Directives.extract_directives(sig_node.docstring)
+    parsed_sig = parse_sig(sig_node)
+    enhance_tag(docstring, :abstract, parsed_sig)
+    enhance_tag(docstring, :return, parsed_sig)
+    if method_node.type != :command
+      parsed_sig.params.each do |name, types|
+        enhance_param(docstring, name, types)
       end
     end
+    method_node.docstring = docstring.to_raw
+    YARDSorbet::Directives.add_directives(method_node.docstring, directives)
+    sig_node.docstring = nil
   end
 
+  sig { params(docstring: YARD::Docstring, name: String, types: T::Array[String]).void }
   private def enhance_param(docstring, name, types)
     tag = docstring.tags.find { |t| t.tag_name == 'param' && t.name == name }
     if tag
@@ -46,8 +85,10 @@ class YARDSorbet::SigHandler < YARD::Handlers::Ruby::Base
     docstring.add_tag(tag)
   end
 
+  sig { params(docstring: YARD::Docstring, type: Symbol, parsed_sig: ParsedSig).void }
   private def enhance_tag(docstring, type, parsed_sig)
-    return if !parsed_sig[type]
+    type_value = parsed_sig.public_send(type)
+    return if !type_value
 
     tag = docstring.tags.find { |t| t.tag_name == type.to_s }
     if tag
@@ -55,52 +96,53 @@ class YARDSorbet::SigHandler < YARD::Handlers::Ruby::Base
     else
       tag = YARD::Tags::Tag.new(type, '')
     end
-    if parsed_sig[type].is_a?(Array)
-      tag.types = parsed_sig[type]
+    if type_value.is_a?(Array)
+      tag.types = type_value
     end
     docstring.add_tag(tag)
   end
 
+  sig { params(sig_node: YARD::Parser::Ruby::MethodCallNode).returns(ParsedSig) }
   private def parse_sig(sig_node)
-    parsed = {}
-    parsed[:abstract] = false
-    parsed[:params] = {}
+    parsed = ParsedSig.new
     found_params = T.let(false, T::Boolean)
     found_return = T.let(false, T::Boolean)
-    bfs_traverse(sig_node, exclude: %i[array hash]) do |n|
+    bfs_traverse(sig_node, exclude: SIG_EXCLUDES) do |n|
       if n.source == 'abstract'
-        parsed[:abstract] = true
+        parsed.abstract = true
       elsif n.source == 'params' && !found_params
         found_params = true
         sibling = T.must(sibling_node(n))
-        bfs_traverse(sibling, exclude: %i[array call hash]) do |p|
+        bfs_traverse(sibling, exclude: PARAM_EXCLUDES) do |p|
           if p.type == :assoc
             param_name = p.children.first.source[0...-1]
             types = YARDSorbet::SigToYARD.convert(p.children.last)
-            parsed[:params][param_name] = types
+            parsed.params[param_name] = types
           end
         end
       elsif n.source == 'returns' && !found_return
         found_return = true
-        parsed[:return] = YARDSorbet::SigToYARD.convert(T.must(sibling_node(n)))
+        parsed.return = YARDSorbet::SigToYARD.convert(T.must(sibling_node(n)))
       elsif n.source == 'void'
-        parsed[:return] ||= ['void']
+        parsed.return ||= ['void']
       end
     end
     parsed
   end
 
   # Returns true if the given node is part of a type signature.
+  sig { params(node: T.nilable(YARD::Parser::Ruby::AstNode)).returns(T::Boolean) }
   private def type_signature?(node)
     loop do
       return false if node.nil?
-      return false unless %i[call vcall fcall].include?(node.type)
+      return false unless SIG_NODE_TYPES.include?(node.type)
       return true if T.unsafe(node).method_name(true) == :sig
 
-      node = node.children.first
+      node = T.let(node.children.first, T.nilable(YARD::Parser::Ruby::AstNode))
     end
   end
 
+  sig { params(node: YARD::Parser::Ruby::AstNode).returns(T.nilable(YARD::Parser::Ruby::AstNode)) }
   private def sibling_node(node)
     found_sibling = T.let(false, T::Boolean)
     node.parent.children.each do |n|
@@ -116,7 +158,14 @@ class YARDSorbet::SigHandler < YARD::Handlers::Ruby::Base
   end
 
   # @yield [YARD::Parser::Ruby::AstNode]
-  private def bfs_traverse(node, exclude: [])
+  sig do
+    params(
+      node: YARD::Parser::Ruby::AstNode,
+      exclude: T::Array[Symbol],
+      _blk: T.proc.params(n: YARD::Parser::Ruby::AstNode).void
+    ).void
+  end
+  private def bfs_traverse(node, exclude: [], &_blk)
     queue = [node]
     while !queue.empty?
       n = T.must(queue.shift)

data/lib/yard-sorbet/sig_to_yard.rb

@@ -1,17 +1,21 @@
+# typed: strict
 # frozen_string_literal: true
-# typed: true
 
 # Translate sig type syntax to YARD type syntax.
 module YARDSorbet::SigToYARD
-  IS_LEGACY_RUBY_VERSION = RUBY_VERSION.match?(/\A2\.[45]\./)
+  extend T::Sig
+
+  IS_LEGACY_RUBY_VERSION = T.let(RUBY_VERSION.start_with?('2.5.'), T::Boolean)
 
   # @see https://yardoc.org/types.html
+  sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Array[String]) }
   def self.convert(node)
     types = convert_type(node)
     # scrub newlines, as they break the YARD parser
     types.map { |type| type.gsub(/\n\s*/, ' ') }
   end
 
+  sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Array[String]) }
   def self.convert_type(node)
     children = node.children
     case node.type
@@ -27,8 +31,8 @@ module YARDSorbet::SigToYARD
         value_type = convert(children.last.children.last).join(', ')
         ["Hash{#{key_type} => #{value_type}}"]
       else
-        log.warn("Unsupported sig aref node #{node.source}")
-        [node.source]
+        log.info("Unsupported sig aref node #{node.source}")
+        [build_generic_type(node)]
       end
     when :arg_paren
       convert(children.first.children.first)
@@ -40,7 +44,7 @@ module YARDSorbet::SigToYARD
       if children[0].source == 'T'
         t_method = IS_LEGACY_RUBY_VERSION ? children[1].source : children[2].source
         case t_method
-        when 'all', 'class_of', 'enum', 'noreturn', 'self_type', 'type_parameter', 'untyped'
+        when 'all', 'attached_class', 'class_of', 'enum', 'noreturn', 'self_type', 'type_parameter', 'untyped'
           # YARD doesn't have equivalent notions, so we just use the raw source
           [node.source]
         when 'any'
@@ -56,7 +60,7 @@ module YARDSorbet::SigToYARD
       else
         [node.source]
       end
-    when :const_path_ref
+    when :const_path_ref, :const
       case node.source
       when 'T::Boolean'
         ['Boolean'] # YARD convention for booleans
@@ -83,9 +87,25 @@ module YARDSorbet::SigToYARD
       else
         [node.source]
       end
+    when :top_const_ref
+      # A top-level constant reference, such as ::Klass
+      # It contains a child node of type :const
+      convert(children.first)
     else
       log.warn("Unsupported sig #{node.type} node #{node.source}")
       [node.source]
     end
   end
+
+  sig { params(node: YARD::Parser::Ruby::AstNode).returns(String) }
+  def self.build_generic_type(node)
+    return node.source if node.children.empty? || node.type != :aref
+
+    collection_type = node.children.first.source
+    member_type = node.children.last.children
+                      .map { |child| build_generic_type(child) }
+                      .join(', ')
+
+    "#{collection_type}[#{member_type}]"
+  end
 end

data/lib/yard-sorbet/struct_handler.rb

@@ -1,14 +1,23 @@
+# typed: strict
 # frozen_string_literal: true
 
-# Handle all `const` calls, creating accessor methods, and compiles them for later usage at the class level
+# Handles all `const`/`prop` calls, creating accessor methods, and compiles them for later usage at the class level
 # in creating a constructor
 class YARDSorbet::StructHandler < YARD::Handlers::Ruby::Base
-  handles method_call(:const)
+  extend T::Sig
+
+  handles method_call(:const), method_call(:prop)
   namespace_only
 
+  sig { void }
   def process
     # Store the property for use in the constructor definition
-    name = statement.parameters[0].jump(:ident).source
+    name = statement.parameters[0].jump(
+      :ident, # handles most "normal" identifiers
+      :kw,    # handles prop names using reserved words like `end` or `def`
+      :const  # handles capitalized prop names like Foo
+    ).source
+
     doc = statement.docstring.to_s
     source = statement.source
     types = YARDSorbet::SigToYARD.convert(statement.parameters[1])
@@ -30,29 +39,36 @@ class YARDSorbet::StructHandler < YARD::Handlers::Ruby::Base
     object = MethodObject.new(namespace, name, scope)
     object.source = source
 
-    register(object)
-
     reader_docstring = doc.empty? ? "Returns the value of attribute +#{name}+." : doc
     docstring = YARD::DocstringParser.new.parse(reader_docstring).to_docstring
     docstring.add_tag(YARD::Tags::Tag.new(:return, '', types))
     object.docstring = docstring.to_raw
 
-    # Register the object explicitly as an attribute
+    # Register the object explicitly as an attribute.
+    # While `const` attributes are immutable, `prop` attributes may be reassigned.
+    if statement.method_name.source == 'prop'
+      namespace.attributes[scope][name][:write] = object
+    end
     namespace.attributes[scope][name][:read] = object
   end
 end
 
-# Class-level handler that folds all `const` declarations into the constructor documentation
+# Class-level handler that folds all `const` and `prop` declarations into the constructor documentation
 # this needs to be injected as a module otherwise the default Class handler will overwrite documentation
 module YARDSorbet::StructClassHandler
+  extend T::Sig
+
+  sig { void }
   def process
     ret = super
 
-    return ret if extra_state.prop_docs.nil?
+    return ret if T.unsafe(self).extra_state.prop_docs.nil?
 
     # lookup the full YARD path for the current class
-    class_ns = YARD::CodeObjects::ClassObject.new(namespace, statement[0].source.gsub(/\s/, ''))
-    props = extra_state.prop_docs[class_ns]
+    class_ns = YARD::CodeObjects::ClassObject.new(
+      T.unsafe(self).namespace, T.unsafe(self).statement[0].source.gsub(/\s/, '')
+    )
+    props = T.unsafe(self).extra_state.prop_docs[class_ns]
 
     return ret if props.empty?
 
@@ -81,7 +97,7 @@ module YARDSorbet::StructClassHandler
     object.source ||= props.map { |p| p[:source] }.join("\n")
     object.explicit ||= false # not strictly necessary
 
-    register(object)
+    T.unsafe(self).register(object)
 
     object.docstring = docstring.to_raw
 

data/lib/yard-sorbet/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module YARDSorbet
-  VERSION = '0.0.1'
+  VERSION = '0.4.1'
 end

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: yard-sorbet
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.4.1
 platform: ruby
 authors:
 - Douglas Eichelberger
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-01-24 00:00:00.000000000 Z
+date: 2021-04-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: codecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.1.16
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.1.16
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -44,98 +44,140 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.9'
+        version: '3.10'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.9'
+        version: '3.10'
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.78.0
+        version: 1.13.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.13.0
+- !ruby/object:Gem::Dependency
+  name: rubocop-performance
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.11.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.78.0
+        version: 1.11.0
+- !ruby/object:Gem::Dependency
+  name: rubocop-rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.1
 - !ruby/object:Gem::Dependency
   name: rubocop-rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.37'
+        version: 2.3.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.37'
+        version: 2.3.0
 - !ruby/object:Gem::Dependency
-  name: simplecov
+  name: rubocop-sorbet
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.17.1
+        version: 0.6.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.17.1
+        version: 0.6.0
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  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'
 - !ruby/object:Gem::Dependency
   name: sorbet
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.5.5200
+        version: 0.5.6193
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.5.5200
+        version: 0.5.6193
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.5'
+        version: 0.5.5845
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.5'
+        version: 0.5.5845
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.9'
+        version: 0.9.16
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.9'
+        version: 0.9.16
 description: 'A YARD plugin that incorporates Sorbet type information
 
   '
@@ -144,66 +186,21 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".editorconfig"
-- ".gitignore"
-- ".rspec"
-- ".rubocop.yml"
-- ".travis.yml"
-- CHANGELOG.md
-- Gemfile
 - LICENSE
-- README.md
-- Rakefile
 - lib/yard-sorbet.rb
 - lib/yard-sorbet/directives.rb
 - lib/yard-sorbet/sig_handler.rb
 - lib/yard-sorbet/sig_to_yard.rb
 - lib/yard-sorbet/struct_handler.rb
 - lib/yard-sorbet/version.rb
-- sorbet/config
-- sorbet/rbi/gems/ast.rbi
-- sorbet/rbi/gems/byebug.rbi
-- sorbet/rbi/gems/codecov.rbi
-- sorbet/rbi/gems/coderay.rbi
-- sorbet/rbi/gems/docile.rbi
-- sorbet/rbi/gems/jaro_winkler.rbi
-- sorbet/rbi/gems/method_source.rbi
-- sorbet/rbi/gems/parallel.rbi
-- sorbet/rbi/gems/parser.rbi
-- sorbet/rbi/gems/pry-byebug.rbi
-- sorbet/rbi/gems/pry.rbi
-- sorbet/rbi/gems/rainbow.rbi
-- sorbet/rbi/gems/rake.rbi
-- sorbet/rbi/gems/rspec-core.rbi
-- sorbet/rbi/gems/rspec-expectations.rbi
-- sorbet/rbi/gems/rspec-mocks.rbi
-- sorbet/rbi/gems/rspec-support.rbi
-- sorbet/rbi/gems/rspec.rbi
-- sorbet/rbi/gems/rubocop-rspec.rbi
-- sorbet/rbi/gems/rubocop.rbi
-- sorbet/rbi/gems/ruby-progressbar.rbi
-- sorbet/rbi/gems/simplecov-html.rbi
-- sorbet/rbi/gems/simplecov.rbi
-- sorbet/rbi/gems/site_ruby.rbi
-- sorbet/rbi/gems/unicode-display_width.rbi
-- sorbet/rbi/gems/yard.rbi
-- sorbet/rbi/hidden-definitions/errors.txt
-- sorbet/rbi/hidden-definitions/hidden.rbi
-- sorbet/rbi/sorbet-typed/lib/bundler/all/bundler.rbi
-- sorbet/rbi/sorbet-typed/lib/ruby/all/gem.rbi
-- sorbet/rbi/sorbet-typed/lib/ruby/all/open3.rbi
-- sorbet/rbi/sorbet-typed/lib/ruby/all/resolv.rbi
-- spec/data/sig_handler.rb.txt
-- spec/data/struct_handler.rb.txt
-- spec/spec_helper.rb
-- spec/yard_sorbet/sig_handler_spec.rb
-- spec/yard_sorbet/struct_handler_spec.rb
-- yard-sorbet.gemspec
 homepage: https://github.com/dduugg/yard-sorbet
 licenses:
 - Apache-2.0
-metadata: {}
-post_install_message: 
+metadata:
+  homepage_uri: https://github.com/dduugg/yard-sorbet
+  source_code_uri: https://github.com/dduugg/yard-sorbet
+  changelog_uri: https://github.com/dduugg/yard-sorbet/blob/master/CHANGELOG.md
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -211,15 +208,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.4.0
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.1
-signing_key: 
+rubygems_version: 3.1.4
+signing_key:
 specification_version: 4
 summary: Create YARD docs from Sorbet type signatures
 test_files: []