rbi 0.0.7 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 97c295f819a7f55175bf02dc1722a7a6ad29c82f92c7f9be2636a47652d0b39f
-  data.tar.gz: f0ab6cb29d0e2a1a0ef78452543258761664d081845b042c0f5f1fc2f74f9773
+  metadata.gz: 37be6daaf86810c60a865b98ac94ff089184e990e168bc405a0d167c641477ed
+  data.tar.gz: 95de3a3ffb035c40d9dd8da3055d808b1b0ae365add26bbc0754ae997c1c09c9
 SHA512:
-  metadata.gz: cb97cd66fd4231f3609efede4b98f8590cf7fff1382b4dbae1997161a8b2aed5ed10e6bc388d8388a16dc71792ba5b5ec32561b37f353cc8b77cbfb778542a60
-  data.tar.gz: a44902b6c3a669c0d706952459b2ebdbe78bbfdcf75ed50b0d16274f9fafa2cba20adb7ce0b70bf2011765edcfe9ea4cf823bb973618e4babd091fdc5e3fafd8
+  metadata.gz: 3b794985ed143c257080ed69ab6ac8458e0cfcad5e988bfe412566dd2146ea009a8ceabfb274759089e3a687eb42e15b27c31a884c04e78a6b413b424d97d0b1
+  data.tar.gz: bc41f792fd147ceb04dee6852e046a68e5f90f886ce4b2937ceaa642ef4d9d46996f1560067177acfedc52b73b60878aeb03cd64deda17be516d04516e37ed63

data/Gemfile

@@ -8,6 +8,7 @@ gemspec
 group(:development, :test) do
   gem("byebug")
   gem("minitest")
+  gem("minitest-reporters")
   gem("rake", "~> 13.0")
   gem("rubocop", "~> 1.7", require: false)
   gem("rubocop-shopify", require: false)

data/lib/rbi/index.rb

@@ -29,9 +29,9 @@ module RBI
       @index[id] ||= []
     end
 
-    sig { params(node: T.all(Indexable, Node)).void }
-    def index(node)
-      node.index_ids.each { |id| self[id] << node }
+    sig { params(nodes: Node).void }
+    def index(*nodes)
+      nodes.each { |node| visit(node) }
     end
 
     sig { override.params(node: T.nilable(Node)).void }
@@ -40,14 +40,21 @@ module RBI
 
       case node
       when Scope
-        index(node)
+        index_node(node)
         visit_all(node.nodes)
       when Tree
         visit_all(node.nodes)
       when Indexable
-        index(node)
+        index_node(node)
       end
     end
+
+    private
+
+    sig { params(node: T.all(Indexable, Node)).void }
+    def index_node(node)
+      node.index_ids.each { |id| self[id] << node }
+    end
   end
 
   class Tree
@@ -154,6 +161,16 @@ module RBI
     end
   end
 
+  class Send
+    extend T::Sig
+    include Indexable
+
+    sig { override.returns(T::Array[String]) }
+    def index_ids
+      ["#{parent_scope&.fully_qualified_name}.#{method}"]
+    end
+  end
+
   class TStructConst
     extend T::Sig
     include Indexable

data/lib/rbi/model.rb

@@ -914,6 +914,106 @@ module RBI
     end
   end
 
+  # Sends
+
+  class Send < NodeWithComments
+    extend T::Sig
+
+    sig { returns(String) }
+    attr_reader :method
+
+    sig { returns(T::Array[Arg]) }
+    attr_reader :args
+
+    sig do
+      params(
+        method: String,
+        args: T::Array[Arg],
+        loc: T.nilable(Loc),
+        comments: T::Array[Comment],
+        block: T.nilable(T.proc.params(node: Send).void)
+      ).void
+    end
+    def initialize(method, args = [], loc: nil, comments: [], &block)
+      super(loc: loc, comments: comments)
+      @method = method
+      @args = args
+      block&.call(self)
+    end
+
+    sig { params(arg: Arg).void }
+    def <<(arg)
+      @args << arg
+    end
+
+    sig { params(other: T.nilable(Object)).returns(T::Boolean) }
+    def ==(other)
+      Send === other && method == other.method && args == other.args
+    end
+
+    sig { returns(String) }
+    def to_s
+      "#{parent_scope&.fully_qualified_name}.#{method}(#{args.join(", ")})"
+    end
+  end
+
+  class Arg < Node
+    extend T::Sig
+
+    sig { returns(String) }
+    attr_reader :value
+
+    sig do
+      params(
+        value: String,
+        loc: T.nilable(Loc)
+      ).void
+    end
+    def initialize(value, loc: nil)
+      super(loc: loc)
+      @value = value
+    end
+
+    sig { params(other: T.nilable(Object)).returns(T::Boolean) }
+    def ==(other)
+      Arg === other && value == other.value
+    end
+
+    sig { returns(String) }
+    def to_s
+      value
+    end
+  end
+
+  class KwArg < Arg
+    extend T::Sig
+
+    sig { returns(String) }
+    attr_reader :keyword
+
+    sig do
+      params(
+        keyword: String,
+        value: String,
+        loc: T.nilable(Loc)
+      ).void
+    end
+    def initialize(keyword, value, loc: nil)
+      super(value, loc: loc)
+      @keyword = keyword
+    end
+
+    sig { params(other: T.nilable(Object)).returns(T::Boolean) }
+    def ==(other)
+      KwArg === other && value == other.value && keyword == other.keyword
+    end
+
+    sig { returns(String) }
+    def to_s
+      "#{keyword}: #{value}"
+    end
+  end
+
   # Sorbet's sigs
 
   class Sig < Node

data/lib/rbi/parser.rb

@@ -43,11 +43,23 @@ module RBI
       Parser.new.parse_file(path)
     end
 
+    sig { params(paths: T::Array[String]).returns(T::Array[Tree]) }
+    def self.parse_files(paths)
+      parser = Parser.new
+      paths.map { |path| parser.parse_file(path) }
+    end
+
     sig { params(string: String).returns(Tree) }
     def parse_string(string)
       parse(string, file: "-")
     end
 
+    sig { params(strings: T::Array[String]).returns(T::Array[Tree]) }
+    def self.parse_strings(strings)
+      parser = Parser.new
+      strings.map { |string| parser.parse_string(string) }
+    end
+
     sig { params(path: String).returns(Tree) }
     def parse_file(path)
       parse(::File.read(path), file: path)
@@ -59,10 +71,9 @@ module RBI
     def parse(content, file:)
       node, comments = Unparser.parse_with_comments(content)
       assoc = ::Parser::Source::Comment.associate_locations(node, comments)
-      builder = TreeBuilder.new(file: file, comments: assoc)
-      builder.separate_header_comments
+      builder = TreeBuilder.new(file: file, comments: comments, nodes_comments_assoc: assoc)
       builder.visit(node)
-      builder.assoc_dangling_comments(comments)
+      builder.post_process
       builder.tree
     rescue ::Parser::SyntaxError => e
       raise ParseError.new(e.message, Loc.from_ast_loc(file, e.diagnostic.location))
@@ -105,16 +116,26 @@ module RBI
     sig do
       params(
         file: String,
-        comments: T::Hash[::Parser::Source::Map, T::Array[::Parser::Source::Comment]]
+        comments: T::Array[::Parser::Source::Comment],
+        nodes_comments_assoc: T::Hash[::Parser::Source::Map, T::Array[::Parser::Source::Comment]]
       ).void
     end
-    def initialize(file:, comments: {})
+    def initialize(file:, comments: [], nodes_comments_assoc: {})
       super()
       @file = file
       @comments = comments
+      @nodes_comments_assoc = nodes_comments_assoc
       @tree = T.let(Tree.new, Tree)
       @scopes_stack = T.let([@tree], T::Array[Tree])
       @last_sigs = T.let([], T::Array[RBI::Sig])
+
+      separate_header_comments
+    end
+
+    sig { void }
+    def post_process
+      assoc_dangling_comments
+      set_root_tree_loc
     end
 
     sig { override.params(node: T.nilable(Object)).void }
@@ -146,46 +167,6 @@ module RBI
       end
     end
 
-    sig { void }
-    def separate_header_comments
-      return if @comments.empty?
-
-      keep = []
-      node = T.must(@comments.keys.first)
-      comments = T.must(@comments.values.first)
-
-      last_line = T.let(nil, T.nilable(Integer))
-      comments.reverse.each do |comment|
-        comment_line = comment.location.last_line
-
-        break if last_line && comment_line < last_line - 1 ||
-          !last_line && comment_line < node.first_line - 1
-
-        keep << comment
-        last_line = comment_line
-      end
-
-      @comments[node] = keep.reverse
-    end
-
-    sig { params(comments: T::Array[::Parser::Source::Comment]).void }
-    def assoc_dangling_comments(comments)
-      last_line = T.let(nil, T.nilable(Integer))
-      (comments - @comments.values.flatten).each do |comment|
-        comment_line = comment.location.last_line
-        text = comment.text[1..-1].strip
-        loc = Loc.from_ast_loc(@file, comment.location)
-
-        if last_line && comment_line > last_line + 1
-          # Preserve empty lines in file headers
-          tree.comments << BlankLine.new(loc: loc)
-        end
-
-        tree.comments << Comment.new(text, loc: loc)
-        last_line = comment_line
-      end
-    end
-
     private
 
     sig { params(node: AST::Node).returns(Scope) }
@@ -332,10 +313,28 @@ module RBI
         name, type, default_value = parse_tstruct_prop(node)
         TStructConst.new(name, type, default: default_value, loc: loc, comments: comments)
       else
-        raise ParseError.new("Unsupported send node with name `#{method_name}`", loc)
+        args = parse_send_args(node)
+        Send.new(method_name.to_s, args, loc: loc, comments: comments)
       end
     end
 
+    sig { params(node: AST::Node).returns(T::Array[Arg]) }
+    def parse_send_args(node)
+      args = T.let([], T::Array[Arg])
+      node.children[2..-1].each do |child|
+        if child.type == :kwargs
+          child.children.each do |pair|
+            keyword = pair.children.first.children.last.to_s
+            value = parse_expr(pair.children.last)
+            args << KwArg.new(keyword, value)
+          end
+        else
+          args << Arg.new(parse_expr(child))
+        end
+      end
+      args
+    end
+
     sig { params(node: AST::Node).returns(T.nilable(RBI::Node)) }
     def parse_block(node)
       name = node.children[0].children[1]
@@ -435,7 +434,7 @@ module RBI
 
     sig { params(node: AST::Node).returns(T::Array[Comment]) }
     def node_comments(node)
-      comments = @comments[node.location]
+      comments = @nodes_comments_assoc[node.location]
       return [] unless comments
       comments.map do |comment|
         text = comment.text[1..-1].strip
@@ -455,6 +454,60 @@ module RBI
       @last_sigs.clear
       sigs
     end
+
+    sig { void }
+    def assoc_dangling_comments
+      last_line = T.let(nil, T.nilable(Integer))
+      (@comments - @nodes_comments_assoc.values.flatten).each do |comment|
+        comment_line = comment.location.last_line
+        text = comment.text[1..-1].strip
+        loc = Loc.from_ast_loc(@file, comment.location)
+
+        if last_line && comment_line > last_line + 1
+          # Preserve empty lines in file headers
+          tree.comments << BlankLine.new(loc: loc)
+        end
+
+        tree.comments << Comment.new(text, loc: loc)
+        last_line = comment_line
+      end
+    end
+
+    sig { void }
+    def separate_header_comments
+      return if @nodes_comments_assoc.empty?
+
+      keep = []
+      node = T.must(@nodes_comments_assoc.keys.first)
+      comments = T.must(@nodes_comments_assoc.values.first)
+
+      last_line = T.let(nil, T.nilable(Integer))
+      comments.reverse.each do |comment|
+        comment_line = comment.location.last_line
+
+        break if last_line && comment_line < last_line - 1 ||
+          !last_line && comment_line < node.first_line - 1
+
+        keep << comment
+        last_line = comment_line
+      end
+
+      @nodes_comments_assoc[node] = keep.reverse
+    end
+
+    sig { void }
+    def set_root_tree_loc
+      first_loc = tree.nodes.first&.loc
+      last_loc = tree.nodes.last&.loc
+
+      @tree.loc = Loc.new(
+        file: @file,
+        begin_line: first_loc&.begin_line || 0,
+        begin_column: first_loc&.begin_column || 0,
+        end_line: last_loc&.end_line || 0,
+        end_column: last_loc&.end_column || 0
+      )
+    end
   end
 
   class ConstBuilder < ASTVisitor

data/lib/rbi/printer.rb

@@ -555,6 +555,47 @@ module RBI
     end
   end
 
+  class Send
+    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.printt(method)
+      unless args.empty?
+        v.print(" ")
+        args.each_with_index do |arg, index|
+          v.visit(arg)
+          v.print(", ") if index < args.size - 1
+        end
+      end
+      v.printn
+    end
+  end
+
+  class Arg
+    extend T::Sig
+
+    sig { override.params(v: Printer).void }
+    def accept_printer(v)
+      v.print(value)
+    end
+  end
+
+  class KwArg
+    extend T::Sig
+
+    sig { override.params(v: Printer).void }
+    def accept_printer(v)
+      v.print(keyword)
+      v.print(": ")
+      v.print(value)
+    end
+  end
+
   class Sig
     extend T::Sig
 

data/lib/rbi/rewriters/group_nodes.rb

@@ -55,6 +55,8 @@ module RBI
         Group::Kind::TypeMembers
       when MixesInClassMethods
         Group::Kind::MixesInClassMethods
+      when Send
+        Group::Kind::Sends
       when TStructField
         Group::Kind::TStructFields
       when TEnumBlock
@@ -67,6 +69,8 @@ module RBI
         else
           Group::Kind::Methods
         end
+      when SingletonClass
+        Group::Kind::SingletonClasses
       when Scope, Const
         Group::Kind::Consts
       else
@@ -93,10 +97,12 @@ module RBI
         Helpers             = new
         TypeMembers         = new
         MixesInClassMethods = new
+        Sends               = new
         TStructFields       = new
         TEnums              = new
         Inits               = new
         Methods             = new
+        SingletonClasses    = new
         Consts              = new
       end
     end

data/lib/rbi/rewriters/merge_trees.rb

@@ -512,6 +512,15 @@ module RBI
     end
   end
 
+  class Send
+    extend T::Sig
+
+    sig { override.params(other: Node).returns(T::Boolean) }
+    def compatible_with?(other)
+      other.is_a?(Send) && method == other.method && args == other.args
+    end
+  end
+
   class TStructField
     extend T::Sig
 

data/lib/rbi/rewriters/remove_known_definitions.rb

@@ -0,0 +1,125 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RBI
+  module Rewriters
+    # Remove all definitions existing in the index from the current tree
+    #
+    # Let's create an `Index` from two different `Tree`s:
+    # ~~~rb
+    # tree1 = Parse.parse_string(<<~RBI)
+    #   class Foo
+    #     def foo; end
+    #   end
+    # RBI
+    #
+    # tree2 = Parse.parse_string(<<~RBI)
+    #   FOO = 10
+    # RBI
+    #
+    # index = Index.index(tree1, tree2)
+    # ~~~
+    #
+    # We can use `RemoveKnownDefinitions` to remove the definitions found in the `index` from the `Tree` to clean:
+    # ~~~rb
+    # tree_to_clean = Parser.parse_string(<<~RBI)
+    #   class Foo
+    #     def foo; end
+    #     def bar; end
+    #   end
+    #   FOO = 10
+    #   BAR = 42
+    # RBI
+    #
+    # cleaned_tree, operations = RemoveKnownDefinitions.remove(tree_to_clean, index)
+    #
+    # assert_equal(<<~RBI, cleaned_tree)
+    #   class Foo
+    #     def bar; end
+    #   end
+    #   BAR = 42
+    # RBI
+    #
+    # assert_equal(<<~OPERATIONS, operations.join("\n"))
+    #   Deleted ::Foo#foo at -:2:2-2-16 (duplicate from -:2:2-2:16)
+    #   Deleted ::FOO at -:5:0-5:8 (duplicate from -:1:0-1:8)
+    # OPERATIONS
+    # ~~~
+    class RemoveKnownDefinitions < Visitor
+      extend T::Sig
+
+      sig do
+        params(
+          tree: RBI::Tree,
+          index: RBI::Index
+        ).returns([RBI::Tree, T::Array[Operation]])
+      end
+      def self.remove(tree, index)
+        v = RemoveKnownDefinitions.new(index)
+        v.visit(tree)
+        [tree, v.operations]
+      end
+
+      sig { returns(T::Array[Operation]) }
+      attr_reader :operations
+
+      sig { params(index: RBI::Index).void }
+      def initialize(index)
+        super()
+        @index = index
+        @operations = T.let([], T::Array[Operation])
+      end
+
+      sig { params(nodes: T::Array[RBI::Node]).void }
+      def visit_all(nodes)
+        nodes.dup.each { |node| visit(node) }
+      end
+
+      sig { override.params(node: T.nilable(RBI::Node)).void }
+      def visit(node)
+        return unless node
+
+        case node
+        when RBI::Scope
+          visit_all(node.nodes)
+          previous = previous_definition_for(node)
+          delete_node(node, previous) if previous && node.empty?
+        when RBI::Tree
+          visit_all(node.nodes)
+        when RBI::Indexable
+          previous = previous_definition_for(node)
+          delete_node(node, previous) if previous
+        end
+      end
+
+      private
+
+      sig { params(node: RBI::Indexable).returns(T.nilable(RBI::Node)) }
+      def previous_definition_for(node)
+        node.index_ids.each do |id|
+          previous = @index[id].first
+          return previous if previous
+        end
+        nil
+      end
+
+      sig { params(node: RBI::Node, previous: RBI::Node).void }
+      def delete_node(node, previous)
+        node.detach
+        @operations << Operation.new(deleted_node: node, duplicate_of: previous)
+      end
+
+      class Operation < T::Struct
+        extend T::Sig
+
+        const :deleted_node, RBI::Node
+        const :duplicate_of, RBI::Node
+
+        sig { returns(String) }
+        def to_s
+          "Deleted #{duplicate_of} at #{deleted_node.loc} (duplicate from #{duplicate_of.loc})"
+        end
+      end
+    end
+  end
+end

data/lib/rbi/rewriters/sort_nodes.rb

@@ -12,10 +12,16 @@ module RBI
         visit_all(node.nodes)
         original_order = node.nodes.map.with_index.to_h
         node.nodes.sort! do |a, b|
+          # First we try to compare the nodes by their node rank (based on the node type)
           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
+          next res if res != 0 # we can sort the nodes by their rank, let's stop here
+
+          # Then, if the nodes ranks are the same (res == 0), we try to compare the nodes by their name
+          res = node_name(a) <=> node_name(b)
+          next res if res && res != 0 # we can sort the nodes by their name, let's stop here
+
+          # Finally, if the two nodes have the same rank and the same name or at least one node is anonymous then,
+          T.must(original_order[a]) <=> T.must(original_order[b]) # we keep the original order
         end
       end
 
@@ -29,19 +35,21 @@ module RBI
         when Helper               then 20
         when TypeMember           then 30
         when MixesInClassMethods  then 40
-        when TStructField         then 50
-        when TEnumBlock           then 60
+        when Send                 then 50
+        when TStructField         then 60
+        when TEnumBlock           then 70
         when Method
           if node.name == "initialize"
-            71
+            81
           elsif !node.is_singleton
-            72
+            82
           else
-            73
+            83
           end
-        when Scope, Const then 80
+        when SingletonClass       then 90
+        when Scope, Const         then 100
         else
-          100
+          110
         end
       end
 
@@ -52,11 +60,13 @@ module RBI
         when Group::Kind::Helpers             then 1
         when Group::Kind::TypeMembers         then 2
         when Group::Kind::MixesInClassMethods then 3
-        when Group::Kind::TStructFields       then 4
-        when Group::Kind::TEnums              then 5
-        when Group::Kind::Inits               then 6
-        when Group::Kind::Methods             then 7
-        when Group::Kind::Consts              then 8
+        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
         else
           T.absurd(kind)
         end

data/lib/rbi/version.rb

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

data/lib/rbi.rb

@@ -19,6 +19,7 @@ require "rbi/rewriters/merge_trees"
 require "rbi/rewriters/nest_singleton_methods"
 require "rbi/rewriters/nest_non_public_methods"
 require "rbi/rewriters/group_nodes"
+require "rbi/rewriters/remove_known_definitions"
 require "rbi/rewriters/sort_nodes"
 require "rbi/parser"
 require "rbi/printer"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rbi
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.8
 platform: ruby
 authors:
 - Alexandre Terrasa
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-11-16 00:00:00.000000000 Z
+date: 2021-11-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ast
@@ -89,6 +89,7 @@ files:
 - lib/rbi/rewriters/merge_trees.rb
 - lib/rbi/rewriters/nest_non_public_methods.rb
 - lib/rbi/rewriters/nest_singleton_methods.rb
+- lib/rbi/rewriters/remove_known_definitions.rb
 - lib/rbi/rewriters/sort_nodes.rb
 - lib/rbi/version.rb
 - lib/rbi/visitor.rb