rbi 0.2.1 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 68328047c11f18c7617e8101a773a3b3b9438be4e36a0b01072274eba2b1c583
-  data.tar.gz: 275b2ed35e5486461d2ebf4afae88d7b75b9f26ac1d7d8d9693ff630b17dff3d
+  metadata.gz: 7d7b27863b9b9ece5a4cc59fb638a2e51055cd2ca39416e311ea38e9929f124e
+  data.tar.gz: 24356f96be5c3381865496aab481214a0cfcbfa423b29eb728691b973a051a5e
 SHA512:
-  metadata.gz: 53e510f0df7f4e44c45686774f3573e06031ba7c81a29f7ff429b2dacb601c42a83be37acca12809161ef7acd50722682ad88483b12d4af8d536c6f709e540b8
-  data.tar.gz: 172bbba7e9c3cd29032d4d34a4fda47ce81728b971a8956d742b0d012ca393b3f555109493ec2ebfe1aa3087a142da109061fc07074f8a4b721096cf1884091d
+  metadata.gz: cd47ce37c3cd31e92d24172e08bb9c1a6a0416a3399bb39529788655f0b1138947cd35a9afb85cc0915c2e04989cdd9f1a04b8a2a511dfd64a1ca6ee82701edc
+  data.tar.gz: eddda9af791aef98efb957b0017376cdc058a96aff0b39c6716ee5e18809da21b12d4a5b79df1c34c923a0c34383286785de5e160934aff3a93289f756a6dac5

data/Gemfile

@@ -10,7 +10,7 @@ group(:development, :test) do
   gem("minitest")
   gem("minitest-reporters")
   gem("rake", "~> 13.2")
-  gem("rubocop", "~> 1.66", require: false)
+  gem("rubocop", "~> 1.69", require: false)
   gem("rubocop-shopify", require: false)
   gem("rubocop-sorbet", require: false)
   gem("sorbet", ">= 0.5.9204", require: false)

data/lib/rbi/formatter.rb

@@ -5,9 +5,6 @@ module RBI
   class Formatter
     extend T::Sig
 
-    sig { params(sort_nodes: T::Boolean).returns(T::Boolean) }
-    attr_writer :sort_nodes
-
     sig { returns(T.nilable(Integer)) }
     attr_accessor :max_line_length
 

data/lib/rbi/model.rb

@@ -581,7 +581,7 @@ module RBI
         is_final: T::Boolean,
         type_params: T::Array[String],
         checked: T.nilable(Symbol),
-        block: T.proc.params(node: Sig).void,
+        block: T.nilable(T.proc.params(node: Sig).void),
       ).void
     end
     def add_sig(
@@ -1111,7 +1111,7 @@ module RBI
     attr_accessor :return_type
 
     sig { returns(T::Boolean) }
-    attr_accessor :is_abstract, :is_override, :is_overridable, :is_final
+    attr_accessor :is_abstract, :is_override, :is_overridable, :is_final, :allow_incompatible_override
 
     sig { returns(T::Array[String]) }
     attr_reader :type_params
@@ -1127,6 +1127,7 @@ module RBI
         is_override: T::Boolean,
         is_overridable: T::Boolean,
         is_final: T::Boolean,
+        allow_incompatible_override: T::Boolean,
         type_params: T::Array[String],
         checked: T.nilable(Symbol),
         loc: T.nilable(Loc),
@@ -1141,6 +1142,7 @@ module RBI
       is_override: false,
       is_overridable: false,
       is_final: false,
+      allow_incompatible_override: false,
       type_params: [],
       checked: nil,
       loc: nil,
@@ -1154,6 +1156,7 @@ module RBI
       @is_override = is_override
       @is_overridable = is_overridable
       @is_final = is_final
+      @allow_incompatible_override = allow_incompatible_override
       @type_params = type_params
       @checked = checked
       block&.call(self)

data/lib/rbi/parser.rb

@@ -858,6 +858,22 @@ module RBI
           end
         when "override"
           @current.is_override = true
+
+          args = node.arguments&.arguments
+
+          keywords_hash = args
+            &.grep(Prism::KeywordHashNode)
+            &.first
+
+          allow_incompatible_override = keywords_hash
+            &.elements
+            &.any? do |assoc|
+              assoc.is_a?(Prism::AssocNode) &&
+                node_string(assoc.key) == "allow_incompatible:" &&
+                node_string(assoc.value) == "true"
+            end
+
+          @current.allow_incompatible_override = !!allow_incompatible_override
         when "overridable"
           @current.is_overridable = true
         when "params"

data/lib/rbi/printer.rb

@@ -721,7 +721,15 @@ module RBI
     def sig_modifiers(node)
       modifiers = T.let([], T::Array[String])
       modifiers << "abstract" if node.is_abstract
-      modifiers << "override" if node.is_override
+
+      if node.is_override
+        modifiers << if node.allow_incompatible_override
+          "override(allow_incompatible: true)"
+        else
+          "override"
+        end
+      end
+
       modifiers << "overridable" if node.is_overridable
       modifiers << "type_parameters(#{node.type_params.map { |type| ":#{type}" }.join(", ")})" if node.type_params.any?
       modifiers << "checked(:#{node.checked})" if node.checked

data/lib/rbi/rbs_printer.rb

@@ -273,19 +273,24 @@ module RBI
 
     sig { params(node: RBI::Attr, sig: Sig).void }
     def print_attr_sig(node, sig)
+      ret_type = sig.return_type
+
       type = case node
-      when AttrAccessor, AttrReader
-        parse_type(sig.return_type)
+      when AttrReader, AttrAccessor
+        parse_type(ret_type).rbs_string
       else
-        first_arg = sig.params.first
-        if first_arg
-          parse_type(first_arg.type)
+        # For attr_writer, Sorbet will prioritize the return type over the argument type in case of mismatch
+        arg_type = sig.params.first
+        if arg_type && (ret_type.is_a?(Type::Void) || ret_type == "void")
+          # If we have an argument type and the return type is void, we prioritize the argument type
+          parse_type(arg_type.type).rbs_string
         else
-          Type.untyped
+          # Otherwise, we prioritize the return type
+          parse_type(ret_type).rbs_string
         end
       end
 
-      print(type.rbs_string)
+      print(type)
     end
 
     sig { override.params(node: Method).void }
@@ -298,13 +303,21 @@ module RBI
       end
 
       if node.sigs.any?(&:is_override)
-        printl("# @override")
+        if node.sigs.any?(&:allow_incompatible_override)
+          printl("# @override(allow_incompatible: true)")
+        else
+          printl("# @override")
+        end
       end
 
       if node.sigs.any?(&:is_overridable)
         printl("# @overridable")
       end
 
+      if node.sigs.any?(&:is_final)
+        printl("# @final")
+      end
+
       print_loc(node)
       printt
       unless in_visibility_group || node.visibility.public?
@@ -349,7 +362,7 @@ module RBI
     sig { params(node: RBI::Method, sig: Sig).void }
     def print_method_sig(node, sig)
       unless sig.type_params.empty?
-        print("[#{sig.type_params.map { |t| "TYPE_#{t}" }.join(", ")}] ")
+        print("[#{sig.type_params.join(", ")}] ")
       end
 
       block_param = node.params.find { |param| param.is_a?(BlockParam) }
@@ -388,9 +401,7 @@ module RBI
           type_string = "(?) -> untyped"
           block_is_nilable = true
         when Type::Simple
-          if block_type.name == "Proc"
-            type_string = "(?) -> untyped"
-          end
+          type_string = "(?) -> untyped"
           skip = true if block_type.name == "NilClass"
         end
 
@@ -410,6 +421,24 @@ module RBI
       print(" # #{loc}") if loc && print_locs
     end
 
+    sig { params(node: Sig).void }
+    def visit_sig(node)
+      if node.params
+        print("(")
+        node.params.each do |param|
+          visit(param)
+        end
+        print(") ")
+      end
+
+      print("-> #{parse_type(node.return_type).rbs_string}")
+    end
+
+    sig { params(node: SigParam).void }
+    def visit_sig_param(node)
+      print(parse_type(node.type).rbs_string)
+    end
+
     sig { override.params(node: ReqParam).void }
     def visit_req_param(node)
       print("untyped #{node.name}")
@@ -770,17 +799,10 @@ module RBI
       return unless node.name == :let
       return unless node.receiver&.slice =~ /^(::)?T$/
 
-      node.arguments&.arguments&.fetch(1, nil)&.slice
-    end
-
-    sig { params(node: Type).returns(T::Boolean) }
-    def bare_proc?(node)
-      node.is_a?(Type::Simple) && node.name == "Proc"
-    end
+      arguments = node.arguments&.arguments
+      return unless arguments
 
-    sig { params(node: Type).returns(T::Boolean) }
-    def bare_nilable_proc?(node)
-      node.is_a?(Type::Nilable) && bare_proc?(node.type)
+      arguments.fetch(1, nil)&.slice
     end
   end
 
@@ -841,7 +863,7 @@ module RBI
 
     sig { params(type: Type::Simple).void }
     def visit_simple(type)
-      @string << translate_t_type(type.name)
+      @string << translate_t_type(type.name.gsub(/\s/, ""))
     end
 
     sig { params(type: Type::Boolean).void }
@@ -851,7 +873,7 @@ module RBI
 
     sig { params(type: Type::Generic).void }
     def visit_generic(type)
-      @string << translate_t_type(type.name)
+      @string << translate_t_type(type.name.gsub(/\s/, ""))
       @string << "["
       type.params.each_with_index do |arg, index|
         visit(arg)
@@ -887,12 +909,19 @@ module RBI
 
     sig { params(type: Type::AttachedClass).void }
     def visit_attached_class(type)
-      @string << "attached_class"
+      @string << "instance"
     end
 
     sig { params(type: Type::Nilable).void }
     def visit_nilable(type)
-      visit(type.type)
+      inner = type.type
+      if inner.is_a?(Type::Proc)
+        @string << "("
+      end
+      visit(inner)
+      if inner.is_a?(Type::Proc)
+        @string << ")"
+      end
       @string << "?"
     end
 
@@ -937,7 +966,16 @@ module RBI
     def visit_shape(type)
       @string << "{"
       type.types.each_with_index do |(key, value), index|
-        @string << "#{key}: "
+        @string << case key
+        when String
+          "\"#{key}\" => "
+        when Symbol
+          if key.match?(/\A[a-zA-Z_]+[a-zA-Z0-9_]*\z/)
+            "#{key}: "
+          else
+            "\"#{key}\": "
+          end
+        end
         visit(value)
         @string << ", " if index < type.types.size - 1
       end
@@ -956,20 +994,26 @@ module RBI
         end
         @string << ") "
       end
+      proc_bind = type.proc_bind
+      if proc_bind
+        @string << "[self: "
+        visit(proc_bind)
+        @string << "] "
+      end
       @string << "-> "
       visit(type.proc_returns)
     end
 
     sig { params(type: Type::TypeParameter).void }
     def visit_type_parameter(type)
-      @string << "TYPE_#{type.name}"
+      @string << type.name.to_s
     end
 
     sig { params(type: Type::Class).void }
     def visit_class(type)
-      @string << "singleton("
+      @string << "Class["
       visit(type.type)
-      @string << ")"
+      @string << "]"
     end
 
     private

data/lib/rbi/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module RBI
-  VERSION = "0.2.1"
+  VERSION = "0.2.3"
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: rbi
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.3
 platform: ruby
 authors:
 - Alexandre Terrasa
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-10-03 00:00:00.000000000 Z
+date: 2025-01-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: prism
@@ -38,7 +37,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.5.9204
-description:
 email:
 - ruby@shopify.com
 executables: []
@@ -80,7 +78,6 @@ licenses:
 - MIT
 metadata:
   allowed_push_host: https://rubygems.org
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -95,8 +92,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.20
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: RBI generation framework
 test_files: []