yard-sorbet 0.6.1 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2f2eb93a66e3c6308a6e1cb10e26eae958d8b114451ee4405659f13da9d423cf
-  data.tar.gz: 869f388d3b14dfaec0d63bb910ab039ec556f010fc586fe8d5e6234a2e1e2bac
+  metadata.gz: 6269732c6f6c20a5757281dea8e97537116082e9f6fcc01af8e37b375585c573
+  data.tar.gz: 3ba3e2a3e9caf49054d30a3e6030540804d7515eecda12eda07140402406879b
 SHA512:
-  metadata.gz: 4ec95f037474cb2e2c95aed81e369901e945014e241ecfb5d12fd4ce1cec1871dda4599ad0915d283ca2a8355b2125e22a71eefdf23fe27d98e06573590fe79b
-  data.tar.gz: d34b5eaabc45de6b5bb58fbc4592468cb0074872e11a6af0c062bea082a98c81687e283b66c98f786025ae5eddd1b64708932f50c6c9798d853fe2d1161b5e12
+  metadata.gz: aa63a4e71daaffb9e18d5613bed37d366b47f80ca040570e2195716b1ae2f275d2e1cad568df123064b0678ee9862d757e05b026efcaa164d80eaae26f2eb65a
+  data.tar.gz: 3d7de3147fe46b1ca6339ef32d66ae98c0f48851205a3baee320a88bbafec44921f64672c335c291a2b117895fa858e49fb254cd7ec3f2b20eb339f06e324f39

data/lib/yard-sorbet/directives.rb

@@ -13,18 +13,13 @@ module YARDSorbet
       # seem to be an API to tweeze them from one node to another without
       # managing YARD internal state. Instead, we just extract them from
       # the raw text and re-attach them.
-      directives = parser.raw_text&.split("\n")&.select do |line|
-        line.start_with?('@!')
-      end || []
-
+      directives = parser.raw_text&.split("\n")&.select { _1.start_with?('@!') } || []
       [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}")
-      end
+      directives.each { docstring.concat("\n#{_1}") }
     end
   end
 end

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

@@ -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 cannont be directly instantiated. #{TAG_TEXT}", String)
+      CLASS_TAG_TEXT = T.let("It cannot be directly instantiated. #{TAG_TEXT}", String)
 
       sig { void }
       def process

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

@@ -16,10 +16,8 @@ module YARDSorbet
       def process
         statement.parameters(false).each do |mixin|
           obj = YARD::CodeObjects::Proxy.new(namespace, mixin.source)
-          class_methods_namespace = MixesInClassMethodsHandler.mixed_in_class_methods(obj.to_s)
-          next unless class_methods_namespace
-
-          included_in.mixins(:class) << YARD::CodeObjects::Proxy.new(obj, class_methods_namespace)
+          class_methods_namespaces = MixesInClassMethodsHandler.mixed_in_class_methods(obj.to_s)
+          class_methods_namespaces&.each { included_in.mixins(:class) << YARD::CodeObjects::Proxy.new(obj, _1) }
         end
       end
 

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

@@ -12,16 +12,17 @@ module YARDSorbet
       handles method_call(:mixes_in_class_methods)
       namespace_only
 
-      @@mix_in_class_methods = T.let({}, T::Hash[String, String]) # rubocop:disable Style/ClassVars
+      @@mix_in_class_methods = T.let({}, T::Hash[String, T::Array[String]]) # rubocop:disable Style/ClassVars
 
-      sig { params(code_obj: String).returns(T.nilable(String)) }
+      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
 
       sig { void }
       def process
-        @@mix_in_class_methods[namespace.to_s] = statement.parameters(false)[0].source
+        @@mix_in_class_methods[namespace.to_s] ||= []
+        @@mix_in_class_methods.fetch(namespace.to_s) << statement.parameters(false)[0].source
       end
     end
   end

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

@@ -10,59 +10,104 @@ module YARDSorbet
       handles method_call(:sig)
       namespace_only
 
-      # These node types attached to sigs represent attr_* declarations
-      ATTR_NODE_TYPES = T.let(%i[command fcall], T::Array[Symbol])
-      private_constant :ATTR_NODE_TYPES
+      # YARD types that can have docstrings attached to them
+      Documentable = T.type_alias do
+        T.any(
+          YARD::CodeObjects::MethodObject, YARD::Parser::Ruby::MethodCallNode, YARD::Parser::Ruby::MethodDefinitionNode
+        )
+      end
+      private_constant :Documentable
 
       # Swap the method definition docstring and the sig docstring.
       # Parse relevant parts of the `sig` and include them as well.
       sig { void }
       def process
         method_node = NodeUtils.get_method_node(NodeUtils.sibling_node(statement))
-        docstring, directives = Directives.extract_directives(statement.docstring)
-        parse_sig(method_node, docstring)
-        method_node.docstring = docstring.to_raw
-        Directives.add_directives(method_node.docstring, directives)
+        case method_node
+        when YARD::Parser::Ruby::MethodDefinitionNode then process_def(method_node)
+        when YARD::Parser::Ruby::MethodCallNode then process_attr(method_node)
+        end
         statement.docstring = nil
       end
 
       private
 
-      sig { params(method_node: YARD::Parser::Ruby::AstNode, docstring: YARD::Docstring).void }
-      def parse_sig(method_node, docstring)
-        NodeUtils.bfs_traverse(statement) do |n|
-          case n.source
-          when 'abstract'
-            YARDSorbet::TagUtils.upsert_tag(docstring, 'abstract')
-          when 'params'
-            parse_params(method_node, n, docstring)
-          when 'returns', 'void'
-            parse_return(n, docstring)
-          end
+      sig { params(def_node: YARD::Parser::Ruby::MethodDefinitionNode).void }
+      def process_def(def_node)
+        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)
+          # 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)
+        else
+          parse_node(def_node, statement.docstring)
         end
       end
 
-      sig do
-        params(
-          method_node: YARD::Parser::Ruby::AstNode,
-          node: YARD::Parser::Ruby::AstNode,
-          docstring: YARD::Docstring
-        ).void
+      sig { params(attr_node: YARD::Parser::Ruby::MethodCallNode).void }
+      def process_attr(attr_node)
+        return if merged_into_attr?(attr_node)
+
+        parse_node(attr_node, statement.docstring, include_params: false)
       end
-      def parse_params(method_node, node, docstring)
-        return if ATTR_NODE_TYPES.include?(method_node.type)
 
+      # An attr* sig can be merged into a previous attr* docstring if it is the only parameter passed to the attr*
+      # declaration. This is to avoid needing to rewrite the source code to separate merged and unmerged attr*
+      # declarations.
+      sig { params(attr_node: YARD::Parser::Ruby::MethodCallNode).returns(T::Boolean) }
+      def merged_into_attr?(attr_node)
+        names = NodeUtils.validated_attribute_names(attr_node)
+        return false if names.size != 1
+
+        attrs = namespace.attributes[scope][names[0]]
+        return false if attrs.nil? || attrs.empty?
+
+        document_attr_methods(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
+
+      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)
+        attach_to.docstring = docstring.to_raw
+        Directives.add_directives(attach_to.docstring, directives) unless existing_docstring
+      end
+
+      sig { params(docstring: YARD::Docstring, include_params: T::Boolean).void }
+      def parse_sig(docstring, include_params: true)
+        NodeUtils.bfs_traverse(statement) do |node|
+          case node.source
+          when 'returns' then parse_return(node, docstring)
+          when 'params' then parse_params(node, docstring) if include_params
+          when 'void' then TagUtils.upsert_tag(docstring, 'return', TagUtils::VOID_RETURN_TYPE)
+          when 'abstract' then TagUtils.upsert_tag(docstring, 'abstract')
+          end
+        end
+      end
+
+      sig { params(node: YARD::Parser::Ruby::AstNode, docstring: YARD::Docstring).void }
+      def parse_params(node, docstring)
         sibling = NodeUtils.sibling_node(node)
-        sibling[0][0].each do |p|
-          param_name = p[0][0]
-          types = SigToYARD.convert(p.last)
+        sibling[0][0].each do |param|
+          param_name = param[0][0]
+          types = SigToYARD.convert(param.last)
           TagUtils.upsert_tag(docstring, 'param', types, param_name)
         end
       end
 
       sig { params(node: YARD::Parser::Ruby::AstNode, docstring: YARD::Docstring).void }
       def parse_return(node, docstring)
-        type = node.source == 'void' ? ['void'] : SigToYARD.convert(NodeUtils.sibling_node(node))
+        type = SigToYARD.convert(NodeUtils.sibling_node(node))
         TagUtils.upsert_tag(docstring, 'return', type)
       end
     end

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

@@ -33,11 +33,9 @@ module YARDSorbet
         # There is a chance that there is a custom initializer, so make sure we steal the existing docstring
         # and source
         docstring, directives = Directives.extract_directives(object.docstring)
-        object.tags.each { |tag| docstring.add_tag(tag) }
-        props.each do |prop|
-          TagUtils.upsert_tag(docstring, 'param', prop.types, prop.prop_name, prop.doc)
-        end
-        TagUtils.upsert_tag(docstring, 'return', ['void'])
+        object.tags.each { docstring.add_tag(_1) }
+        props.each { TagUtils.upsert_tag(docstring, 'param', _1.types, _1.prop_name, _1.doc) }
+        TagUtils.upsert_tag(docstring, 'return', TagUtils::VOID_RETURN_TYPE)
         decorate_t_struct_init(object, props, docstring, directives)
       end
 

data/lib/yard-sorbet/handlers/struct_class_handler.rbi

@@ -1,4 +1,6 @@
 # typed: strict
+# frozen_string_literal: true
+
 # This is in an rbi so the runtime doesn't depend on experimental sorbet features
 module YARDSorbet::Handlers::StructClassHandler
   requires_ancestor { YARD::Handlers::Ruby::ClassHandler }

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

@@ -13,7 +13,7 @@ module YARDSorbet
 
       sig { void }
       def process
-        name = statement.parameters.first.last.last.source
+        name = params[0][-1][-1].source
         prop = make_prop(name)
         update_state(prop)
         object = YARD::CodeObjects::MethodObject.new(namespace, name, scope)
@@ -27,37 +27,45 @@ module YARDSorbet
       sig { params(object: YARD::CodeObjects::MethodObject, prop: TStructProp).void }
       def decorate_object(object, prop)
         object.source = prop.source
-        # TODO: this should use `+` to delimit the attribute name when markdown is disabled
-        reader_docstring = prop.doc.empty? ? "Returns the value of attribute `#{prop.prop_name}`." : prop.doc
+        # TODO: this should use `+` to delimit the prop name when markdown is disabled
+        reader_docstring = prop.doc.empty? ? "Returns the value of prop `#{prop.prop_name}`." : prop.doc
         docstring = YARD::DocstringParser.new.parse(reader_docstring).to_docstring
         docstring.add_tag(YARD::Tags::Tag.new(:return, '', prop.types))
         object.docstring = docstring.to_raw
       end
 
-      # Get the default prop value
-      sig { returns(T.nilable(String)) }
-      def default_value
-        default_node = statement.traverse { |n| break n if n.type == :label && n.source == 'default:' }
-        default_node.parent[1].source if default_node
+      sig { returns(T::Boolean) }
+      def immutable?
+        statement.method_name(true) == :const || kw_arg('immutable:') == 'true'
+      end
+
+      # @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
 
       sig { params(name: String).returns(TStructProp) }
       def make_prop(name)
         TStructProp.new(
-          default: default_value,
+          default: kw_arg('default:'),
           doc: statement.docstring.to_s,
           prop_name: name,
           source: statement.source,
-          types: SigToYARD.convert(statement.parameters[1])
+          types: SigToYARD.convert(params[1])
         )
       end
 
+      sig { returns(T::Array[T.untyped]) }
+      def params
+        @params ||= T.let(statement.parameters(false), T.nilable(T::Array[T.untyped]))
+      end
+
       # Register the field explicitly as an attribute.
-      # While `const` attributes are immutable, `prop` attributes may be reassigned.
       sig { params(object: YARD::CodeObjects::MethodObject, name: String).void }
       def register_attrs(object, name)
-        # Create the virtual method in our current scope
-        write = statement.method_name(true) == :prop ? object : nil
+        write = immutable? ? nil : object
+        # Create the virtual attribute in our current scope
         namespace.attributes[scope][name] ||= SymbolHash[read: object, write: write]
       end
 

data/lib/yard-sorbet/node_utils.rb

@@ -8,45 +8,35 @@ module YARDSorbet
 
     # Command node types that can have type signatures
     ATTRIBUTE_METHODS = T.let(%i[attr attr_accessor attr_reader attr_writer].freeze, T::Array[Symbol])
-    # Node types that can have type signatures
-    SIGABLE_NODE = T.type_alias do
-      T.any(YARD::Parser::Ruby::MethodDefinitionNode, YARD::Parser::Ruby::MethodCallNode)
-    end
     # Skip these method contents during BFS node traversal, they can have their own nested types via `T.Proc`
-    SKIP_METHOD_CONTENTS = T.let(%i[params returns], T::Array[Symbol])
-
-    private_constant :ATTRIBUTE_METHODS, :SIGABLE_NODE
+    SKIP_METHOD_CONTENTS = T.let(%i[params returns].freeze, T::Array[Symbol])
+    # Node types that can have type signatures
+    SigableNode = T.type_alias { T.any(YARD::Parser::Ruby::MethodDefinitionNode, YARD::Parser::Ruby::MethodCallNode) }
+    private_constant :ATTRIBUTE_METHODS, :SKIP_METHOD_CONTENTS, :SigableNode
 
-    # Traverese AST nodes in breadth-first order
+    # Traverse AST nodes in breadth-first order
     # @note This will skip over some node types.
     # @yield [YARD::Parser::Ruby::AstNode]
-    sig do
-      params(
-        node: YARD::Parser::Ruby::AstNode,
-        _blk: T.proc.params(n: YARD::Parser::Ruby::AstNode).void
-      ).void
-    end
+    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]
       until queue.empty?
         n = T.must(queue.shift)
         yield n
-        n.children.each { |c| queue.push(c) }
+        n.children.each { queue.push(_1) }
         queue.pop if n.is_a?(YARD::Parser::Ruby::MethodCallNode) && SKIP_METHOD_CONTENTS.include?(n.method_name(true))
       end
     end
 
+    sig { params(node: YARD::Parser::Ruby::AstNode).void }
+    def self.delete_node(node)
+      node.parent.children.delete(node)
+    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(SIGABLE_NODE) }
+    sig { params(node: YARD::Parser::Ruby::AstNode).returns(SigableNode) }
     def self.get_method_node(node)
-      case node
-      when YARD::Parser::Ruby::MethodDefinitionNode
-        return node
-      when YARD::Parser::Ruby::MethodCallNode
-        return node if ATTRIBUTE_METHODS.include?(node.method_name(true))
-      end
-
-      node.jump(:def, :defs)
+      sigable_node?(node) ? node : node.jump(:def, :defs)
     end
 
     # Find and return the adjacent node (ascending)
@@ -54,8 +44,28 @@ module YARDSorbet
     sig { params(node: YARD::Parser::Ruby::AstNode).returns(YARD::Parser::Ruby::AstNode) }
     def self.sibling_node(node)
       siblings = node.parent.children
-      siblings.each_with_index.find do |sibling, i|
-        return siblings.fetch(i + 1) if sibling.equal?(node)
+      node_index = siblings.find_index { _1.equal?(node) }
+      siblings.fetch(node_index + 1)
+    end
+
+    sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Boolean) }
+    def self.sigable_node?(node)
+      case node
+      when YARD::Parser::Ruby::MethodDefinitionNode then true
+      when YARD::Parser::Ruby::MethodCallNode then ATTRIBUTE_METHODS.include?(node.method_name(true))
+      else false
+      end
+    end
+
+    # @see https://github.com/lsegal/yard/blob/main/lib/yard/handlers/ruby/attribute_handler.rb
+    #   YARD::Handlers::Ruby::AttributeHandler.validated_attribute_names
+    sig { params(attr_node: YARD::Parser::Ruby::MethodCallNode).returns(T::Array[String]) }
+    def self.validated_attribute_names(attr_node)
+      attr_node.parameters(false).map do |obj|
+        case obj
+        when YARD::Parser::Ruby::LiteralNode then obj[0][0].source
+        else raise YARD::Parser::UndocumentableError, obj.source
+        end
       end
     end
   end

data/lib/yard-sorbet/sig_to_yard.rb

@@ -6,18 +6,29 @@ module YARDSorbet
   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 { |type| type.gsub(/\n\s*/, ' ') }
+      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)
+      when YARD::Parser::Ruby::ReferenceNode then convert_ref(node.source)
       else convert_node_type(node)
       end
     end
@@ -45,8 +56,7 @@ module YARDSorbet
       return node.source if node.empty? || node.type != :aref
 
       collection_type = node.first.source
-      member_type = node.last.children.map { |child| build_generic_type(child) }.join(', ')
-
+      member_type = node.last.children.map { build_generic_type(_1) }.join(', ')
       "#{collection_type}[#{member_type}]"
     end
 
@@ -62,11 +72,11 @@ module YARDSorbet
       end
     end
 
-    sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Array[String]) }
+    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 { |n| convert_node(n) }
-      sequence = member_types.map { |mt| mt.size == 1 ? mt[0] : mt.to_s.tr('"', '') }.join(', ')
+      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
 
@@ -75,14 +85,14 @@ module YARDSorbet
       node.namespace.source == 'T' ? convert_t_method(node) : [node.source]
     end
 
-    sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Array[String]) }
+    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.last.first).join(', ')
+      member_type = convert_node(node[-1][0]).join(', ')
       ["#{collection_type}<#{member_type}>"]
     end
 
-    sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Array[String]) }
+    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(', ')
@@ -95,33 +105,23 @@ module YARDSorbet
       node.children.size == 1 ? convert_node(node.children.first) : [node.source]
     end
 
-    sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Array[String]) }
-    private_class_method def self.convert_ref(node)
-      source = node.source
-      case source
-      when 'T::Boolean' then ['Boolean'] # YARD convention for booleans
-      # YARD convention is use singleton objects when applicable:
-      # https://www.rubydoc.info/gems/yard/file/docs/Tags.md#Literals
-      when 'FalseClass' then ['false']
-      when 'NilClass' then ['nil']
-      when 'TrueClass' then ['true']
-      else [source]
-      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::MethodCallNode).returns(T::Array[String]) }
     private_class_method def self.convert_t_method(node)
       case node.method_name(true)
-      when :any then node.last.first.children.map { |n| convert_node(n) }.flatten
-      # Order matters here, putting `nil` last results in a more concise
-      # return syntax in the UI (superscripted `?`)
+      # 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) + ['nil']
+      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
 
-    sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Array[String]) }
+    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]

data/lib/yard-sorbet/t_struct_prop.rb

@@ -1,4 +1,4 @@
-# typed: strict
+# typed: strong
 # frozen_string_literal: true
 
 module YARDSorbet

data/lib/yard-sorbet/tag_utils.rb

@@ -6,13 +6,15 @@ module YARDSorbet
   module TagUtils
     extend T::Sig
 
+    # The `void` return type, as a constant to reduce array allocations
+    VOID_RETURN_TYPE = T.let(['void'].freeze, [String])
+
     # @return the tag with the matching `tag_name` and `name`, or `nil`
     sig do
-      params(docstring: YARD::Docstring, tag_name: String, name: T.nilable(String))
-        .returns(T.nilable(YARD::Tags::Tag))
+      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 { |t| t.tag_name == tag_name && t.name == name }
+      docstring.tags.find { _1.tag_name == tag_name && _1.name == name }
     end
 
     # Create or update a `YARD` tag with type information
@@ -31,7 +33,7 @@ module YARDSorbet
         return unless types
 
         # Updating a tag in place doesn't seem to work, so we'll delete it, add the types, and re-add it
-        docstring.delete_tag_if { |t| t == tag }
+        docstring.delete_tag_if { _1 == tag }
         # overwrite any existing type annotation (sigs should win)
         tag.types = types
         tag.text = text unless text.empty?

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.6.1'
+  VERSION = '0.8.0'
 end

metadata

@@ -1,43 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: yard-sorbet
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.8.0
 platform: ruby
 authors:
 - Douglas Eichelberger
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-11-01 00:00:00.000000000 Z
+date: 2023-01-14 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'
+        version: 0.9.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.9.1
 - !ruby/object:Gem::Dependency
   name: codecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.6.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.6.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -86,28 +86,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.22.0
+        version: 1.42.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.22.0
+        version: 1.42.0
 - !ruby/object:Gem::Dependency
   name: rubocop-performance
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.12.0
+        version: 1.15.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.12.0
+        version: 1.15.0
 - !ruby/object:Gem::Dependency
   name: rubocop-rake
   requirement: !ruby/object:Gem::Requirement
@@ -128,14 +128,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.5.0
+        version: 2.16.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.5.0
+        version: 2.16.0
 - !ruby/object:Gem::Dependency
   name: rubocop-sorbet
   requirement: !ruby/object:Gem::Requirement
@@ -151,33 +151,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 0.6.0
 - !ruby/object:Gem::Dependency
-  name: simplecov
+  name: sorbet
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.5.9204
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.5.9204
 - !ruby/object:Gem::Dependency
-  name: sorbet
+  name: tapioca
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.5.9204
+        version: 0.10.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.5.9204
+        version: 0.10.0
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime
   requirement: !ruby/object:Gem::Requirement
@@ -206,9 +206,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0.9'
-description: 'A YARD plugin that incorporates Sorbet type information
-
-  '
+description: A YARD plugin that incorporates Sorbet type information
 email: dduugg@gmail.com
 executables: []
 extensions: []
@@ -239,6 +237,7 @@ metadata:
   changelog_uri: https://github.com/dduugg/yard-sorbet/blob/main/CHANGELOG.md
   documentation_uri: https://dduugg.github.io/yard-sorbet/
   homepage_uri: https://github.com/dduugg/yard-sorbet
+  rubygems_mfa_required: 'true'
   source_code_uri: https://github.com/dduugg/yard-sorbet
   wiki_uri: https://github.com/dduugg/yard-sorbet/wiki
 post_install_message:
@@ -249,14 +248,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.5.0
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.22
+rubygems_version: 3.2.33
 signing_key:
 specification_version: 4
 summary: Create YARD docs from Sorbet type signatures