rbi 0.0.2 → 0.0.6

data/lib/rbi/printer.rb

@@ -97,7 +97,7 @@ module RBI
         v.visit_all(comments)
       end
 
-      unless root.empty?
+      unless root.empty? && root.comments.empty?
         v.printn if strictness || !comments.empty?
         v.visit(root)
       end
@@ -156,9 +156,26 @@ module RBI
 
     sig { override.params(v: Printer).void }
     def accept_printer(v)
-      text = self.text.strip
-      v.printt("#")
-      v.print(" #{text}") unless text.empty?
+      lines = text.lines
+
+      if lines.empty?
+        v.printl("#")
+      end
+
+      lines.each do |line|
+        text = line.strip
+        v.printt("#")
+        v.print(" #{text}") unless text.empty?
+        v.printn
+      end
+    end
+  end
+
+  class EmptyComment
+    extend T::Sig
+
+    sig { override.params(v: Printer).void }
+    def accept_printer(v)
       v.printn
     end
   end
@@ -238,6 +255,27 @@ module RBI
     end
   end
 
+  class Struct
+    extend T::Sig
+
+    sig { override.params(v: Printer).void }
+    def print_header(v)
+      v.printt("#{name} = ::Struct.new")
+      if !members.empty? || keyword_init
+        v.print("(")
+        args = members.map { |member| ":#{member}" }
+        args << "keyword_init: true" if keyword_init
+        v.print(args.join(", "))
+        v.print(")")
+      end
+      if empty?
+        v.printn
+      else
+        v.printn(" do")
+      end
+    end
+  end
+
   class SingletonClass
     extend T::Sig
 
@@ -278,7 +316,7 @@ module RBI
       sigs.each { |sig| v.visit(sig) }
       v.printl("# #{loc}") if loc && v.print_locs
       v.printt
-      unless v.in_visibility_group || visibility == Visibility::Public
+      unless v.in_visibility_group || visibility.public?
         v.print(visibility.visibility.to_s)
         v.print(" ")
       end
@@ -315,7 +353,7 @@ module RBI
       v.visit_all(sigs)
       v.printl("# #{loc}") if loc && v.print_locs
       v.printt
-      unless v.in_visibility_group || visibility == Visibility::Public
+      unless v.in_visibility_group || visibility.public?
         v.print(visibility.visibility.to_s)
         v.print(" ")
       end
@@ -336,13 +374,14 @@ module RBI
             v.printt
             v.visit(param)
             v.print(",") if pindex < params.size - 1
-            param.comments.each_with_index do |comment, cindex|
+
+            param.comments_lines.each_with_index do |comment, cindex|
               if cindex > 0
-                param.print_comment_leading_space(v)
+                param.print_comment_leading_space(v, last: pindex == params.size - 1)
               else
                 v.print(" ")
               end
-              v.print("# #{comment.text.strip}")
+              v.print("# #{comment}")
             end
             v.printn
           end
@@ -373,11 +412,17 @@ module RBI
       v.print(name.to_s)
     end
 
-    sig { params(v: Printer).void }
-    def print_comment_leading_space(v)
+    sig { params(v: Printer, last: T::Boolean).void }
+    def print_comment_leading_space(v, last:)
       v.printn
       v.printt
-      v.print(" " * (name.size + 2))
+      v.print(" " * (name.size + 1))
+      v.print(" ") unless last
+    end
+
+    sig { returns(T::Array[String]) }
+    def comments_lines
+      comments.flat_map { |comment| comment.text.lines.map(&:strip) }
     end
   end
 
@@ -389,8 +434,8 @@ module RBI
       v.print("#{name} = #{value}")
     end
 
-    sig { override.params(v: Printer).void }
-    def print_comment_leading_space(v)
+    sig { override.params(v: Printer, last: T::Boolean).void }
+    def print_comment_leading_space(v, last:)
       super
       v.print(" " * (value.size + 3))
     end
@@ -404,8 +449,8 @@ module RBI
       v.print("*#{name}")
     end
 
-    sig { override.params(v: Printer).void }
-    def print_comment_leading_space(v)
+    sig { override.params(v: Printer, last: T::Boolean).void }
+    def print_comment_leading_space(v, last:)
       super
       v.print(" ")
     end
@@ -419,8 +464,8 @@ module RBI
       v.print("#{name}:")
     end
 
-    sig { override.params(v: Printer).void }
-    def print_comment_leading_space(v)
+    sig { override.params(v: Printer, last: T::Boolean).void }
+    def print_comment_leading_space(v, last:)
       super
       v.print(" ")
     end
@@ -434,11 +479,9 @@ module RBI
       v.print("#{name}: #{value}")
     end
 
-    sig { override.params(v: Printer).void }
-    def print_comment_leading_space(v)
-      v.printn
-      v.printt
-      v.print(" " * (name.size + 2))
+    sig { override.params(v: Printer, last: T::Boolean).void }
+    def print_comment_leading_space(v, last:)
+      super
       v.print(" " * (value.size + 2))
     end
   end
@@ -451,8 +494,8 @@ module RBI
       v.print("**#{name}")
     end
 
-    sig { override.params(v: Printer).void }
-    def print_comment_leading_space(v)
+    sig { override.params(v: Printer, last: T::Boolean).void }
+    def print_comment_leading_space(v, last:)
       super
       v.print("  ")
     end
@@ -465,6 +508,12 @@ module RBI
     def accept_printer(v)
       v.print("&#{name}")
     end
+
+    sig { override.params(v: Printer, last: T::Boolean).void }
+    def print_comment_leading_space(v, last:)
+      super
+      v.print(" ")
+    end
   end
 
   class Mixin
@@ -494,7 +543,11 @@ module RBI
 
     sig { override.params(v: Printer).void }
     def accept_printer(v)
+      previous_node = v.previous_node
+      v.printn if previous_node && (!previous_node.oneline? || !oneline?)
+
       v.printl("# #{loc}") if loc && v.print_locs
+      v.visit_all(comments)
       v.printl(visibility.to_s)
     end
   end
@@ -505,7 +558,12 @@ module RBI
     sig { override.params(v: Printer).void }
     def accept_printer(v)
       v.printl("# #{loc}") if loc && v.print_locs
-      v.printt("sig { ")
+      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
@@ -518,12 +576,33 @@ module RBI
         v.print(").")
       end
       unless params.empty?
-        v.print("params(")
-        params.each_with_index do |param, index|
-          v.visit(param)
-          v.print(", ") if index < params.length - 1
+        if inline_params?
+          v.print("params(")
+          params.each_with_index do |param, index|
+            v.print(", ") if index > 0
+            v.visit(param)
+          end
+          v.print(").")
+        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(").")
         end
-        v.print(").")
       end
       if return_type && return_type != "void"
         v.print("returns(#{return_type})")
@@ -533,7 +612,23 @@ module RBI
       if checked
         v.print(".checked(:#{checked})")
       end
-      v.printn(" }")
+      if oneline?
+        v.printn(" }")
+      else
+        v.printn
+        v.dedent
+        v.printl("end")
+      end
+    end
+
+    sig { override.returns(T::Boolean) }
+    def oneline?
+      inline_params?
+    end
+
+    sig { returns(T::Boolean) }
+    def inline_params?
+      params.all? { |p| p.comments.empty? }
     end
   end
 
@@ -544,6 +639,19 @@ module RBI
     def accept_printer(v)
       v.print("#{name}: #{type}")
     end
+
+    sig { params(v: Printer, last: T::Boolean).void }
+    def print_comment_leading_space(v, last:)
+      v.printn
+      v.printt
+      v.print(" " * (name.size + type.size + 3))
+      v.print(" ") unless last
+    end
+
+    sig { returns(T::Array[String]) }
+    def comments_lines
+      comments.flat_map { |comment| comment.text.lines.map(&:strip) }
+    end
   end
 
   class TStructField
@@ -630,14 +738,19 @@ module RBI
     sig { override.params(v: Printer).void }
     def accept_printer(v)
       v.in_visibility_group = true
-      v.printn unless v.previous_node.nil?
-      case visibility
-      when Visibility::Protected, Visibility::Private
+      if visibility.public?
+        v.printn unless v.previous_node.nil?
+      else
         v.visit(visibility)
         v.printn
       end
       v.visit_all(nodes)
       v.in_visibility_group = false
     end
+
+    sig { override.returns(T::Boolean) }
+    def oneline?
+      false
+    end
   end
 end

data/lib/rbi/rewriters/add_sig_templates.rb

@@ -0,0 +1,71 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RBI
+  module Rewriters
+    class AddSigTemplates < Visitor
+      extend T::Sig
+
+      sig { params(with_todo_comment: T::Boolean).void }
+      def initialize(with_todo_comment: true)
+        super()
+        @with_todo_comment = with_todo_comment
+      end
+
+      sig { override.params(node: T.nilable(Node)).void }
+      def visit(node)
+        case node
+        when Tree
+          visit_all(node.nodes)
+        when Attr
+          add_attr_sig(node)
+        when Method
+          add_method_sig(node)
+        end
+      end
+
+      private
+
+      sig { params(attr: Attr).void }
+      def add_attr_sig(attr)
+        return unless attr.sigs.empty?
+        return if attr.names.size > 1
+
+        params = []
+        params << SigParam.new(attr.names.first.to_s, "T.untyped") if attr.is_a?(AttrWriter)
+
+        attr.sigs << Sig.new(
+          params: params,
+          return_type: "T.untyped"
+        )
+        add_todo_comment(attr)
+      end
+
+      sig { params(method: Method).void }
+      def add_method_sig(method)
+        return unless method.sigs.empty?
+
+        method.sigs << Sig.new(
+          params: method.params.map { |param| SigParam.new(param.name, "T.untyped") },
+          return_type: "T.untyped"
+        )
+        add_todo_comment(method)
+      end
+
+      sig { params(node: NodeWithComments).void }
+      def add_todo_comment(node)
+        node.comments << Comment.new("TODO: fill in signature with appropriate type information") if @with_todo_comment
+      end
+    end
+  end
+
+  class Tree
+    extend T::Sig
+
+    sig { params(with_todo_comment: T::Boolean).void }
+    def add_sig_templates!(with_todo_comment: true)
+      visitor = Rewriters::AddSigTemplates.new(with_todo_comment: with_todo_comment)
+      visitor.visit(self)
+    end
+  end
+end

data/lib/rbi/rewriters/merge_trees.rb

@@ -39,9 +39,19 @@ module RBI
     class Merge
       extend T::Sig
 
-      sig { params(left: Tree, right: Tree, left_name: String, right_name: String).returns(Tree) }
-      def self.merge_trees(left, right, left_name: "left", right_name: "right")
-        rewriter = Rewriters::Merge.new(left_name: left_name, right_name: right_name)
+      class Keep < ::T::Enum
+        enums do
+          NONE = new
+          LEFT = new
+          RIGHT = new
+        end
+      end
+
+      sig { params(left: Tree, right: Tree, left_name: String, right_name: String, keep: Keep).returns(Tree) }
+      def self.merge_trees(left, right, left_name: "left", right_name: "right", keep: Keep::NONE)
+        left.nest_singleton_methods!
+        right.nest_singleton_methods!
+        rewriter = Rewriters::Merge.new(left_name: left_name, right_name: right_name, keep: keep)
         rewriter.merge(left)
         rewriter.merge(right)
         tree = rewriter.tree
@@ -52,17 +62,18 @@ module RBI
       sig { returns(Tree) }
       attr_reader :tree
 
-      sig { params(left_name: String, right_name: String).void }
-      def initialize(left_name: "left", right_name: "right")
+      sig { params(left_name: String, right_name: String, keep: Keep).void }
+      def initialize(left_name: "left", right_name: "right", keep: Keep::NONE)
         @left_name = left_name
         @right_name = right_name
+        @keep = keep
         @tree = T.let(Tree.new, Tree)
         @scope_stack = T.let([@tree], T::Array[Tree])
       end
 
       sig { params(tree: Tree).returns(T::Array[Conflict]) }
       def merge(tree)
-        v = TreeMerger.new(@tree, left_name: @left_name, right_name: @right_name)
+        v = TreeMerger.new(@tree, left_name: @left_name, right_name: @right_name, keep: @keep)
         v.visit(tree)
         v.conflicts
       end
@@ -88,14 +99,15 @@ module RBI
         sig { returns(T::Array[Conflict]) }
         attr_reader :conflicts
 
-        sig { params(output: Tree, left_name: String, right_name: String).void }
-        def initialize(output, left_name: "left", right_name: "right")
+        sig { params(output: Tree, left_name: String, right_name: String, keep: Keep).void }
+        def initialize(output, left_name: "left", right_name: "right", keep: Keep::NONE)
           super()
           @tree = output
           @index = T.let(output.index, Index)
           @scope_stack = T.let([@tree], T::Array[Tree])
           @left_name = left_name
           @right_name = right_name
+          @keep = keep
           @conflicts = T.let([], T::Array[Conflict])
         end
 
@@ -110,6 +122,10 @@ module RBI
             if prev.is_a?(Scope)
               if node.compatible_with?(prev)
                 prev.merge_with(node)
+              elsif @keep == Keep::LEFT
+                # do nothing it's already merged
+              elsif @keep == Keep::RIGHT
+                prev = replace_scope_header(prev, node)
               else
                 make_conflict_scope(prev, node)
               end
@@ -129,6 +145,10 @@ module RBI
             if prev
               if node.compatible_with?(prev)
                 prev.merge_with(node)
+              elsif @keep == Keep::LEFT
+                # do nothing it's already merged
+              elsif @keep == Keep::RIGHT
+                prev.replace(node)
               else
                 make_conflict_tree(prev, node)
               end
@@ -175,6 +195,17 @@ module RBI
           end
           tree.right << right
         end
+
+        sig { params(left: Scope, right: Scope).returns(Scope) }
+        def replace_scope_header(left, right)
+          right_copy = right.dup_empty
+          left.replace(right_copy)
+          left.nodes.each do |node|
+            right_copy << node
+          end
+          @index.index(right_copy)
+          right_copy
+        end
       end
 
       # Merge adjacent conflict trees
@@ -300,6 +331,8 @@ module RBI
         Module.new(name, loc: loc, comments: comments)
       when Class
         Class.new(name, superclass_name: superclass_name, loc: loc, comments: comments)
+      when Struct
+        Struct.new(name, members: members, keyword_init: keyword_init, loc: loc, comments: comments)
       when SingletonClass
         SingletonClass.new(loc: loc, comments: comments)
       else
@@ -326,6 +359,15 @@ module RBI
     end
   end
 
+  class Struct
+    extend T::Sig
+
+    sig { override.params(other: Node).returns(T::Boolean) }
+    def compatible_with?(other)
+      other.is_a?(Struct) && members == other.members && keyword_init == other.keyword_init
+    end
+  end
+
   class Const
     extend T::Sig
 

data/lib/rbi/rewriters/nest_non_public_methods.rb

@@ -12,18 +12,18 @@ module RBI
 
         case node
         when Tree
-          public_group = VisibilityGroup.new(Visibility::Public)
-          protected_group = VisibilityGroup.new(Visibility::Protected)
-          private_group = VisibilityGroup.new(Visibility::Private)
+          public_group = VisibilityGroup.new(Public.new)
+          protected_group = VisibilityGroup.new(Protected.new)
+          private_group = VisibilityGroup.new(Private.new)
 
           node.nodes.dup.each do |child|
             visit(child)
             next unless child.is_a?(Method)
             child.detach
             case child.visibility
-            when Visibility::Protected
+            when Protected
               protected_group << child
-            when Visibility::Private
+            when Private
               private_group << child
             else
               public_group << child

data/lib/rbi/rewriters/sort_nodes.rb

@@ -10,11 +10,11 @@ module RBI
       def visit(node)
         return unless node.is_a?(Tree)
         visit_all(node.nodes)
+        original_order = node.nodes.map.with_index.to_h
         node.nodes.sort! do |a, b|
-          return 0 if a.is_a?(Mixin) || b.is_a?(Mixin)
-
           res = node_rank(a) <=> node_rank(b)
           res = node_name(a) <=> node_name(b) if res == 0
+          res = (original_order[a] || 0) <=> (original_order[b] || 0) if res == 0
           res || 0
         end
       end
@@ -24,29 +24,29 @@ module RBI
       sig { params(node: Node).returns(Integer) }
       def node_rank(node)
         case node
-        when Group                then kind_rank(node.kind)
-        when Include, Extend      then 0
-        when Helper               then 1
-        when TypeMember           then 2
-        when MixesInClassMethods  then 3
-        when TStructField         then 4
-        when TEnumBlock           then 5
+        when Group                then group_rank(node.kind)
+        when Include, Extend      then 10
+        when Helper               then 20
+        when TypeMember           then 30
+        when MixesInClassMethods  then 40
+        when TStructField         then 50
+        when TEnumBlock           then 60
         when Method
           if node.name == "initialize"
-            7
+            71
           elsif !node.is_singleton
-            8
+            72
           else
-            9
+            73
           end
-        when Scope, Const then 9
+        when Scope, Const then 80
         else
-          10
+          100
         end
       end
 
       sig { params(kind: Group::Kind).returns(Integer) }
-      def kind_rank(kind)
+      def group_rank(kind)
         case kind
         when Group::Kind::Mixins              then 0
         when Group::Kind::Helpers             then 1
@@ -65,7 +65,7 @@ module RBI
       sig { params(node: Node).returns(T.nilable(String)) }
       def node_name(node)
         case node
-        when Module, Class, Const, Method, Helper, TStructField
+        when Module, Class, Struct, Const, Method, Helper, TStructField
           node.name
         end
       end

data/lib/rbi/version.rb

@@ -1,7 +1,6 @@
 # typed: true
-# typed: false
 # frozen_string_literal: true
 
 module RBI
-  VERSION = "0.0.2"
+  VERSION = "0.0.6"
 end

data/lib/rbi.rb

@@ -12,6 +12,7 @@ require "rbi/loc"
 require "rbi/model"
 require "rbi/visitor"
 require "rbi/index"
+require "rbi/rewriters/add_sig_templates"
 require "rbi/rewriters/merge_trees"
 require "rbi/rewriters/nest_singleton_methods"
 require "rbi/rewriters/nest_non_public_methods"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rbi
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.6
 platform: ruby
 authors:
 - Alexandre Terrasa
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-08-03 00:00:00.000000000 Z
+date: 2021-10-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ast
@@ -38,34 +38,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '13.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '13.0'
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.5.9204
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.5.9204
 - !ruby/object:Gem::Dependency
   name: unparser
   requirement: !ruby/object:Gem::Requirement
@@ -82,7 +68,7 @@ dependencies:
         version: '0'
 description: 
 email:
-- alexandre.terrasa@shopify.com
+- ruby@shopify.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -96,6 +82,7 @@ files:
 - lib/rbi/model.rb
 - lib/rbi/parser.rb
 - lib/rbi/printer.rb
+- lib/rbi/rewriters/add_sig_templates.rb
 - lib/rbi/rewriters/group_nodes.rb
 - lib/rbi/rewriters/merge_trees.rb
 - lib/rbi/rewriters/nest_non_public_methods.rb