rbi 0.2.2 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4c651b1059238b331d30239d5f366dc771fa9e3a3cd5ae8341cd41afcd8f4fbd
-  data.tar.gz: 1c46c0ca74094a0a74fe6b5e8de3ab6ca23c1a4f441ca88eb2733a0b56c42031
+  metadata.gz: a8f99c70643c9f05b1b7dda28cb2091654c1865b124b01a981fc4a3b6f59275f
+  data.tar.gz: 9d0b4626b14eced346dd4899cce76996137a84047f4b10142e01d0c35655b450
 SHA512:
-  metadata.gz: 339001680272e363ee1bb55170bce1e1af78fbb70a718359a9a0b56db0c8c73210043fca56b6f65d4a45da6bafbbd10f7a6162fe03351a8f7b409781d752ccaf
-  data.tar.gz: 0e97a47c78aec83d044ceaa901b79e3ebdfd2219cfe787d7645faf070f83c317cd47239c41c424737ef5172cfb4ebfac96fb9a2939e863543290168e167243d3
+  metadata.gz: e02a6ffba6687475814388820be9ae352ec732fa288f2295af75959a0ad7b3032992fa6c17b4cb2b03cdcb26667c48b5038c7c4d04babe25be77e0404ff41880
+  data.tar.gz: 0dd7254c9b7ac5c204654bd71f1a26b6b8597e2c5b10a199c5e0ab40224d5444d38eaf4c1e1c4a2acb9c75e482464ef55b7419216dc2f02556d8c8b2317e0f84

data/Gemfile

@@ -10,7 +10,7 @@ group(:development, :test) do
   gem("minitest")
   gem("minitest-reporters")
   gem("rake", "~> 13.2")
-  gem("rubocop", "~> 1.69", require: false)
+  gem("rubocop", "~> 1.70", 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

@@ -261,7 +261,7 @@ module RBI
       ).void
     end
     def initialize(loc: nil, comments: [], &block)
-      super(loc: loc, comments: comments) {}
+      super {}
       block&.call(self)
     end
 
@@ -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)
@@ -1354,7 +1357,7 @@ module RBI
       ).void
     end
     def initialize(loc: nil, comments: [], &block)
-      super(loc: loc, comments: comments) {}
+      super {}
       block&.call(self)
     end
 

data/lib/rbi/parser.rb

@@ -451,11 +451,6 @@ module RBI
                 loc: node_loc(node),
                 comments: node_comments(node),
               )
-            else
-              raise ParseError.new(
-                "Unexpected token `#{node.message}` before `#{last_node&.string&.strip}`",
-                node_loc(node),
-              )
             end
           else
             current_scope << parse_visibility(node.name.to_s, node)
@@ -722,8 +717,6 @@ module RBI
 
                 keyword_init = val == "true" if key == "keyword_init:"
               end
-            else
-              raise ParseError.new("Unexpected node type `#{arg.class}`", node_loc(arg))
             end
           end
         end
@@ -858,6 +851,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}")
@@ -834,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 }
@@ -844,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)
@@ -885,7 +914,14 @@ module RBI
 
     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
 
@@ -930,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
@@ -949,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.2"
+  VERSION = "0.2.4"
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: rbi
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.4
 platform: ruby
 authors:
 - Alexandre Terrasa
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-12-17 00:00:00.000000000 Z
+date: 2025-01-21 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.23
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: RBI generation framework
 test_files: []