rbi 0.0.8 → 0.0.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 37be6daaf86810c60a865b98ac94ff089184e990e168bc405a0d167c641477ed
-  data.tar.gz: 95de3a3ffb035c40d9dd8da3055d808b1b0ae365add26bbc0754ae997c1c09c9
+  metadata.gz: ff552cac7ef282e9673502662c239c6e60e370d4d9e6d137db16ed03bd3c5a32
+  data.tar.gz: 6ca736d5854621dde27bafffd8ad4b393d2c60d5f7b9e4eba8ab938e7f9123f4
 SHA512:
-  metadata.gz: 3b794985ed143c257080ed69ab6ac8458e0cfcad5e988bfe412566dd2146ea009a8ceabfb274759089e3a687eb42e15b27c31a884c04e78a6b413b424d97d0b1
-  data.tar.gz: bc41f792fd147ceb04dee6852e046a68e5f90f886ce4b2937ceaa642ef4d9d46996f1560067177acfedc52b73b60878aeb03cd64deda17be516d04516e37ed63
+  metadata.gz: 9540175cf17bd99421f4c0e2d81dae2a6b79a0ba3528409c1aeb0fbc4923eb01b2b9a5d6d28a17c1b7d0ac4a4b06f10775ecabc460f54ad39fa5099256554730
+  data.tar.gz: 75a8657c94d508c5b53793be7b53fe6570850c6088cd67fc75c85b5d42555824b248d6f2c7a62527e8e50555276eb4e32ba33bb406c948d66a1f0a11f7f16014

data/lib/rbi/formatter.rb

@@ -0,0 +1,66 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RBI
+  class Formatter
+    extend T::Sig
+
+    sig { returns(T::Boolean) }
+    attr_accessor :add_sig_templates, :group_nodes, :nest_singleton_methods, :nest_non_public_methods, :sort_nodes
+
+    sig { returns(T.nilable(Integer)) }
+    attr_accessor :max_line_length
+
+    sig do
+      params(
+        add_sig_templates: T::Boolean,
+        group_nodes: T::Boolean,
+        max_line_length: T.nilable(Integer),
+        nest_singleton_methods: T::Boolean,
+        nest_non_public_methods: T::Boolean,
+        sort_nodes: T::Boolean
+      ).void
+    end
+    def initialize(
+      add_sig_templates: false,
+      group_nodes: false,
+      max_line_length: nil,
+      nest_singleton_methods: false,
+      nest_non_public_methods: false,
+      sort_nodes: false
+    )
+      @add_sig_templates = add_sig_templates
+      @group_nodes = group_nodes
+      @max_line_length = max_line_length
+      @nest_singleton_methods = nest_singleton_methods
+      @nest_non_public_methods = nest_non_public_methods
+      @sort_nodes = sort_nodes
+    end
+
+    sig { params(file: RBI::File).returns(String) }
+    def print_file(file)
+      format_file(file)
+      file.string(max_line_length: @max_line_length)
+    end
+
+    sig { params(tree: RBI::Tree).returns(String) }
+    def print_tree(tree)
+      format_tree(tree)
+      tree.string(max_line_length: @max_line_length)
+    end
+
+    sig { params(file: RBI::File).void }
+    def format_file(file)
+      format_tree(file.root)
+    end
+
+    sig { params(tree: RBI::Tree).void }
+    def format_tree(tree)
+      tree.add_sig_templates! if @add_sig_templates
+      tree.nest_singleton_methods! if @nest_singleton_methods
+      tree.nest_non_public_methods! if @nest_non_public_methods
+      tree.group_nodes! if @group_nodes
+      tree.sort_nodes! if @sort_nodes
+    end
+  end
+end

data/lib/rbi/index.rb

@@ -151,6 +151,16 @@ module RBI
     end
   end
 
+  class RequiresAncestor
+    extend T::Sig
+    include Indexable
+
+    sig { override.returns(T::Array[String]) }
+    def index_ids
+      [to_s]
+    end
+  end
+
   class Helper
     extend T::Sig
     include Indexable

data/lib/rbi/model.rb

@@ -1026,7 +1026,7 @@ module RBI
     attr_accessor :return_type
 
     sig { returns(T::Boolean) }
-    attr_accessor :is_abstract, :is_override, :is_overridable
+    attr_accessor :is_abstract, :is_override, :is_overridable, :is_final
 
     sig { returns(T::Array[String]) }
     attr_reader :type_params
@@ -1041,6 +1041,7 @@ module RBI
         is_abstract: T::Boolean,
         is_override: T::Boolean,
         is_overridable: T::Boolean,
+        is_final: T::Boolean,
         type_params: T::Array[String],
         checked: T.nilable(Symbol),
         loc: T.nilable(Loc),
@@ -1053,6 +1054,7 @@ module RBI
       is_abstract: false,
       is_override: false,
       is_overridable: false,
+      is_final: false,
       type_params: [],
       checked: nil,
       loc: nil,
@@ -1064,6 +1066,7 @@ module RBI
       @is_abstract = is_abstract
       @is_override = is_override
       @is_overridable = is_overridable
+      @is_final = is_final
       @type_params = type_params
       @checked = checked
       block&.call(self)
@@ -1078,7 +1081,7 @@ module RBI
     def ==(other)
       return false unless other.is_a?(Sig)
       params == other.params && return_type == other.return_type && is_abstract == other.is_abstract &&
-        is_override == other.is_override && is_overridable == other.is_overridable &&
+        is_override == other.is_override && is_overridable == other.is_overridable && is_final == other.is_final &&
         type_params == other.type_params && checked == other.checked
     end
   end
@@ -1361,4 +1364,28 @@ module RBI
       "#{parent_scope&.fully_qualified_name}.mixes_in_class_methods(#{names.join(", ")})"
     end
   end
+
+  class RequiresAncestor < NodeWithComments
+    extend T::Sig
+
+    sig { returns(String) }
+    attr_reader :name
+
+    sig do
+      params(
+        name: String,
+        loc: T.nilable(Loc),
+        comments: T::Array[Comment]
+      ).void
+    end
+    def initialize(name, loc: nil, comments: [])
+      super(loc: loc, comments: comments)
+      @name = name
+    end
+
+    sig { override.returns(String) }
+    def to_s
+      "#{parent_scope&.fully_qualified_name}.requires_ancestor(#{name})"
+    end
+  end
 end

data/lib/rbi/parser.rb

@@ -278,10 +278,10 @@ module RBI
         symbols = node.children[2..-1].map { |child| child.children[0] }
         AttrAccessor.new(*symbols, sigs: current_sigs, loc: loc, comments: comments)
       when :include
-        names = node.children[2..-1].map { |child| parse_name(child) }
+        names = node.children[2..-1].map { |child| parse_expr(child) }
         Include.new(*names, loc: loc, comments: comments)
       when :extend
-        names = node.children[2..-1].map { |child| parse_name(child) }
+        names = node.children[2..-1].map { |child| parse_expr(child) }
         Extend.new(*names, loc: loc, comments: comments)
       when :abstract!, :sealed!, :interface!
         Helper.new(method_name.to_s.delete_suffix("!"), loc: loc, comments: comments)
@@ -289,7 +289,14 @@ module RBI
         names = node.children[2..-1].map { |child| parse_name(child) }
         MixesInClassMethods.new(*names, loc: loc, comments: comments)
       when :public, :protected, :private
-        visibility = Visibility.new(method_name, loc: loc)
+        visibility = case method_name
+        when :protected
+          Protected.new(loc: loc)
+        when :private
+          Private.new(loc: loc)
+        else
+          Public.new(loc: loc)
+        end
         nested_node = node.children[2]
         case nested_node&.type
         when :def, :defs
@@ -344,6 +351,8 @@ module RBI
         parse_sig(node)
       when :enums
         parse_enum(node)
+      when :requires_ancestor
+        parse_requires_ancestor(node)
       else
         raise ParseError.new("Unsupported block node type `#{name}`", node_loc(node))
       end
@@ -427,6 +436,14 @@ module RBI
       enum
     end
 
+    sig { params(node: AST::Node).returns(RequiresAncestor) }
+    def parse_requires_ancestor(node)
+      name = parse_name(node.children[2])
+      ra = RequiresAncestor.new(name)
+      ra.loc = node_loc(node)
+      ra
+    end
+
     sig { params(node: AST::Node).returns(Loc) }
     def node_loc(node)
       Loc.from_ast_loc(@file, node.location)
@@ -551,7 +568,7 @@ module RBI
     sig { params(node: AST::Node).returns(Sig) }
     def self.build(node)
       v = SigBuilder.new
-      v.visit_all(node.children[2..-1])
+      v.visit_all(node.children)
       v.current
     end
 
@@ -578,6 +595,9 @@ module RBI
       visit(node.children[0]) if node.children[0]
       name = node.children[1]
       case name
+      when :sig
+        arg = node.children[2]
+        @current.is_final = arg && arg.children[0] == :final
       when :abstract
         @current.is_abstract = true
       when :override

data/lib/rbi/printer.rb

@@ -11,14 +11,28 @@ module RBI
     sig { returns(T.nilable(Node)) }
     attr_reader :previous_node
 
-    sig { params(out: T.any(IO, StringIO), indent: Integer, print_locs: T::Boolean).void }
-    def initialize(out: $stdout, indent: 0, print_locs: false)
+    sig { returns(Integer) }
+    attr_reader :current_indent
+
+    sig { returns(T.nilable(Integer)) }
+    attr_reader :max_line_length
+
+    sig do
+      params(
+        out: T.any(IO, StringIO),
+        indent: Integer,
+        print_locs: T::Boolean,
+        max_line_length: T.nilable(Integer)
+      ).void
+    end
+    def initialize(out: $stdout, indent: 0, print_locs: false, max_line_length: nil)
       super()
       @out = out
       @current_indent = indent
       @print_locs = print_locs
       @in_visibility_group = T.let(false, T::Boolean)
       @previous_node = T.let(nil, T.nilable(Node))
+      @max_line_length = max_line_length
     end
 
     # Printing
@@ -103,16 +117,23 @@ module RBI
       end
     end
 
-    sig { params(out: T.any(IO, StringIO), indent: Integer, print_locs: T::Boolean).void }
-    def print(out: $stdout, indent: 0, print_locs: false)
-      p = Printer.new(out: out, indent: indent, print_locs: print_locs)
+    sig do
+      params(
+        out: T.any(IO, StringIO),
+        indent: Integer,
+        print_locs: T::Boolean,
+        max_line_length: T.nilable(Integer)
+      ).void
+    end
+    def print(out: $stdout, indent: 0, print_locs: false, max_line_length: nil)
+      p = Printer.new(out: out, indent: indent, print_locs: print_locs, max_line_length: max_line_length)
       p.visit_file(self)
     end
 
-    sig { params(indent: Integer, print_locs: T::Boolean).returns(String) }
-    def string(indent: 0, print_locs: false)
+    sig { params(indent: Integer, print_locs: T::Boolean, max_line_length: T.nilable(Integer)).returns(String) }
+    def string(indent: 0, print_locs: false, max_line_length: nil)
       out = StringIO.new
-      print(out: out, indent: indent, print_locs: print_locs)
+      print(out: out, indent: indent, print_locs: print_locs, max_line_length: max_line_length)
       out.string
     end
   end
@@ -123,16 +144,23 @@ module RBI
     sig { abstract.params(v: Printer).void }
     def accept_printer(v); end
 
-    sig { params(out: T.any(IO, StringIO), indent: Integer, print_locs: T::Boolean).void }
-    def print(out: $stdout, indent: 0, print_locs: false)
-      p = Printer.new(out: out, indent: indent, print_locs: print_locs)
+    sig do
+      params(
+        out: T.any(IO, StringIO),
+        indent: Integer,
+        print_locs: T::Boolean,
+        max_line_length: T.nilable(Integer)
+      ).void
+    end
+    def print(out: $stdout, indent: 0, print_locs: false, max_line_length: nil)
+      p = Printer.new(out: out, indent: indent, print_locs: print_locs, max_line_length: max_line_length)
       p.visit(self)
     end
 
-    sig { params(indent: Integer, print_locs: T::Boolean).returns(String) }
-    def string(indent: 0, print_locs: false)
+    sig { params(indent: Integer, print_locs: T::Boolean, max_line_length: T.nilable(Integer)).returns(String) }
+    def string(indent: 0, print_locs: false, max_line_length: nil)
       out = StringIO.new
-      print(out: out, indent: indent, print_locs: print_locs)
+      print(out: out, indent: indent, print_locs: print_locs, max_line_length: max_line_length)
       out.string
     end
 
@@ -172,7 +200,7 @@ module RBI
       end
 
       lines.each do |line|
-        text = line.strip
+        text = line.rstrip
         v.printt("#")
         v.print(" #{text}") unless text.empty?
         v.printn
@@ -427,7 +455,7 @@ module RBI
 
     sig { returns(T::Array[String]) }
     def comments_lines
-      comments.flat_map { |comment| comment.text.lines.map(&:strip) }
+      comments.flat_map { |comment| comment.text.lines.map(&:rstrip) }
     end
   end
 
@@ -602,66 +630,18 @@ module RBI
     sig { override.params(v: Printer).void }
     def accept_printer(v)
       v.printl("# #{loc}") if loc && v.print_locs
-      if oneline?
-        v.printt("sig { ")
-      else
-        v.printl("sig do")
-        v.indent
-      end
-      v.print("abstract.") if is_abstract
-      v.print("override.") if is_override
-      v.print("overridable.") if is_overridable
-      unless type_params.empty?
-        v.print("type_parameters(")
-        type_params.each_with_index do |param, index|
-          v.print(":#{param}")
-          v.print(", ") if index < type_params.length - 1
-        end
-        v.print(").")
-      end
-      unless params.empty?
-        if inline_params?
-          v.print("params(")
-          params.each_with_index do |param, index|
-            v.print(", ") if index > 0
-            v.visit(param)
-          end
-          v.print(").")
+      max_line_length = v.max_line_length
+      if oneline? && max_line_length.nil?
+        print_as_line(v)
+      elsif max_line_length
+        line = string(indent: v.current_indent)
+        if line.length <= max_line_length
+          v.print(line)
         else
-          v.printl("params(")
-          v.indent
-          params.each_with_index do |param, pindex|
-            v.printt
-            v.visit(param)
-            v.print(",") if pindex < params.size - 1
-            param.comments_lines.each_with_index do |comment, cindex|
-              if cindex == 0
-                v.print(" ")
-              else
-                param.print_comment_leading_space(v, last: pindex == params.size - 1)
-              end
-              v.print("# #{comment}")
-            end
-            v.printn
-          end
-          v.dedent
-          v.printt(").")
+          print_as_block(v)
         end
-      end
-      if return_type && return_type != "void"
-        v.print("returns(#{return_type})")
       else
-        v.print("void")
-      end
-      if checked
-        v.print(".checked(:#{checked})")
-      end
-      if oneline?
-        v.printn(" }")
-      else
-        v.printn
-        v.dedent
-        v.printl("end")
+        print_as_block(v)
       end
     end
 
@@ -674,6 +654,92 @@ module RBI
     def inline_params?
       params.all? { |p| p.comments.empty? }
     end
+
+    private
+
+    sig { returns(T::Array[String]) }
+    def sig_modifiers
+      modifiers = T.let([], T::Array[String])
+      modifiers << "abstract" if is_abstract
+      modifiers << "override" if is_override
+      modifiers << "overridable" if is_overridable
+      modifiers << "type_parameters(#{type_params.map { |type| ":#{type}" }.join(", ")})" if type_params.any?
+      modifiers << "checked(:#{checked})" if checked
+      modifiers
+    end
+
+    sig { params(v: Printer).void }
+    def print_as_line(v)
+      v.printt("sig")
+      v.print("(:final)") if is_final
+      v.print(" { ")
+      sig_modifiers.each do |modifier|
+        v.print("#{modifier}.")
+      end
+      unless params.empty?
+        v.print("params(")
+        params.each_with_index do |param, index|
+          v.print(", ") if index > 0
+          v.visit(param)
+        end
+        v.print(").")
+      end
+      if return_type && return_type != "void"
+        v.print("returns(#{return_type})")
+      else
+        v.print("void")
+      end
+      v.printn(" }")
+    end
+
+    sig { params(v: Printer).void }
+    def print_as_block(v)
+      modifiers = sig_modifiers
+
+      v.printl("sig do")
+      v.indent
+      if modifiers.any?
+        v.printl(T.must(modifiers.first))
+        v.indent
+        modifiers[1..]&.each do |modifier|
+          v.printl(".#{modifier}")
+        end
+      end
+
+      if params.any?
+        v.printt
+        v.print(".") if modifiers.any?
+        v.printn("params(")
+        v.indent
+        params.each_with_index do |param, pindex|
+          v.printt
+          v.visit(param)
+          v.print(",") if pindex < params.size - 1
+          param.comments_lines.each_with_index do |comment, cindex|
+            if cindex == 0
+              v.print(" ")
+            else
+              param.print_comment_leading_space(v, last: pindex == params.size - 1)
+            end
+            v.print("# #{comment}")
+          end
+          v.printn
+        end
+        v.dedent
+        v.printt(")")
+      end
+      v.printt if params.empty?
+      v.print(".") if modifiers.any? || params.any?
+      if return_type && return_type != "void"
+        v.print("returns(#{return_type})")
+      else
+        v.print("void")
+      end
+      v.printn
+      v.dedent
+      v.dedent if modifiers.any?
+      v.printl("end")
+    end
   end
 
   class SigParam
@@ -694,7 +760,7 @@ module RBI
 
     sig { returns(T::Array[String]) }
     def comments_lines
-      comments.flat_map { |comment| comment.text.lines.map(&:strip) }
+      comments.flat_map { |comment| comment.text.lines.map(&:rstrip) }
     end
   end
 
@@ -794,4 +860,17 @@ module RBI
       false
     end
   end
+
+  class RequiresAncestor
+    extend T::Sig
+
+    sig { override.params(v: Printer).void }
+    def accept_printer(v)
+      print_blank_line_before(v)
+
+      v.printl("# #{loc}") if loc && v.print_locs
+      v.visit_all(comments)
+      v.printl("requires_ancestor { #{name} }")
+    end
+  end
 end

data/lib/rbi/rewriters/group_nodes.rb

@@ -47,8 +47,12 @@ module RBI
     sig { returns(Group::Kind) }
     def group_kind
       case self
+      when Group
+        kind
       when Include, Extend
         Group::Kind::Mixins
+      when RequiresAncestor
+        Group::Kind::RequiredAncestors
       when Helper
         Group::Kind::Helpers
       when TypeMember
@@ -57,6 +61,8 @@ module RBI
         Group::Kind::MixesInClassMethods
       when Send
         Group::Kind::Sends
+      when Attr
+        Group::Kind::Attrs
       when TStructField
         Group::Kind::TStructFields
       when TEnumBlock
@@ -94,10 +100,12 @@ module RBI
     class Kind < T::Enum
       enums do
         Mixins              = new
+        RequiredAncestors   = new
         Helpers             = new
         TypeMembers         = new
         MixesInClassMethods = new
         Sends               = new
+        Attrs               = new
         TStructFields       = new
         TEnums              = new
         Inits               = new

data/lib/rbi/rewriters/remove_known_definitions.rb

@@ -50,9 +50,9 @@ module RBI
 
       sig do
         params(
-          tree: RBI::Tree,
-          index: RBI::Index
-        ).returns([RBI::Tree, T::Array[Operation]])
+          tree: Tree,
+          index: Index
+        ).returns([Tree, T::Array[Operation]])
       end
       def self.remove(tree, index)
         v = RemoveKnownDefinitions.new(index)
@@ -63,38 +63,38 @@ module RBI
       sig { returns(T::Array[Operation]) }
       attr_reader :operations
 
-      sig { params(index: RBI::Index).void }
+      sig { params(index: Index).void }
       def initialize(index)
         super()
         @index = index
         @operations = T.let([], T::Array[Operation])
       end
 
-      sig { params(nodes: T::Array[RBI::Node]).void }
+      sig { params(nodes: T::Array[Node]).void }
       def visit_all(nodes)
         nodes.dup.each { |node| visit(node) }
       end
 
-      sig { override.params(node: T.nilable(RBI::Node)).void }
+      sig { override.params(node: T.nilable(Node)).void }
       def visit(node)
         return unless node
 
         case node
-        when RBI::Scope
+        when Scope
           visit_all(node.nodes)
           previous = previous_definition_for(node)
-          delete_node(node, previous) if previous && node.empty?
-        when RBI::Tree
+          delete_node(node, previous) if previous && can_delete_node?(node, previous)
+        when Tree
           visit_all(node.nodes)
-        when RBI::Indexable
+        when Indexable
           previous = previous_definition_for(node)
-          delete_node(node, previous) if previous
+          delete_node(node, previous) if previous && can_delete_node?(node, previous)
         end
       end
 
       private
 
-      sig { params(node: RBI::Indexable).returns(T.nilable(RBI::Node)) }
+      sig { params(node: Indexable).returns(T.nilable(Node)) }
       def previous_definition_for(node)
         node.index_ids.each do |id|
           previous = @index[id].first
@@ -103,7 +103,25 @@ module RBI
         nil
       end
 
-      sig { params(node: RBI::Node, previous: RBI::Node).void }
+      sig { params(node: Node, previous: Node).returns(T::Boolean) }
+      def can_delete_node?(node, previous)
+        return false unless node.class == previous.class
+
+        case node
+        when Scope
+          node.empty?
+        when Attr
+          previous = T.cast(previous, Attr)
+          node.names == previous.names && node.sigs == previous.sigs
+        when Method
+          previous = T.cast(previous, Method)
+          node.params == previous.params && node.sigs == previous.sigs
+        else
+          true
+        end
+      end
+
+      sig { params(node: Node, previous: Node).void }
       def delete_node(node, previous)
         node.detach
         @operations << Operation.new(deleted_node: node, duplicate_of: previous)
@@ -112,8 +130,8 @@ module RBI
       class Operation < T::Struct
         extend T::Sig
 
-        const :deleted_node, RBI::Node
-        const :duplicate_of, RBI::Node
+        const :deleted_node, Node
+        const :duplicate_of, Node
 
         sig { returns(String) }
         def to_s

data/lib/rbi/rewriters/sort_nodes.rb

@@ -8,6 +8,8 @@ module RBI
 
       sig { override.params(node: T.nilable(Node)).void }
       def visit(node)
+        sort_node_names!(node) if node
+
         return unless node.is_a?(Tree)
         visit_all(node.nodes)
         original_order = node.nodes.map.with_index.to_h
@@ -32,12 +34,14 @@ module RBI
         case node
         when Group                then group_rank(node.kind)
         when Include, Extend      then 10
+        when RequiresAncestor     then 15
         when Helper               then 20
         when TypeMember           then 30
         when MixesInClassMethods  then 40
         when Send                 then 50
         when TStructField         then 60
         when TEnumBlock           then 70
+        when Attr                 then 75
         when Method
           if node.name == "initialize"
             81
@@ -57,16 +61,18 @@ module RBI
       def group_rank(kind)
         case kind
         when Group::Kind::Mixins              then 0
-        when Group::Kind::Helpers             then 1
-        when Group::Kind::TypeMembers         then 2
-        when Group::Kind::MixesInClassMethods then 3
+        when Group::Kind::RequiredAncestors   then 1
+        when Group::Kind::Helpers             then 2
+        when Group::Kind::TypeMembers         then 3
+        when Group::Kind::MixesInClassMethods then 4
         when Group::Kind::Sends               then 5
         when Group::Kind::TStructFields       then 6
         when Group::Kind::TEnums              then 7
-        when Group::Kind::Inits               then 8
-        when Group::Kind::Methods             then 9
-        when Group::Kind::SingletonClasses    then 10
-        when Group::Kind::Consts              then 11
+        when Group::Kind::Attrs               then 8
+        when Group::Kind::Inits               then 9
+        when Group::Kind::Methods             then 10
+        when Group::Kind::SingletonClasses    then 11
+        when Group::Kind::Consts              then 12
         else
           T.absurd(kind)
         end
@@ -75,8 +81,18 @@ module RBI
       sig { params(node: Node).returns(T.nilable(String)) }
       def node_name(node)
         case node
-        when Module, Class, Struct, Const, Method, Helper, TStructField
+        when Module, Class, Struct, Const, Method, Helper, TStructField, RequiresAncestor
           node.name
+        when Attr
+          node.names.first.to_s
+        end
+      end
+
+      sig { params(node: Node).void }
+      def sort_node_names!(node)
+        case node
+        when Attr
+          node.names.sort!
         end
       end
     end

data/lib/rbi/version.rb

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

data/lib/rbi.rb

@@ -23,4 +23,5 @@ require "rbi/rewriters/remove_known_definitions"
 require "rbi/rewriters/sort_nodes"
 require "rbi/parser"
 require "rbi/printer"
+require "rbi/formatter"
 require "rbi/version"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rbi
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.0.12
 platform: ruby
 authors:
 - Alexandre Terrasa
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-11-24 00:00:00.000000000 Z
+date: 2022-02-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ast
@@ -77,6 +77,7 @@ files:
 - README.md
 - Rakefile
 - lib/rbi.rb
+- lib/rbi/formatter.rb
 - lib/rbi/index.rb
 - lib/rbi/loc.rb
 - lib/rbi/model.rb