yard-sorbet 0.8.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6269732c6f6c20a5757281dea8e97537116082e9f6fcc01af8e37b375585c573
-  data.tar.gz: 3ba3e2a3e9caf49054d30a3e6030540804d7515eecda12eda07140402406879b
+  metadata.gz: 1421bf5c36984eb95f6d05e83900bdc9599a052fa51edb2939cf9dc656f5722b
+  data.tar.gz: 3922ad972509e1bfb185903ff40dfce5952fca881ea4196f7c8c2f37a572ae24
 SHA512:
-  metadata.gz: aa63a4e71daaffb9e18d5613bed37d366b47f80ca040570e2195716b1ae2f275d2e1cad568df123064b0678ee9862d757e05b026efcaa164d80eaae26f2eb65a
-  data.tar.gz: 3d7de3147fe46b1ca6339ef32d66ae98c0f48851205a3baee320a88bbafec44921f64672c335c291a2b117895fa858e49fb254cd7ec3f2b20eb339f06e324f39
+  metadata.gz: 2a7531bf6292ee4d37d5257ce851d62a9738c8f9319595f5c638b30e9a0cb324980b5fa3608b6b45da1e7fa9940323e7e31cbab9621957e8b0addab86020f11c
+  data.tar.gz: 365dac401f8792a0841496ccb07a3b08ee5d88d5f1de29a38312094eddc659f6fc6b9b087032e11fa862a482c6d30dc2069244aa060719eb81666d5358b7d5d3

data/lib/yard-sorbet/directives.rb

@@ -18,8 +18,6 @@ module YARDSorbet
     end
 
     sig { params(docstring: String, directives: T::Array[String]).void }
-    def self.add_directives(docstring, directives)
-      directives.each { docstring.concat("\n#{_1}") }
-    end
+    def self.add_directives(docstring, directives) = directives.each { docstring.concat("\n#{_1}") }
   end
 end

data/lib/yard-sorbet/handlers/abstract_dsl_handler.rb

@@ -3,7 +3,7 @@
 
 module YARDSorbet
   module Handlers
-    # Apllies an `@abstract` tag to `abstract!`/`interface!` modules (if not alerady present).
+    # Applies an `@abstract` tag to `abstract!`/`interface!` modules (if not alerady present).
     class AbstractDSLHandler < YARD::Handlers::Ruby::Base
       extend T::Sig
 
@@ -15,7 +15,7 @@ module YARDSorbet
       #   The `@abstract` tag template
       TAG_TEXT = 'Subclasses must implement the `abstract` methods below.'
       # Extra text for class namespaces
-      CLASS_TAG_TEXT = T.let("It cannot be directly instantiated. #{TAG_TEXT}", String)
+      CLASS_TAG_TEXT = T.let("It cannot be directly instantiated. #{TAG_TEXT}".freeze, String)
 
       sig { void }
       def process

data/lib/yard-sorbet/handlers/enums_handler.rb

@@ -26,9 +26,7 @@ module YARDSorbet
       private
 
       sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Boolean) }
-      def const_assign_node?(node)
-        node.type == :assign && node[0][0].type == :const
-      end
+      def const_assign_node?(node) = node.type == :assign && node[0][0].type == :const
     end
   end
 end

data/lib/yard-sorbet/handlers/mixes_in_class_methods_handler.rb

@@ -15,9 +15,7 @@ module YARDSorbet
       @@mix_in_class_methods = T.let({}, T::Hash[String, T::Array[String]]) # rubocop:disable Style/ClassVars
 
       sig { params(code_obj: String).returns(T.nilable(T::Array[String])) }
-      def self.mixed_in_class_methods(code_obj)
-        @@mix_in_class_methods[code_obj]
-      end
+      def self.mixed_in_class_methods(code_obj) = @@mix_in_class_methods[code_obj]
 
       sig { void }
       def process

data/lib/yard-sorbet/handlers/sig_handler.rb

@@ -37,7 +37,7 @@ module YARDSorbet
         separator = scope == :instance && def_node.type == :def ? '#' : '.'
         registered = YARD::Registry.at("#{namespace}#{separator}#{def_node.method_name(true)}")
         if registered
-          parse_node(registered, registered.docstring)
+          parse_node(registered, statement.docstring || registered.docstring)
           # Since we're probably in an RBI file, delete the def node, which could otherwise erroneously override the
           # visibility setting
           NodeUtils.delete_node(def_node)
@@ -64,21 +64,19 @@ module YARDSorbet
         attrs = namespace.attributes[scope][names[0]]
         return false if attrs.nil? || attrs.empty?
 
-        document_attr_methods(attrs.values.compact)
+        document_attrs(attrs.values.compact)
         attr_node.docstring = nil
         true
       end
 
       sig { params(method_objects: T::Array[YARD::CodeObjects::MethodObject]).void }
-      def document_attr_methods(method_objects)
-        method_objects.each { parse_node(_1, _1.docstring, include_params: false) }
-      end
+      def document_attrs(method_objects) =  method_objects.each { parse_node(_1, _1.docstring, include_params: false) }
 
       sig { params(attach_to: Documentable, docstring: T.nilable(String), include_params: T::Boolean).void }
       def parse_node(attach_to, docstring, include_params: true)
         existing_docstring = docstring.is_a?(YARD::Docstring)
         docstring, directives = Directives.extract_directives(docstring) unless existing_docstring
-        parse_sig(docstring, include_params: include_params)
+        parse_sig(docstring, include_params:)
         attach_to.docstring = docstring.to_raw
         Directives.add_directives(attach_to.docstring, directives) unless existing_docstring
       end

data/lib/yard-sorbet/handlers/struct_prop_handler.rb

@@ -13,7 +13,7 @@ module YARDSorbet
 
       sig { void }
       def process
-        name = params[0][-1][-1].source
+        name = params.dig(0, -1, -1).source
         prop = make_prop(name)
         update_state(prop)
         object = YARD::CodeObjects::MethodObject.new(namespace, name, scope)
@@ -35,15 +35,11 @@ module YARDSorbet
       end
 
       sig { returns(T::Boolean) }
-      def immutable?
-        statement.method_name(true) == :const || kw_arg('immutable:') == 'true'
-      end
+      def immutable? = statement.method_name(true) == :const || kw_arg('immutable:') == 'true'
 
       # @return the value passed to the keyword argument, or nil
       sig { params(kwd: String).returns(T.nilable(String)) }
-      def kw_arg(kwd)
-        params[2]&.find { _1[0].source == kwd }&.[](1)&.source
-      end
+      def kw_arg(kwd) = params[2]&.find { _1[0].source == kwd }&.[](1)&.source
 
       sig { params(name: String).returns(TStructProp) }
       def make_prop(name)
@@ -52,21 +48,19 @@ module YARDSorbet
           doc: statement.docstring.to_s,
           prop_name: name,
           source: statement.source,
-          types: SigToYARD.convert(params[1])
+          types: SigToYARD.convert(params.fetch(1))
         )
       end
 
-      sig { returns(T::Array[T.untyped]) }
-      def params
-        @params ||= T.let(statement.parameters(false), T.nilable(T::Array[T.untyped]))
-      end
+      sig { returns(T::Array[YARD::Parser::Ruby::AstNode]) }
+      def params = @params ||= T.let(statement.parameters(false), T.nilable(T::Array[YARD::Parser::Ruby::AstNode]))
 
       # Register the field explicitly as an attribute.
       sig { params(object: YARD::CodeObjects::MethodObject, name: String).void }
       def register_attrs(object, name)
         write = immutable? ? nil : object
         # Create the virtual attribute in our current scope
-        namespace.attributes[scope][name] ||= SymbolHash[read: object, write: write]
+        namespace.attributes[scope][name] ||= SymbolHash[read: object, write:]
       end
 
       # Store the prop for use in the constructor definition

data/lib/yard-sorbet/node_utils.rb

@@ -19,25 +19,33 @@ module YARDSorbet
     # @yield [YARD::Parser::Ruby::AstNode]
     sig { params(node: YARD::Parser::Ruby::AstNode, _blk: T.proc.params(n: YARD::Parser::Ruby::AstNode).void).void }
     def self.bfs_traverse(node, &_blk)
-      queue = [node]
+      queue = Queue.new << node
       until queue.empty?
-        n = T.must(queue.shift)
+        n = queue.deq(true)
         yield n
-        n.children.each { queue.push(_1) }
-        queue.pop if n.is_a?(YARD::Parser::Ruby::MethodCallNode) && SKIP_METHOD_CONTENTS.include?(n.method_name(true))
+        enqueue_children(queue, n)
       end
     end
 
     sig { params(node: YARD::Parser::Ruby::AstNode).void }
-    def self.delete_node(node)
-      node.parent.children.delete(node)
+    def self.delete_node(node) = node.parent.children.delete(node)
+
+    # Enqueue the eligible children of a node in the BFS queue
+    sig { params(queue: Queue, node: YARD::Parser::Ruby::AstNode).void }
+    def self.enqueue_children(queue, node)
+      last_child = node.children.last
+      node.children.each do |child|
+        next if child == last_child &&
+                node.is_a?(YARD::Parser::Ruby::MethodCallNode) &&
+                SKIP_METHOD_CONTENTS.include?(node.method_name(true))
+
+        queue.enq(child)
+      end
     end
 
     # Gets the node that a sorbet `sig` can be attached do, bypassing visisbility modifiers and the like
     sig { params(node: YARD::Parser::Ruby::AstNode).returns(SigableNode) }
-    def self.get_method_node(node)
-      sigable_node?(node) ? node : node.jump(:def, :defs)
-    end
+    def self.get_method_node(node) = sigable_node?(node) ? node : node.jump(:def, :defs)
 
     # Find and return the adjacent node (ascending)
     # @raise [IndexError] if the node does not have an adjacent sibling (ascending)

data/lib/yard-sorbet/sig_to_yard.rb

@@ -4,127 +4,121 @@
 module YARDSorbet
   # Translate `sig` type syntax to `YARD` type syntax.
   module SigToYARD
-    extend T::Sig
-
-    # Map of common types to YARD conventions (in order to reduce allocations)
-    REF_TYPES = T.let({
-      'T::Boolean' => ['Boolean'].freeze, # YARD convention for booleans
-      # YARD convention is use singleton objects when applicable:
-      # https://www.rubydoc.info/gems/yard/file/docs/Tags.md#Literals
-      'FalseClass' => ['false'].freeze,
-      'NilClass' => ['nil'].freeze,
-      'TrueClass' => ['true'].freeze
-    }.freeze, T::Hash[String, [String]])
-    private_constant :REF_TYPES
-
-    # @see https://yardoc.org/types.html
-    sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Array[String]) }
-    def self.convert(node)
-      # scrub newlines, as they break the YARD parser
-      convert_node(node).map { _1.gsub(/\n\s*/, ' ') }
-    end
-
-    sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Array[String]) }
-    private_class_method def self.convert_node(node)
-      case node
-      when YARD::Parser::Ruby::MethodCallNode then convert_call(node)
-      when YARD::Parser::Ruby::ReferenceNode then convert_ref(node.source)
-      else convert_node_type(node)
+    class << self
+      extend T::Sig
+
+      # Map of common types to YARD conventions (in order to reduce allocations)
+      REF_TYPES = T.let({
+        'T::Boolean' => ['Boolean'].freeze, # YARD convention for booleans
+        # YARD convention is to use singleton objects when applicable:
+        # https://www.rubydoc.info/gems/yard/file/docs/Tags.md#literals
+        'FalseClass' => ['false'].freeze,
+        'NilClass' => ['nil'].freeze,
+        'TrueClass' => ['true'].freeze
+      }.freeze, T::Hash[String, [String]])
+      private_constant :REF_TYPES
+
+      # @see https://yardoc.org/types.html
+      sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Array[String]) }
+      def convert(node) = convert_node(node).map { _1.gsub(/\n\s*/, ' ') }
+
+      private
+
+      sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Array[String]) }
+      def convert_node(node)
+        case node
+        when YARD::Parser::Ruby::MethodCallNode
+          node.namespace.source == 'T' ? convert_t_method(node) : [node.source]
+        when YARD::Parser::Ruby::ReferenceNode
+          node_source = node.source
+          REF_TYPES[node_source] || [node_source]
+        else convert_node_type(node)
+        end
       end
-    end
 
-    sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Array[String]) }
-    private_class_method def self.convert_node_type(node)
-      case node.type
-      when :aref then convert_aref(node)
-      when :arg_paren then convert_node(node.first)
-      when :array then convert_array(node)
-      # Fixed hashes as return values are unsupported:
-      # https://github.com/lsegal/yard/issues/425
-      #
-      # Hash key params can be individually documented with `@option`, but
-      # sig translation is currently unsupported.
-      when :hash then ['Hash']
-      # seen when sig methods omit parentheses
-      when :list then convert_list(node)
-      else convert_unknown(node)
+      sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Array[String]) }
+      def convert_node_type(node)
+        case node.type
+        when :aref then convert_aref(node)
+        when :arg_paren then convert_node(node.first)
+        when :array then convert_array(node)
+        # Fixed hashes as return values are unsupported:
+        # https://github.com/lsegal/yard/issues/425
+        #
+        # Hash key params can be individually documented with `@option`, but
+        # sig translation is currently unsupported.
+        when :hash then ['Hash']
+        # seen when sig methods omit parentheses
+        when :list then convert_list(node)
+        else convert_unknown(node)
+        end
       end
-    end
 
-    sig { params(node: YARD::Parser::Ruby::AstNode).returns(String) }
-    private_class_method def self.build_generic_type(node)
-      return node.source if node.empty? || node.type != :aref
+      sig { params(node: YARD::Parser::Ruby::AstNode).returns(String) }
+      def build_generic_type(node)
+        return node.source if node.empty? || node.type != :aref
 
-      collection_type = node.first.source
-      member_type = node.last.children.map { build_generic_type(_1) }.join(', ')
-      "#{collection_type}[#{member_type}]"
-    end
-
-    sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Array[String]) }
-    private_class_method def self.convert_aref(node)
-      # https://www.rubydoc.info/gems/yard/file/docs/Tags.md#Parametrized_Types
-      case node.first.source
-      when 'T::Array', 'T::Enumerable', 'T::Range', 'T::Set' then convert_collection(node)
-      when 'T::Hash' then convert_hash(node)
-      else
-        log.info("Unsupported sig aref node #{node.source}")
-        [build_generic_type(node)]
+        collection_type = node.first.source
+        member_type = node.last.children.map { build_generic_type(_1) }.join(', ')
+        "#{collection_type}[#{member_type}]"
       end
-    end
 
-    sig { params(node: YARD::Parser::Ruby::AstNode).returns([String]) }
-    private_class_method def self.convert_array(node)
-      # https://www.rubydoc.info/gems/yard/file/docs/Tags.md#Order-Dependent_Lists
-      member_types = node.first.children.map { convert_node(_1) }
-      sequence = member_types.map { _1.size == 1 ? _1[0] : _1.to_s.tr('"', '') }.join(', ')
-      ["Array(#{sequence})"]
-    end
-
-    sig { params(node: YARD::Parser::Ruby::MethodCallNode).returns(T::Array[String]) }
-    private_class_method def self.convert_call(node)
-      node.namespace.source == 'T' ? convert_t_method(node) : [node.source]
-    end
+      sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Array[String]) }
+      def convert_aref(node)
+        # https://www.rubydoc.info/gems/yard/file/docs/Tags.md#parametrized-types
+        case node.first.source
+        when 'T::Array', 'T::Enumerable', 'T::Range', 'T::Set' then convert_collection(node)
+        when 'T::Hash' then convert_hash(node)
+        else
+          log.info("Unsupported sig aref node #{node.source}")
+          [build_generic_type(node)]
+        end
+      end
 
-    sig { params(node: YARD::Parser::Ruby::AstNode).returns([String]) }
-    private_class_method def self.convert_collection(node)
-      collection_type = node.first.source.split('::').last
-      member_type = convert_node(node[-1][0]).join(', ')
-      ["#{collection_type}<#{member_type}>"]
-    end
+      sig { params(node: YARD::Parser::Ruby::AstNode).returns([String]) }
+      def convert_array(node)
+        # https://www.rubydoc.info/gems/yard/file/docs/Tags.md#order-dependent-lists
+        member_types = node.first.children.map { convert_node(_1) }
+        sequence = member_types.map { _1.size == 1 ? _1[0] : _1.to_s.tr('"', '') }.join(', ')
+        ["Array<(#{sequence})>"]
+      end
 
-    sig { params(node: YARD::Parser::Ruby::AstNode).returns([String]) }
-    private_class_method def self.convert_hash(node)
-      kv = node.last.children
-      key_type = convert_node(kv.first).join(', ')
-      value_type = convert_node(kv.last).join(', ')
-      ["Hash{#{key_type} => #{value_type}}"]
-    end
+      sig { params(node: YARD::Parser::Ruby::AstNode).returns([String]) }
+      def convert_collection(node)
+        collection_type = node.first.source.split('::').last
+        member_type = convert_node(node[-1][0]).join(', ')
+        ["#{collection_type}<#{member_type}>"]
+      end
 
-    sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Array[String]) }
-    private_class_method def self.convert_list(node)
-      node.children.size == 1 ? convert_node(node.children.first) : [node.source]
-    end
+      sig { params(node: YARD::Parser::Ruby::AstNode).returns([String]) }
+      def convert_hash(node)
+        kv = node.last.children
+        key_type = convert_node(kv.first).join(', ')
+        value_type = convert_node(kv.last).join(', ')
+        ["Hash{#{key_type} => #{value_type}}"]
+      end
 
-    sig { params(node_source: String).returns([String]) }
-    private_class_method def self.convert_ref(node_source)
-      REF_TYPES[node_source] || [node_source]
-    end
+      sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Array[String]) }
+      def convert_list(node)
+        node.children.size == 1 ? convert_node(node.children.first) : [node.source]
+      end
 
-    sig { params(node: YARD::Parser::Ruby::MethodCallNode).returns(T::Array[String]) }
-    private_class_method def self.convert_t_method(node)
-      case node.method_name(true)
-      # Order matters here, putting `nil` last results in a more concise return syntax in the UI (superscripted `?`):
-      # https://github.com/lsegal/yard/blob/cfa62ae/lib/yard/templates/helpers/html_helper.rb#L499-L500
-      when :nilable then convert_node(node.last) + REF_TYPES.fetch('NilClass')
-      when :any then node[-1][0].children.flat_map { convert_node(_1) }
-      else [node.source]
+      sig { params(node: YARD::Parser::Ruby::MethodCallNode).returns(T::Array[String]) }
+      def convert_t_method(node)
+        case node.method_name(true)
+        # Order matters here, putting `nil` last results in a more concise return syntax in the UI (superscripted `?`):
+        # https://github.com/lsegal/yard/blob/cfa62ae/lib/yard/templates/helpers/html_helper.rb#L499-L500
+        when :nilable then convert_node(node.last) + REF_TYPES.fetch('NilClass')
+        when :any then node[-1][0].children.flat_map { convert_node(_1) }
+        else [node.source]
+        end
       end
-    end
 
-    sig { params(node: YARD::Parser::Ruby::AstNode).returns([String]) }
-    private_class_method def self.convert_unknown(node)
-      log.warn("Unsupported sig #{node.type} node #{node.source}")
-      [node.source]
+      sig { params(node: YARD::Parser::Ruby::AstNode).returns([String]) }
+      def convert_unknown(node)
+        log.warn("Unsupported sig #{node.type} node #{node.source}")
+        [node.source]
+      end
     end
   end
 end

data/lib/yard-sorbet/tag_utils.rb

@@ -13,9 +13,7 @@ module YARDSorbet
     sig do
       params(docstring: YARD::Docstring, tag_name: String, name: T.nilable(String)).returns(T.nilable(YARD::Tags::Tag))
     end
-    def self.find_tag(docstring, tag_name, name)
-      docstring.tags.find { _1.tag_name == tag_name && _1.name == name }
-    end
+    def self.find_tag(docstring, tag_name, name) = docstring.tags.find { _1.tag_name == tag_name && _1.name == name }
 
     # Create or update a `YARD` tag with type information
     sig do

data/lib/yard-sorbet/version.rb

@@ -4,5 +4,5 @@
 # Types are documentation
 module YARDSorbet
   # {https://rubygems.org/gems/yard-sorbet Version history}
-  VERSION = '0.8.0'
+  VERSION = '0.9.0'
 end

metadata

@@ -1,211 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: yard-sorbet
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Douglas Eichelberger
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-01-14 00:00:00.000000000 Z
+date: 2024-06-30 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: bundler-audit
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.9.1
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.9.1
-- !ruby/object:Gem::Dependency
-  name: codecov
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.6.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.6.0
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '13.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '13.0'
-- !ruby/object:Gem::Dependency
-  name: redcarpet
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.5'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.5'
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.10'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.10'
-- !ruby/object:Gem::Dependency
-  name: rubocop
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.42.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.42.0
-- !ruby/object:Gem::Dependency
-  name: rubocop-performance
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.15.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.15.0
-- !ruby/object:Gem::Dependency
-  name: rubocop-rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.6.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.6.0
-- !ruby/object:Gem::Dependency
-  name: rubocop-rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 2.16.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 2.16.0
-- !ruby/object:Gem::Dependency
-  name: rubocop-sorbet
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.6.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.6.0
-- !ruby/object:Gem::Dependency
-  name: sorbet
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.5.9204
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.5.9204
-- !ruby/object:Gem::Dependency
-  name: tapioca
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.10.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.10.0
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.5'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.5'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.9'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.9'
+        version: '0'
 description: A YARD plugin that incorporates Sorbet type information
 email: dduugg@gmail.com
 executables: []
@@ -248,14 +80,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.7.0
+      version: '3.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.33
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: Create YARD docs from Sorbet type signatures