syntax_tree-rbs 0.2.0 → 0.5.0

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: syntax_tree-rbs
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Kevin Newton
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-04-22 00:00:00.000000000 Z
+date: 2022-07-07 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: prettier_print
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rbs
   requirement: !ruby/object:Gem::Requirement
@@ -117,11 +131,10 @@ files:
 - gemfiles/rbs1.gemfile
 - gemfiles/rbs2.gemfile
 - lib/syntax_tree/rbs.rb
-- lib/syntax_tree/rbs/declarations.rb
-- lib/syntax_tree/rbs/members.rb
+- lib/syntax_tree/rbs/entrypoints.rb
+- lib/syntax_tree/rbs/format.rb
+- lib/syntax_tree/rbs/pretty_print.rb
 - lib/syntax_tree/rbs/shims.rb
-- lib/syntax_tree/rbs/types.rb
-- lib/syntax_tree/rbs/utils.rb
 - lib/syntax_tree/rbs/version.rb
 - syntax_tree-rbs.gemspec
 homepage: https://github.com/ruby-syntax-tree/syntax_tree-rbs
@@ -144,7 +157,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
+rubygems_version: 3.3.3
 signing_key:
 specification_version: 4
 summary: Syntax Tree support for RBS

data/lib/syntax_tree/rbs/declarations.rb

@@ -1,226 +0,0 @@
-# frozen_string_literal: true
-
-module RBS
-  module AST
-    module Declarations
-      class Alias
-        # Prints out a type alias, which is a declaration that looks like:
-        # type foo = String
-        def format(q)
-          SyntaxTree::RBS::Comment.maybe_format(q, comment)
-          SyntaxTree::RBS::Annotations.maybe_format(q, annotations)
-
-          q.group do
-            q.text("type ")
-            name.format(q)
-            q.text(" =")
-            q.group do
-              q.indent do
-                q.breakable
-                type.format(q)
-              end
-            end
-          end
-        end
-
-        def pretty_print(q)
-          q.group(2, "(constant", ")") do
-            SyntaxTree::RBS::Comment.maybe_pretty_print(q, comment)
-            SyntaxTree::RBS::Annotations.maybe_pretty_print(q, annotations)
-
-            q.breakable
-            q.text("name=")
-            q.pp(name)
-
-            q.breakable
-            q.text("type=")
-            q.pp(type)
-          end
-        end
-      end
-
-      class Class
-        # Prints out a class declarations, which looks like:
-        # class Foo end
-        def format(q)
-          SyntaxTree::RBS::Comment.maybe_format(q, comment)
-          SyntaxTree::RBS::Annotations.maybe_format(q, annotations)
-
-          q.group do
-            q.text("class ")
-            SyntaxTree::RBS::NameAndTypeParams.new(self).format(q)
-
-            if super_class
-              q.text(" < ")
-              SyntaxTree::RBS::NameAndArgs.new(super_class).format(q)
-            end
-
-            q.indent do
-              SyntaxTree::RBS::Members.new(self).format(q)
-            end
-
-            q.breakable(force: true)
-            q.text("end")
-          end
-        end
-
-        def pretty_print(q)
-          q.group(2, "(class", ")") do
-            SyntaxTree::RBS::Comment.maybe_pretty_print(q, comment)
-            SyntaxTree::RBS::Annotations.maybe_pretty_print(q, annotations)
-
-            q.pp(SyntaxTree::RBS::NameAndTypeParams.new(self))
-
-            if super_class
-              q.breakable
-              q.text("super_class=")
-              q.group(2, "(class", ")") do
-                q.pp(SyntaxTree::RBS::NameAndArgs.new(super_class))
-              end
-            end
-
-            q.breakable
-            q.text("members=")
-            q.pp(members)
-          end
-        end
-      end
-
-      class Constant
-        # Prints out a constant declaration, which looks like:
-        # Foo: String
-        def format(q)
-          SyntaxTree::RBS::Comment.maybe_format(q, comment)
-
-          q.group do
-            name.format(q)
-            q.text(": ")
-            type.format(q)
-          end
-        end
-
-        def pretty_print(q)
-          q.group(2, "(constant", ")") do
-            SyntaxTree::RBS::Comment.maybe_pretty_print(q, comment)
-
-            q.breakable
-            q.text("name=")
-            q.pp(name)
-
-            q.breakable
-            q.text("type=")
-            q.pp(type)
-          end
-        end
-      end
-
-      class Global
-        # Prints out a global declaration, which looks like:
-        # $foo: String
-        def format(q)
-          SyntaxTree::RBS::Comment.maybe_format(q, comment)
-
-          q.group do
-            q.text(name)
-            q.text(": ")
-            type.format(q)
-          end
-        end
-
-        def pretty_print(q)
-          q.group(2, "(global", ")") do
-            SyntaxTree::RBS::Comment.maybe_pretty_print(q, comment)
-
-            q.breakable
-            q.text("name=")
-            q.pp(name)
-
-            q.breakable
-            q.text("type=")
-            q.pp(type)
-          end
-        end
-      end
-
-      class Interface
-        # Prints out an interface declaration, which looks like:
-        # interface _Foo end
-        def format(q)
-          SyntaxTree::RBS::Comment.maybe_format(q, comment)
-          SyntaxTree::RBS::Annotations.maybe_format(q, annotations)
-
-          q.group do
-            q.text("interface ")
-            SyntaxTree::RBS::NameAndTypeParams.new(self).format(q)
-            q.indent { SyntaxTree::RBS::Members.new(self).format(q) }
-            q.breakable(force: true)
-            q.text("end")
-          end
-        end
-
-        def pretty_print(q)
-          q.group(2, "(interface", ")") do
-            SyntaxTree::RBS::Comment.maybe_pretty_print(q, comment)
-            SyntaxTree::RBS::Annotations.maybe_pretty_print(q, annotations)
-
-            q.pp(SyntaxTree::RBS::NameAndTypeParams.new(self))
-
-            q.breakable
-            q.text("members=")
-            q.pp(members)
-          end
-        end
-      end
-
-      class Module
-        # Prints out a module declaration, which looks like:
-        # module Foo end
-        def format(q)
-          SyntaxTree::RBS::Comment.maybe_format(q, comment)
-          SyntaxTree::RBS::Annotations.maybe_format(q, annotations)
-
-          q.group do
-            q.text("module ")
-            SyntaxTree::RBS::NameAndTypeParams.new(self).format(q)
-
-            if self_types.any?
-              q.text(" : ")
-              q.seplist(self_types, -> { q.text(", ") }) do |self_type|
-                SyntaxTree::RBS::NameAndArgs.new(self_type).format(q)
-              end
-            end
-
-            q.indent { SyntaxTree::RBS::Members.new(self).format(q) }
-            q.breakable(force: true)
-            q.text("end")
-          end
-        end
-
-        def pretty_print(q)
-          q.group(2, "(module", ")") do
-            SyntaxTree::RBS::Comment.maybe_pretty_print(q, comment)
-            SyntaxTree::RBS::Annotations.maybe_pretty_print(q, annotations)
-
-            q.pp(SyntaxTree::RBS::NameAndTypeParams.new(self))
-
-            if self_types.any?
-              q.breakable
-              q.text("self_types=")
-              q.group(2, "[", "]") do
-                q.seplist(self_types) do |self_type|
-                  q.group(2, "(self-type", ")") do
-                    q.pp(SyntaxTree::RBS::NameAndArgs.new(self_type))
-                  end
-                end
-              end
-            end
-
-            q.breakable
-            q.text("members=")
-            q.pp(members)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/syntax_tree/rbs/members.rb

@@ -1,414 +0,0 @@
-# frozen_string_literal: true
-
-module SyntaxTree
-  module RBS
-    # Prints out an attr_* meta method, which looks like:
-    # attr_accessor foo: Foo
-    # attr_reader foo: Foo
-    # attr_writer foo: Foo
-    class Attribute
-      attr_reader :type, :node
-
-      def initialize(type, node)
-        @type = type
-        @node = node
-      end
-
-      def format(q)
-        q.group do
-          q.text("#{node.visibility} ") if node.visibility
-          q.text("attr_#{type} ")
-          q.text("self.") if node.kind == :singleton
-          q.text(node.name)
-
-          if node.ivar_name == false
-            q.text("()")
-          elsif node.ivar_name
-            q.text("(")
-            q.text(node.ivar_name)
-            q.text(")")
-          end
-
-          q.text(": ")
-          node.type.format(q)
-        end
-      end
-
-      def pretty_print(q)
-        if node.kind == :singleton
-          q.breakable
-          q.text("singleton")
-        end
-
-        q.breakable
-        q.text("name=")
-        q.pp(node.name)
-
-        if node.visibility
-          q.breakable
-          q.text("visibility=")
-          q.pp(node.visibility)
-        end
-
-        unless node.ivar_name.nil?
-          q.breakable
-          q.text("ivar_name=")
-          q.pp(node.ivar_name)
-        end
-
-        q.breakable
-        q.text("type=")
-        q.pp(node.type)
-      end
-    end
-  end
-end
-
-module RBS
-  module AST
-    module Members
-      class Alias
-        # Prints out an alias within a declaration, which looks like:
-        # alias foo bar
-        # alias self.foo self.bar
-        def format(q)
-          SyntaxTree::RBS::Comment.maybe_format(q, comment)
-          SyntaxTree::RBS::Annotations.maybe_format(q, annotations)
-
-          if kind == :singleton
-            q.text("alias self.")
-            q.text(new_name)
-            q.text(" self.")
-            q.text(old_name)
-          else
-            q.text("alias ")
-            q.text(new_name)
-            q.text(" ")
-            q.text(old_name)
-          end
-        end
-
-        def pretty_print(q)
-          q.group(2, "(alias", ")") do
-            SyntaxTree::RBS::Comment.maybe_pretty_print(q, comment)
-            SyntaxTree::RBS::Annotations.maybe_pretty_print(q, annotations)
-
-            if kind == :singleton
-              q.breakable
-              q.text("singleton")
-            end
-
-            q.breakable
-            q.text("new_name=")
-            q.pp(new_name)
-
-            q.breakable
-            q.text("old_name=")
-            q.pp(old_name)
-          end
-        end
-      end
-
-      class AttrAccessor
-        # Prints out an attr_accessor meta method, which looks like:
-        # attr_accessor foo: Foo
-        def format(q)
-          SyntaxTree::RBS::Comment.maybe_format(q, comment)
-          SyntaxTree::RBS::Annotations.maybe_format(q, annotations)
-          SyntaxTree::RBS::Attribute.new(:accessor, self).format(q)
-        end
-
-        def pretty_print(q)
-          q.group(2, "(attr-accessor", ")") do
-            SyntaxTree::RBS::Comment.maybe_pretty_print(q, comment)
-            SyntaxTree::RBS::Annotations.maybe_pretty_print(q, annotations)
-            q.pp(SyntaxTree::RBS::Attribute.new(:accessor, self))
-          end
-        end
-      end
-
-      class AttrReader
-        # Prints out an attr_reader meta method, which looks like:
-        # attr_reader foo: Foo
-        def format(q)
-          SyntaxTree::RBS::Comment.maybe_format(q, comment)
-          SyntaxTree::RBS::Annotations.maybe_format(q, annotations)
-          SyntaxTree::RBS::Attribute.new(:reader, self).format(q)
-        end
-
-        def pretty_print(q)
-          q.group(2, "(attr-reader", ")") do
-            SyntaxTree::RBS::Comment.maybe_pretty_print(q, comment)
-            SyntaxTree::RBS::Annotations.maybe_pretty_print(q, annotations)
-            q.pp(SyntaxTree::RBS::Attribute.new(:reader, self))
-          end
-        end
-      end
-
-      class AttrWriter
-        # Prints out an attr_writer meta method, which looks like:
-        # attr_writer foo: Foo
-        def format(q)
-          SyntaxTree::RBS::Comment.maybe_format(q, comment)
-          SyntaxTree::RBS::Annotations.maybe_format(q, annotations)
-          SyntaxTree::RBS::Attribute.new(:writer, self).format(q)
-        end
-
-        def pretty_print(q)
-          q.group(2, "(attr-writer", ")") do
-            SyntaxTree::RBS::Comment.maybe_pretty_print(q, comment)
-            SyntaxTree::RBS::Annotations.maybe_pretty_print(q, annotations)
-            q.pp(SyntaxTree::RBS::Attribute.new(:writer, self))
-          end
-        end
-      end
-
-      class ClassInstanceVariable
-        # Prints out a class instance variable member, which looks like:
-        # self.@foo: String
-        def format(q)
-          SyntaxTree::RBS::Comment.maybe_format(q, comment)
-
-          q.group do
-            q.text("self.")
-            q.text(name)
-            q.text(": ")
-            type.format(q)
-          end
-        end
-
-        def pretty_print(q)
-          q.group(2, "(class-instance-variable", ")") do
-            SyntaxTree::RBS::Comment.maybe_pretty_print(q, comment)
-
-            q.breakable
-            q.text("name=")
-            q.pp(name)
-          end
-        end
-      end
-
-      class ClassVariable
-        # Prints out a class variable member, which looks like:
-        # @@foo: String
-        def format(q)
-          SyntaxTree::RBS::Comment.maybe_format(q, comment)
-
-          q.group do
-            q.text(name)
-            q.text(": ")
-            type.format(q)
-          end
-        end
-
-        def pretty_print(q)
-          q.group(2, "(class-variable", ")") do
-            SyntaxTree::RBS::Comment.maybe_pretty_print(q, comment)
-
-            q.breakable
-            q.text("name=")
-            q.pp(name)
-          end
-        end
-      end
-
-      class Extend
-        # Prints out an extend, which looks like:
-        # extend Foo
-        def format(q)
-          SyntaxTree::RBS::Comment.maybe_format(q, comment)
-          SyntaxTree::RBS::Annotations.maybe_format(q, annotations)
-
-          q.group do
-            q.text("extend ")
-            SyntaxTree::RBS::NameAndArgs.new(self).format(q)
-          end
-        end
-
-        def pretty_print(q)
-          q.group(2, "(extend", ")") do
-            SyntaxTree::RBS::Comment.maybe_pretty_print(q, comment)
-            SyntaxTree::RBS::Annotations.maybe_pretty_print(q, annotations)
-            q.pp(SyntaxTree::RBS::NameAndArgs.new(self))
-          end
-        end
-      end
-
-      class Include
-        # Prints out an include, which looks like:
-        # include Foo
-        def format(q)
-          SyntaxTree::RBS::Comment.maybe_format(q, comment)
-          SyntaxTree::RBS::Annotations.maybe_format(q, annotations)
-
-          q.group do
-            q.text("include ")
-            SyntaxTree::RBS::NameAndArgs.new(self).format(q)
-          end
-        end
-
-        def pretty_print(q)
-          q.group(2, "(include", ")") do
-            SyntaxTree::RBS::Comment.maybe_pretty_print(q, comment)
-            SyntaxTree::RBS::Annotations.maybe_pretty_print(q, annotations)
-            q.pp(SyntaxTree::RBS::NameAndArgs.new(self))
-          end
-        end
-      end
-
-      class InstanceVariable
-        # Prints out an instance variable member, which looks like:
-        # @foo: String
-        def format(q)
-          SyntaxTree::RBS::Comment.maybe_format(q, comment)
-
-          q.group do
-            q.text(name)
-            q.text(": ")
-            type.format(q)
-          end
-        end
-
-        def pretty_print(q)
-          q.group(2, "(instance-variable", ")") do
-            SyntaxTree::RBS::Comment.maybe_pretty_print(q, comment)
-
-            q.breakable
-            q.text("name=")
-            q.pp(name)
-          end
-        end
-      end
-
-      class MethodDefinition
-        # Prints out a method definition, which looks like:
-        # def t: (T t) -> void
-        def format(q)
-          SyntaxTree::RBS::Comment.maybe_format(q, comment)
-          SyntaxTree::RBS::Annotations.maybe_format(q, annotations)
-
-          q.group do
-            q.text("#{visibility} ") if visibility
-            q.text("def ")
-
-            if kind == :singleton
-              q.text("self.")
-            elsif kind == :singleton_instance
-              q.text("self?.")
-            end
-
-            q.text(Parser::KEYWORDS.include?(name.to_s) ? "`#{name}`" : name)
-            q.text(":")
-
-            if types.length == 1 && !overload?
-              q.text(" ")
-              SyntaxTree::RBS::MethodSignature.new(types.first).format(q)
-            else
-              separator =
-                lambda do
-                  q.breakable
-                  q.text("| ")
-                end
-
-              q.group do
-                q.indent do
-                  q.breakable
-                  q.seplist(types, separator) do |type|
-                    SyntaxTree::RBS::MethodSignature.new(type).format(q)
-                  end
-
-                  if overload?
-                    separator.call
-                    q.text("...")
-                  end
-                end
-              end
-            end
-          end
-        end
-
-        def pretty_print(q)
-          q.group(2, "(method-definition", ")") do
-            SyntaxTree::RBS::Comment.maybe_pretty_print(q, comment)
-            SyntaxTree::RBS::Annotations.maybe_pretty_print(q, annotations)
-
-            q.breakable
-            q.text("kind=")
-            q.pp(kind)
-
-            q.breakable
-            q.text("name=")
-            q.pp(name)
-
-            if visibility
-              q.breakable
-              q.text("visibility=")
-              q.pp(visibility)
-            end
-
-            if overload?
-              q.breakable
-              q.text("overload")
-            end
-
-            q.breakable
-            q.text("types=")
-            q.group(2, "[", "]") do
-              q.breakable("")
-              q.seplist(types) do |type|
-                q.pp(SyntaxTree::RBS::MethodSignature.new(type))
-              end
-              q.breakable("")
-            end
-          end
-        end
-      end
-
-      class Prepend
-        # Prints out a prepend, which looks like:
-        # prepend Foo
-        def format(q)
-          SyntaxTree::RBS::Comment.maybe_format(q, comment)
-          SyntaxTree::RBS::Annotations.maybe_format(q, annotations)
-
-          q.group do
-            q.text("prepend ")
-            SyntaxTree::RBS::NameAndArgs.new(self).format(q)
-          end
-        end
-
-        def pretty_print(q)
-          q.group(2, "(prepend", ")") do
-            SyntaxTree::RBS::Comment.maybe_pretty_print(q, comment)
-            SyntaxTree::RBS::Annotations.maybe_pretty_print(q, annotations)
-            q.pp(SyntaxTree::RBS::NameAndArgs.new(self))
-          end
-        end
-      end
-
-      class Private
-        # Prints out a private declaration, which looks like:
-        # private
-        def format(q)
-          q.text("private")
-        end
-
-        def pretty_print(q)
-          q.text("(private)")
-        end
-      end
-
-      class Public
-        # Prints out a public declaration, which looks like:
-        # public
-        def format(q)
-          q.text("public")
-        end
-
-        def pretty_print(q)
-          q.text("(public)")
-        end
-      end
-    end
-  end
-end