tapioca 0.4.26 → 0.5.0

data/lib/tapioca/core_ext/string.rb

@@ -1,18 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-class String
-  extend T::Sig
-
-  sig { returns(String) }
-  def underscore
-    return self unless /[A-Z-]|::/.match?(self)
-
-    word = to_s.gsub("::", "/")
-    word.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
-    word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
-    word.tr!("-", "_")
-    word.downcase!
-    word
-  end
-end

data/lib/tapioca/rbi/model.rb

@@ -1,405 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module Tapioca
-  module RBI
-    class Node
-      extend T::Sig
-      extend T::Helpers
-
-      abstract!
-
-      sig { returns(T.nilable(Tree)) }
-      attr_accessor :parent_tree
-
-      sig { void }
-      def initialize
-        @parent_tree = nil
-      end
-
-      sig { void }
-      def detach
-        tree = parent_tree
-        return unless tree
-        tree.nodes.delete(self)
-        self.parent_tree = nil
-      end
-    end
-
-    class Tree < Node
-      extend T::Sig
-
-      sig { returns(T::Array[Node]) }
-      attr_reader :nodes
-
-      sig { void }
-      def initialize
-        super()
-        @nodes = T.let([], T::Array[Node])
-      end
-
-      sig { params(node: Node).void }
-      def <<(node)
-        node.parent_tree = self
-        @nodes << node
-      end
-
-      sig { returns(T::Boolean) }
-      def empty?
-        nodes.empty?
-      end
-    end
-
-    # Scopes
-
-    class Scope < Tree
-      extend T::Helpers
-
-      abstract!
-    end
-
-    class Module < Scope
-      extend T::Sig
-
-      sig { returns(String) }
-      attr_accessor :name
-
-      sig { params(name: String).void }
-      def initialize(name)
-        super()
-        @name = name
-      end
-    end
-
-    class Class < Scope
-      extend T::Sig
-
-      sig { returns(String) }
-      attr_accessor :name
-
-      sig { returns(T.nilable(String)) }
-      attr_accessor :superclass_name
-
-      sig { params(name: String, superclass_name: T.nilable(String)).void }
-      def initialize(name, superclass_name: nil)
-        super()
-        @name = name
-        @superclass_name = superclass_name
-      end
-    end
-
-    class SingletonClass < Scope
-      extend T::Sig
-
-      sig { void }
-      def initialize
-        super()
-      end
-    end
-
-    # Consts
-
-    class Const < Node
-      extend T::Sig
-
-      sig { returns(String) }
-      attr_reader :name, :value
-
-      sig { params(name: String, value: String).void }
-      def initialize(name, value)
-        super()
-        @name = name
-        @value = value
-      end
-    end
-
-    # Methods and args
-
-    class Method < Node
-      extend T::Sig
-
-      sig { returns(String) }
-      attr_accessor :name
-
-      sig { returns(T::Array[Param]) }
-      attr_reader :params
-
-      sig { returns(T::Boolean) }
-      attr_accessor :is_singleton
-
-      sig { returns(Visibility) }
-      attr_accessor :visibility
-
-      sig { returns(T::Array[Sig]) }
-      attr_accessor :sigs
-
-      sig do
-        params(
-          name: String,
-          params: T::Array[Param],
-          is_singleton: T::Boolean,
-          visibility: Visibility,
-          sigs: T::Array[Sig]
-        ).void
-      end
-      def initialize(name, params: [], is_singleton: false, visibility: Visibility::Public, sigs: [])
-        super()
-        @name = name
-        @params = params
-        @is_singleton = is_singleton
-        @visibility = visibility
-        @sigs = sigs
-      end
-
-      sig { params(param: Param).void }
-      def <<(param)
-        @params << param
-      end
-    end
-
-    class Param < Node
-      extend T::Sig
-
-      sig { returns(String) }
-      attr_reader :name
-
-      sig { params(name: String).void }
-      def initialize(name)
-        super()
-        @name = name
-      end
-    end
-
-    class OptParam < Param
-      extend T::Sig
-
-      sig { returns(String) }
-      attr_reader :value
-
-      sig { params(name: String, value: String).void }
-      def initialize(name, value)
-        super(name)
-        @value = value
-      end
-    end
-
-    class RestParam < Param; end
-    class KwParam < Param; end
-    class KwOptParam < OptParam; end
-    class KwRestParam < Param; end
-    class BlockParam < Param; end
-
-    # Mixins
-
-    class Mixin < Node
-      extend T::Sig
-      extend T::Helpers
-
-      abstract!
-
-      sig { returns(String) }
-      attr_reader :name
-
-      sig { params(name: String).void }
-      def initialize(name)
-        super()
-        @name = name
-      end
-    end
-
-    class Include < Mixin; end
-    class Extend < Mixin; end
-
-    # Visibility
-
-    class Visibility < Node
-      extend T::Sig
-      extend T::Helpers
-
-      abstract!
-
-      sig { returns(Symbol) }
-      attr_reader :visibility
-
-      sig { params(visibility: Symbol).void }
-      def initialize(visibility)
-        super()
-        @visibility = visibility
-      end
-
-      sig { returns(T::Boolean) }
-      def public?
-        visibility == :public
-      end
-
-      Public = T.let(Visibility.new(:public), Visibility)
-      Protected = T.let(Visibility.new(:protected), Visibility)
-      Private = T.let(Visibility.new(:private), Visibility)
-    end
-
-    # Sorbet's sigs
-
-    class Sig < Node
-      extend T::Sig
-
-      sig { returns(T::Array[SigParam]) }
-      attr_reader :params
-
-      sig { returns(T.nilable(String)) }
-      attr_accessor :return_type
-
-      sig { returns(T::Boolean) }
-      attr_accessor :is_abstract, :is_override, :is_overridable
-
-      sig { returns(T::Array[String]) }
-      attr_reader :type_params
-
-      sig do
-        params(
-          params: T::Array[SigParam],
-          return_type: T.nilable(String),
-          is_abstract: T::Boolean,
-          is_override: T::Boolean,
-          is_overridable: T::Boolean,
-          type_params: T::Array[String]
-        ).void
-      end
-      def initialize(
-        params: [],
-        return_type: nil,
-        is_abstract: false,
-        is_override: false,
-        is_overridable: false,
-        type_params: []
-      )
-        super()
-        @params = params
-        @return_type = return_type
-        @is_abstract = is_abstract
-        @is_override = is_override
-        @is_overridable = is_overridable
-        @type_params = type_params
-      end
-
-      sig { params(param: SigParam).void }
-      def <<(param)
-        @params << param
-      end
-    end
-
-    class SigParam < Node
-      extend T::Sig
-
-      sig { returns(String) }
-      attr_reader :name, :type
-
-      sig { params(name: String, type: String).void }
-      def initialize(name, type)
-        super()
-        @name = name
-        @type = type
-      end
-    end
-
-    # Sorbet's T::Struct
-
-    class TStruct < Class
-      extend T::Sig
-
-      sig { params(name: String).void }
-      def initialize(name)
-        super(name, superclass_name: "::T::Struct")
-      end
-    end
-
-    class TStructField < Node
-      extend T::Sig
-      extend T::Helpers
-
-      abstract!
-
-      sig { returns(String) }
-      attr_accessor :name, :type
-
-      sig { returns(T.nilable(String)) }
-      attr_accessor :default
-
-      sig do
-        params(
-          name: String,
-          type: String,
-          default: T.nilable(String)
-        ).void
-      end
-      def initialize(name, type, default: nil)
-        super()
-        @name = name
-        @type = type
-        @default = default
-      end
-    end
-
-    class TStructProp < TStructField; end
-    class TStructConst < TStructField; end
-
-    # Sorbet's T::Enum
-
-    class TEnum < Class
-      extend T::Sig
-
-      sig { params(name: String).void }
-      def initialize(name)
-        super(name, superclass_name: "::T::Enum")
-      end
-    end
-
-    class TEnumBlock < Node
-      extend T::Sig
-
-      sig { returns(T::Array[String]) }
-      attr_reader :names
-
-      sig { params(names: T::Array[String]).void }
-      def initialize(names = [])
-        super()
-        @names = names
-      end
-
-      sig { returns(T::Boolean) }
-      def empty?
-        names.empty?
-      end
-    end
-
-    # Sorbet's misc.
-
-    class Helper < Node
-      extend T::Helpers
-
-      sig { returns(String) }
-      attr_reader :name
-
-      sig { params(name: String).void }
-      def initialize(name)
-        super()
-        @name = name
-      end
-    end
-
-    class TypeMember < Node
-      extend T::Sig
-
-      sig { returns(String) }
-      attr_reader :name, :value
-
-      sig { params(name: String, value: String).void }
-      def initialize(name, value)
-        super()
-        @name = name
-        @value = value
-      end
-    end
-
-    class MixesInClassMethods < Mixin; end
-  end
-end

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