tapioca 0.4.27 → 0.5.3

data/lib/tapioca/rbi/printer.rb

@@ -1,410 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module Tapioca
-  module RBI
-    class Printer < Visitor
-      extend T::Sig
-
-      sig { returns(T::Boolean) }
-      attr_accessor :in_visibility_group
-
-      sig { returns(T.nilable(Node)) }
-      attr_reader :previous_node
-
-      sig { params(out: T.any(IO, StringIO), indent: Integer).void }
-      def initialize(out: $stdout, indent: 0)
-        super()
-        @out = out
-        @current_indent = indent
-        @in_visibility_group = T.let(false, T::Boolean)
-        @previous_node = T.let(nil, T.nilable(Node))
-      end
-
-      # Printing
-
-      sig { void }
-      def indent
-        @current_indent += 2
-      end
-
-      sig { void }
-      def dedent
-        @current_indent -= 2
-      end
-
-      # Print a string without indentation nor `\n` at the end.
-      sig { params(string: String).void }
-      def print(string)
-        @out.print(string)
-      end
-
-      # Print a string without indentation but with a `\n` at the end.
-      sig { params(string: T.nilable(String)).void }
-      def printn(string = nil)
-        print(string) if string
-        print("\n")
-      end
-
-      # Print a string with indentation but without a `\n` at the end.
-      sig { params(string: T.nilable(String)).void }
-      def printt(string = nil)
-        print(" " * @current_indent)
-        print(string) if string
-      end
-
-      # Print a string with indentation and `\n` at the end.
-      sig { params(string: String).void }
-      def printl(string)
-        printt
-        printn(string)
-      end
-
-      sig { override.params(node: T.nilable(Node)).void }
-      def visit(node)
-        return unless node
-        node.accept_printer(self)
-      end
-
-      sig { override.params(nodes: T::Array[Node]).void }
-      def visit_all(nodes)
-        previous_node = @previous_node
-        @previous_node = nil
-        nodes.each do |node|
-          visit(node)
-          @previous_node = node
-        end
-        @previous_node = previous_node
-      end
-    end
-
-    class Node
-      extend T::Sig
-
-      sig { abstract.params(v: Printer).void }
-      def accept_printer(v); end
-
-      sig { params(out: T.any(IO, StringIO), indent: Integer).void }
-      def print(out: $stdout, indent: 0)
-        p = Printer.new(out: out, indent: indent)
-        p.visit(self)
-      end
-
-      sig { params(indent: Integer).returns(String) }
-      def string(indent: 0)
-        out = StringIO.new
-        print(out: out, indent: indent)
-        out.string
-      end
-
-      sig { returns(T::Boolean) }
-      def oneline?
-        true
-      end
-    end
-
-    class Tree
-      extend T::Sig
-
-      sig { override.params(v: Printer).void }
-      def accept_printer(v)
-        v.visit_all(nodes)
-      end
-
-      sig { override.returns(T::Boolean) }
-      def oneline?
-        empty?
-      end
-    end
-
-    class Scope
-      extend T::Sig
-
-      sig { override.params(v: Printer).void }
-      def accept_printer(v)
-        previous_node = v.previous_node
-        v.printn if previous_node && (!previous_node.oneline? || !oneline?)
-
-        case self
-        when Module
-          v.printt("module #{name}")
-        when Class
-          v.printt("class #{name}")
-          superclass = superclass_name
-          v.print(" < #{superclass}") if superclass
-        when SingletonClass
-          v.printt("class << self")
-        end
-        if empty?
-          v.printn("; end")
-        else
-          v.printn
-          v.indent
-          v.visit_all(nodes)
-          v.dedent
-          v.printl("end")
-        end
-      end
-    end
-
-    class Const
-      extend T::Sig
-
-      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("#{name} = #{value}")
-      end
-    end
-
-    class Method
-      extend T::Sig
-
-      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.visit_all(sigs)
-        v.printt
-        unless v.in_visibility_group || visibility == Visibility::Public
-          v.print(visibility.visibility.to_s)
-          v.print(" ")
-        end
-        v.print("def ")
-        v.print("self.") if is_singleton
-        v.print(name)
-        unless params.empty?
-          v.print("(")
-          params.each_with_index do |param, index|
-            v.print(", ") if index > 0
-            v.visit(param)
-          end
-          v.print(")")
-        end
-        v.print("; end")
-        v.printn
-      end
-
-      sig { override.returns(T::Boolean) }
-      def oneline?
-        sigs.empty?
-      end
-    end
-
-    class Param
-      extend T::Sig
-
-      sig { override.params(v: Printer).void }
-      def accept_printer(v)
-        v.print(name.to_s)
-      end
-    end
-
-    class OptParam
-      extend T::Sig
-
-      sig { override.params(v: Printer).void }
-      def accept_printer(v)
-        v.print("#{name} = #{value}")
-      end
-    end
-
-    class RestParam
-      extend T::Sig
-
-      sig { override.params(v: Printer).void }
-      def accept_printer(v)
-        v.print("*#{name}")
-      end
-    end
-
-    class KwParam
-      extend T::Sig
-
-      sig { override.params(v: Printer).void }
-      def accept_printer(v)
-        v.print("#{name}:")
-      end
-    end
-
-    class KwOptParam
-      extend T::Sig
-
-      sig { override.params(v: Printer).void }
-      def accept_printer(v)
-        v.print("#{name}: #{value}")
-      end
-    end
-
-    class KwRestParam
-      extend T::Sig
-
-      sig { override.params(v: Printer).void }
-      def accept_printer(v)
-        v.print("**#{name}")
-      end
-    end
-
-    class BlockParam
-      extend T::Sig
-
-      sig { override.params(v: Printer).void }
-      def accept_printer(v)
-        v.print("&#{name}")
-      end
-    end
-
-    class Mixin
-      extend T::Sig
-
-      sig { override.params(v: Printer).void }
-      def accept_printer(v)
-        case self
-        when Include
-          v.printt("include")
-        when Extend
-          v.printt("extend")
-        when MixesInClassMethods
-          v.printt("mixes_in_class_methods")
-        end
-        v.printn(" #{name}")
-      end
-    end
-
-    class Visibility
-      extend T::Sig
-
-      sig { override.params(v: Printer).void }
-      def accept_printer(v)
-        v.printl(visibility.to_s)
-      end
-    end
-
-    class Sig
-      extend T::Sig
-
-      sig { override.params(v: Printer).void }
-      def accept_printer(v)
-        v.printt("sig { ")
-        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?
-          v.print("params(")
-          params.each_with_index do |param, index|
-            v.visit(param)
-            v.print(", ") if index < params.length - 1
-          end
-          v.print(").")
-        end
-        if return_type && return_type != "void"
-          v.print("returns(#{return_type})")
-        else
-          v.print("void")
-        end
-        v.printn(" }")
-      end
-    end
-
-    class SigParam
-      extend T::Sig
-
-      sig { override.params(v: Printer).void }
-      def accept_printer(v)
-        v.print("#{name}: #{type}")
-      end
-    end
-
-    class TStructField
-      extend T::Sig
-
-      sig { override.params(v: Printer).void }
-      def accept_printer(v)
-        case self
-        when TStructProp
-          v.printt("prop")
-        when TStructConst
-          v.printt("const")
-        end
-        v.print(" :#{name}, #{type}")
-        default = self.default
-        v.print(", default: #{default}") if default
-        v.printn
-      end
-    end
-
-    class TEnumBlock
-      extend T::Sig
-
-      sig { override.params(v: Printer).void }
-      def accept_printer(v)
-        v.printl("enums do")
-        v.indent
-        names.each do |name|
-          v.printl("#{name} = new")
-        end
-        v.dedent
-        v.printl("end")
-      end
-    end
-
-    class TypeMember
-      extend T::Sig
-
-      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("#{name} = #{value}")
-      end
-    end
-
-    class Helper
-      extend T::Sig
-
-      sig { override.params(v: Printer).void }
-      def accept_printer(v)
-        v.printl("#{name}!")
-      end
-    end
-
-    class Group
-      extend T::Sig
-
-      sig { override.params(v: Printer).void }
-      def accept_printer(v)
-        v.printn unless v.previous_node.nil?
-        v.visit_all(nodes)
-      end
-    end
-
-    class VisibilityGroup
-      extend T::Sig
-
-      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
-          v.visit(visibility)
-          v.printn
-        end
-        v.visit_all(nodes)
-        v.in_visibility_group = false
-      end
-    end
-  end
-end

data/lib/tapioca/rbi/rewriters/group_nodes.rb

@@ -1,106 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module Tapioca
-  module RBI
-    module Rewriters
-      class GroupNodes < Visitor
-        extend T::Sig
-
-        sig { override.params(node: T.nilable(Node)).void }
-        def visit(node)
-          return unless node
-
-          case node
-          when Tree
-            kinds = node.nodes.map(&:group_kind)
-            kinds.compact!
-            kinds.uniq!
-
-            groups = {}
-            kinds.each { |kind| groups[kind] = Group.new(kind) }
-
-            node.nodes.dup.each do |child|
-              visit(child)
-              child.detach
-              groups[child.group_kind] << child
-            end
-
-            groups.each { |_, group| node << group }
-          end
-        end
-      end
-    end
-
-    class Tree
-      extend T::Sig
-
-      sig { void }
-      def group_nodes!
-        visitor = Rewriters::GroupNodes.new
-        visitor.visit(self)
-      end
-    end
-
-    class Node
-      extend T::Sig
-
-      sig { returns(Group::Kind) }
-      def group_kind
-        case self
-        when Include, Extend
-          Group::Kind::Mixins
-        when Helper
-          Group::Kind::Helpers
-        when TypeMember
-          Group::Kind::TypeMembers
-        when MixesInClassMethods
-          Group::Kind::MixesInClassMethods
-        when TStructField
-          Group::Kind::TStructFields
-        when TEnumBlock
-          Group::Kind::TEnums
-        when VisibilityGroup
-          Group::Kind::Methods
-        when Method
-          if name == "initialize"
-            Group::Kind::Inits
-          else
-            Group::Kind::Methods
-          end
-        when Scope, Const
-          Group::Kind::Consts
-        else
-          raise "Unknown group for #{self}"
-        end
-      end
-    end
-
-    class Group < Tree
-      extend T::Sig
-
-      sig { returns(Kind) }
-      attr_reader :kind
-
-      sig { params(kind: Kind).void }
-      def initialize(kind)
-        super()
-        @kind = kind
-      end
-
-      class Kind < T::Enum
-        enums do
-          Mixins              = new
-          Helpers             = new
-          TypeMembers         = new
-          MixesInClassMethods = new
-          TStructFields       = new
-          TEnums              = new
-          Inits               = new
-          Methods             = new
-          Consts              = new
-        end
-      end
-    end
-  end
-end

data/lib/tapioca/rbi/rewriters/nest_non_public_methods.rb

@@ -1,65 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module Tapioca
-  module RBI
-    module Rewriters
-      class NestNonPublicMethods < Visitor
-        extend T::Sig
-
-        sig { override.params(node: T.nilable(Node)).void }
-        def visit(node)
-          return unless node
-
-          case node
-          when Tree
-            public_group = VisibilityGroup.new(Visibility::Public)
-            protected_group = VisibilityGroup.new(Visibility::Protected)
-            private_group = VisibilityGroup.new(Visibility::Private)
-
-            node.nodes.dup.each do |child|
-              visit(child)
-              next unless child.is_a?(Method)
-              child.detach
-              case child.visibility
-              when Visibility::Protected
-                protected_group << child
-              when Visibility::Private
-                private_group << child
-              else
-                public_group << child
-              end
-            end
-
-            node << public_group unless public_group.empty?
-            node << protected_group unless protected_group.empty?
-            node << private_group unless private_group.empty?
-          end
-        end
-      end
-    end
-
-    class Tree
-      extend T::Sig
-
-      sig { void }
-      def nest_non_public_methods!
-        visitor = Rewriters::NestNonPublicMethods.new
-        visitor.visit(self)
-      end
-    end
-
-    class VisibilityGroup < Tree
-      extend T::Sig
-
-      sig { returns(Visibility) }
-      attr_reader :visibility
-
-      sig { params(visibility: Visibility).void }
-      def initialize(visibility)
-        super()
-        @visibility = visibility
-      end
-    end
-  end
-end

data/lib/tapioca/rbi/rewriters/nest_singleton_methods.rb

@@ -1,42 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module Tapioca
-  module RBI
-    module Rewriters
-      class NestSingletonMethods < Visitor
-        extend T::Sig
-
-        sig { override.params(node: T.nilable(Node)).void }
-        def visit(node)
-          return unless node
-
-          case node
-          when Tree
-            singleton_class = SingletonClass.new
-
-            node.nodes.dup.each do |child|
-              visit(child)
-              next unless child.is_a?(Method) && child.is_singleton
-              child.detach
-              child.is_singleton = false
-              singleton_class << child
-            end
-
-            node << singleton_class unless singleton_class.empty?
-          end
-        end
-      end
-    end
-
-    class Tree
-      extend T::Sig
-
-      sig { void }
-      def nest_singleton_methods!
-        visitor = Rewriters::NestSingletonMethods.new
-        visitor.visit(self)
-      end
-    end
-  end
-end

data/lib/tapioca/rbi/rewriters/sort_nodes.rb

@@ -1,86 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module Tapioca
-  module RBI
-    module Rewriters
-      class SortNodes < Visitor
-        extend T::Sig
-
-        sig { override.params(node: T.nilable(Node)).void }
-        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|
-            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
-
-        private
-
-        sig { params(node: Node).returns(Integer) }
-        def node_rank(node)
-          case node
-          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"
-              71
-            elsif !node.is_singleton
-              72
-            else
-              73
-            end
-          when Scope, Const then 80
-          else
-            100
-          end
-        end
-
-        sig { params(kind: Group::Kind).returns(Integer) }
-        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
-          else
-            T.absurd(kind)
-          end
-        end
-
-        sig { params(node: Node).returns(T.nilable(String)) }
-        def node_name(node)
-          case node
-          when Module, Class, Const, Method, Helper, TStructField
-            node.name
-          end
-        end
-      end
-    end
-
-    class Tree
-      extend T::Sig
-
-      sig { void }
-      def sort_nodes!
-        visitor = Rewriters::SortNodes.new
-        visitor.visit(self)
-      end
-    end
-  end
-end