rbi 0.0.6 → 0.0.10

data/lib/rbi/rewriters/remove_known_definitions.rb

@@ -0,0 +1,143 @@
+# 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: Tree,
+          index: Index
+        ).returns([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: Index).void }
+      def initialize(index)
+        super()
+        @index = index
+        @operations = T.let([], T::Array[Operation])
+      end
+
+      sig { params(nodes: T::Array[Node]).void }
+      def visit_all(nodes)
+        nodes.dup.each { |node| visit(node) }
+      end
+
+      sig { override.params(node: T.nilable(Node)).void }
+      def visit(node)
+        return unless node
+
+        case node
+        when Scope
+          visit_all(node.nodes)
+          previous = previous_definition_for(node)
+          delete_node(node, previous) if previous && can_delete_node?(node, previous)
+        when Tree
+          visit_all(node.nodes)
+        when Indexable
+          previous = previous_definition_for(node)
+          delete_node(node, previous) if previous && can_delete_node?(node, previous)
+        end
+      end
+
+      private
+
+      sig { params(node: Indexable).returns(T.nilable(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: 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)
+      end
+
+      class Operation < T::Struct
+        extend T::Sig
+
+        const :deleted_node, Node
+        const :duplicate_of, 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

@@ -8,14 +8,22 @@ 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
         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
 
@@ -26,22 +34,26 @@ 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 TStructField         then 50
-        when TEnumBlock           then 60
+        when Send                 then 50
+        when TStructField         then 60
+        when TEnumBlock           then 70
+        when Attr                 then 75
         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
 
@@ -49,14 +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::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::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::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
@@ -65,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.6"
+  VERSION = "0.0.10"
 end

data/lib/rbi.rb

@@ -13,10 +13,13 @@ require "rbi/model"
 require "rbi/visitor"
 require "rbi/index"
 require "rbi/rewriters/add_sig_templates"
+require "rbi/rewriters/annotate"
+require "rbi/rewriters/deannotate"
 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.6
+  version: 0.0.10
 platform: ruby
 authors:
 - Alexandre Terrasa
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-10-06 00:00:00.000000000 Z
+date: 2022-01-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ast
@@ -83,10 +83,13 @@ files:
 - lib/rbi/parser.rb
 - lib/rbi/printer.rb
 - lib/rbi/rewriters/add_sig_templates.rb
+- lib/rbi/rewriters/annotate.rb
+- lib/rbi/rewriters/deannotate.rb
 - lib/rbi/rewriters/group_nodes.rb
 - 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