rbs-relaxed 3.9.0.1

data/lib/rbs/writer.rb

@@ -0,0 +1,424 @@
+# frozen_string_literal: true
+
+module RBS
+  class Writer
+    attr_reader :out
+    attr_reader :indentation
+
+    def initialize(out:)
+      @out = out
+      @indentation = []
+      @preserve = false
+    end
+
+    def preserve?
+      @preserve
+    end
+
+    def preserve!(preserve: true)
+      @preserve = preserve
+      self
+    end
+
+    def indent(size = 2)
+      indentation.push(" " * size)
+      yield
+    ensure
+      indentation.pop
+    end
+
+    def prefix
+      indentation.join()
+    end
+
+    def puts(string = "")
+      if string.size > 0
+        @out.puts("#{prefix}#{string}")
+      else
+        @out.puts
+      end
+    end
+
+    def format_annotation(annotation)
+      string = annotation.string
+      case
+      when string !~ /\}/
+        "%a{#{string}}"
+      when string !~ /\)/
+        "%a(#{string})"
+      when string !~ /\]/
+        "%a[#{string}]"
+      when string !~ /\>/
+        "%a<#{string}>"
+      when string !~ /\|/
+        "%a|#{string}|"
+      else
+        raise
+      end
+    end
+
+    def write_annotation(annotations)
+      annotations.each do |annotation|
+        puts format_annotation(annotation)
+      end
+    end
+
+    def write_comment(comment)
+      if comment
+        comment.string.lines.each do |line|
+          line = line.chomp
+          unless line.empty?
+            puts "# #{line}"
+          else
+            puts "#"
+          end
+        end
+      end
+    end
+
+    def write(contents)
+      resolves = contents.select { _1.is_a?(AST::Directives::ResolveTypeNames) } #: Array[AST::Directives::ResolveTypeNames]
+      uses = contents.select {|c| c.is_a?(AST::Directives::Use) } #: Array[AST::Directives::Use]
+      decls = contents.select {|c| c.is_a?(AST::Declarations::Base) } #: Array[AST::Declarations::t]
+
+      if first_resolves = resolves.first
+        puts "# resolve-type-names: #{first_resolves.value}"
+        puts
+      end
+
+      uses.each do |dir|
+        write_use_directive(dir)
+      end
+      puts unless uses.empty?
+
+      [nil, *decls].each_cons(2) do |prev, decl|
+        raise unless decl
+
+        preserve_empty_line(prev, decl)
+        write_decl decl
+      end
+    end
+
+    def write_use_directive(dir)
+      clauses = dir.clauses.map do |clause|
+        case clause
+        when AST::Directives::Use::SingleClause
+          if clause.new_name
+            "#{clause.type_name} as #{clause.new_name}"
+          else
+            "#{clause.type_name}"
+          end
+        when AST::Directives::Use::WildcardClause
+          "#{clause.namespace}*"
+        end
+      end
+
+      puts "use #{clauses.join(", ")}"
+    end
+
+    def write_decl(decl)
+      case decl
+      when AST::Declarations::Class
+        super_class = if super_class = decl.super_class
+                        " < #{name_and_args(super_class.name, super_class.args)}"
+                      end
+        write_comment decl.comment
+        write_annotation decl.annotations
+        puts "class #{name_and_params(decl.name, decl.type_params)}#{super_class}"
+
+        indent do
+          [nil, *decl.members].each_cons(2) do |prev, member|
+            raise unless member
+
+            preserve_empty_line prev, member
+            write_member member
+          end
+        end
+
+        puts "end"
+
+      when AST::Declarations::Module
+        self_type = unless decl.self_types.empty?
+                      " : #{decl.self_types.join(", ")}"
+                    end
+
+        write_comment decl.comment
+        write_annotation decl.annotations
+
+        puts "module #{name_and_params(decl.name, decl.type_params)}#{self_type}"
+
+        indent do
+          decl.members.each.with_index do |member, index|
+            if index > 0
+              puts
+            end
+            write_member member
+          end
+        end
+
+        puts "end"
+      when AST::Declarations::Constant
+        write_comment decl.comment
+        puts "#{decl.name}: #{decl.type}"
+
+      when AST::Declarations::Global
+        write_comment decl.comment
+        puts "#{decl.name}: #{decl.type}"
+
+      when AST::Declarations::TypeAlias
+        write_comment decl.comment
+        write_annotation decl.annotations
+        write_loc_source(decl) {
+          puts "type #{name_and_params(decl.name, decl.type_params)} = #{decl.type}"
+        }
+
+      when AST::Declarations::ClassAlias
+        write_comment decl.comment
+        write_loc_source(decl) {
+          puts "class #{decl.new_name} = #{decl.old_name}"
+        }
+
+      when AST::Declarations::ModuleAlias
+        write_comment decl.comment
+        write_loc_source(decl) {
+          puts "module #{decl.new_name} = #{decl.old_name}"
+        }
+
+      when AST::Declarations::Interface
+        write_comment decl.comment
+        write_annotation decl.annotations
+
+        puts "interface #{name_and_params(decl.name, decl.type_params)}"
+
+        indent do
+          decl.members.each.with_index do |member, index|
+            if index > 0
+              puts
+            end
+            write_member member
+          end
+        end
+
+        puts "end"
+
+      end
+    end
+
+    def name_and_params(name, params)
+      if params.empty?
+        "#{name}"
+      else
+        ps = params.each.map do |param|
+          param.to_s
+        end
+
+        "#{name}[#{ps.join(", ")}]"
+      end
+    end
+
+    def name_and_args(name, args)
+      if name && args
+        if args.empty?
+          "#{name}"
+        else
+          "#{name}[#{args.join(", ")}]"
+        end
+      end
+    end
+
+    def put_lines(lines, leading_spaces:)
+      lines.each_line.with_index do |line, index|
+        line.chomp!
+        line.rstrip!
+        line.sub!(/\A( {,#{leading_spaces}})/, '') if index > 0
+
+        puts line
+      end
+    end
+
+    def write_member(member)
+      case member
+      when AST::Members::Include
+        write_comment member.comment
+        write_annotation member.annotations
+        puts "include #{name_and_args(member.name, member.args)}"
+      when AST::Members::Extend
+        write_comment member.comment
+        write_annotation member.annotations
+        puts "extend #{name_and_args(member.name, member.args)}"
+      when AST::Members::Prepend
+        write_comment member.comment
+        write_annotation member.annotations
+        puts "prepend #{name_and_args(member.name, member.args)}"
+      when AST::Members::AttrAccessor
+        write_comment member.comment
+        write_annotation member.annotations
+        puts "#{attribute(:accessor, member)}"
+      when AST::Members::AttrReader
+        write_comment member.comment
+        write_annotation member.annotations
+        puts "#{attribute(:reader, member)}"
+      when AST::Members::AttrWriter
+        write_comment member.comment
+        write_annotation member.annotations
+        puts "#{attribute(:writer, member)}"
+      when AST::Members::Public
+        puts "public"
+      when AST::Members::Private
+        puts "private"
+      when AST::Members::Alias
+        write_comment member.comment
+        write_annotation member.annotations
+        new_name = member.singleton? ? "self.#{method_name(member.new_name)}" : method_name(member.new_name)
+        old_name = member.singleton? ? "self.#{method_name(member.old_name)}" : method_name(member.old_name)
+        puts "alias #{new_name} #{old_name}"
+      when AST::Members::InstanceVariable
+        write_comment member.comment
+        puts "#{member.name}: #{member.type}"
+      when AST::Members::ClassInstanceVariable
+        write_comment member.comment
+        puts "self.#{member.name}: #{member.type}"
+      when AST::Members::ClassVariable
+        write_comment member.comment
+        puts "#{member.name}: #{member.type}"
+      when AST::Members::MethodDefinition
+        write_comment member.comment
+        write_annotation member.annotations
+        write_loc_source(member) { write_def member }
+      else
+        write_decl member
+      end
+    end
+
+    def method_name(name)
+      s = name.to_s
+
+      case s
+      when /\A(_?)[A-Za-z_]\w*(\?|!|=)?\Z/
+        s
+      when *%w(|  ^  &  <=>  ==  ===  =~  >   >=  <   <=   <<  >> +  -  *  /  %   **   ~   +@  -@  []  []=  ` ! != !~)
+        s
+      else
+        "`#{s}`"
+      end
+    end
+
+    def write_loc_source(located)
+      if preserve? && loc = located.location
+        put_lines(loc.source, leading_spaces: loc.start_column)
+      else
+        yield
+      end
+    end
+
+    def write_def(member)
+      visibility =
+        case member.visibility
+        when :public
+          "public "
+        when :private
+          "private "
+        else
+          ""
+        end
+
+      name = case member.kind
+             when :instance
+               "#{method_name(member.name)}"
+             when :singleton_instance
+               "self?.#{method_name(member.name)}"
+             when :singleton
+               "self.#{method_name(member.name)}"
+             end
+
+      string = +""
+
+      prefix = "#{visibility}def #{name}:"
+      padding = " " * (prefix.size-1)
+
+      string << prefix
+
+      member.overloads.each.with_index do |overload, index|
+        if index > 0
+          string << padding
+          string << "|"
+        end
+
+        overload.annotations.each do |annotation|
+          string << " #{format_annotation(annotation)}"
+        end
+        string << " #{overload.method_type}\n"
+      end
+
+      if member.overloading?
+        if member.overloads.size > 0
+          string << padding
+          string << "|"
+        end
+        string << " ...\n"
+      end
+
+      string.each_line do |line|
+        puts line.chomp
+      end
+    end
+
+    def attribute(kind, attr)
+      visibility =
+        case attr.visibility
+        when :public
+          "public "
+        when :private
+          "private "
+        else
+          ""
+        end
+
+      var = case attr.ivar_name
+            when nil
+              ""
+            when false
+              "()"
+            else
+              "(#{attr.ivar_name})"
+            end
+
+      receiver = case attr.kind
+                 when :singleton
+                   "self."
+                 when :instance
+                   ""
+                 end
+
+      "#{visibility}attr_#{kind} #{receiver}#{method_name(attr.name)}#{var}: #{attr.type}"
+    end
+
+    def preserve_empty_line(prev, decl)
+      # @type var decl: _Located
+
+      return unless prev
+
+      if (_ = decl).respond_to?(:comment)
+        if comment = (_ = decl).comment
+          decl = comment
+        end
+      end
+
+      prev_loc = prev.location
+      decl_loc = decl.location
+
+      if prev_loc && decl_loc
+        prev_end_line = prev_loc.end_line
+        start_line = decl_loc.start_line
+
+        if start_line - prev_end_line > 1
+          puts
+        end
+      else
+        # When the signature is not constructed by the parser,
+        # it always inserts an empty line.
+        puts
+      end
+    end
+  end
+end

data/lib/rbs.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "rbs/version"
+
+require "set"
+require "json"
+require "pathname"
+require "pp"
+require "ripper"
+require "logger"
+require "tsort"
+require "strscan"
+
+require "rbs/errors"
+require "rbs/buffer"
+require "rbs/namespace"
+require "rbs/type_name"
+require "rbs/types"
+require "rbs/method_type"
+require "rbs/file_finder"
+require "rbs/ast/type_param"
+require "rbs/ast/directives"
+require "rbs/ast/declarations"
+require "rbs/ast/members"
+require "rbs/ast/annotation"
+require "rbs/ast/visitor"
+require "rbs/environment"
+require "rbs/environment/use_map"
+require "rbs/environment_loader"
+require "rbs/builtin_names"
+require "rbs/definition"
+require "rbs/definition_builder"
+require "rbs/definition_builder/ancestor_builder"
+require "rbs/definition_builder/method_builder"
+require "rbs/diff"
+require "rbs/variance_calculator"
+require "rbs/substitution"
+require "rbs/constant"
+require "rbs/resolver/constant_resolver"
+require "rbs/resolver/type_name_resolver"
+require "rbs/ast/comment"
+require "rbs/writer"
+require "rbs/prototype/helpers"
+require "rbs/prototype/rbi"
+require "rbs/prototype/rb"
+require "rbs/prototype/runtime"
+require "rbs/prototype/node_usage"
+require "rbs/environment_walker"
+require "rbs/vendorer"
+require "rbs/validator"
+require "rbs/factory"
+require "rbs/repository"
+require "rbs/subtractor"
+require "rbs/ancestor_graph"
+require "rbs/locator"
+require "rbs/type_alias_dependency"
+require "rbs/type_alias_regularity"
+require "rbs/collection"
+
+require "rbs_extension"
+require "rbs/parser_aux"
+require "rbs/location_aux"
+
+module RBS
+  class <<self
+    attr_reader :logger_level
+    attr_reader :logger_output
+
+    def logger
+      @logger ||= Logger.new(logger_output || STDERR, level: logger_level || Logger::WARN, progname: "rbs")
+    end
+
+    def logger_output=(val)
+      @logger = nil
+      @logger_output = val
+    end
+
+    def logger_level=(level)
+      @logger_level = level
+      @logger = nil
+    end
+
+    def print_warning()
+      @warnings ||= Set[]
+
+      message = yield()
+
+      unless @warnings.include?(message)
+        @warnings << message
+        logger.warn { message }
+      end
+    end
+  end
+end

data/lib/rdoc/discover.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+begin
+  gem 'rdoc', '~> 6.4'
+  require 'rdoc_plugin/parser'
+  module RDoc
+    class Parser
+      class RBS < Parser
+        parse_files_matching(/\.rbs$/)
+        def scan
+          ::RBS::RDocPlugin::Parser.new(@top_level, @content).scan
+        end
+      end
+    end
+  end
+rescue Gem::LoadError
+    # Error :sad:
+rescue Exception
+    # Exception :sad:
+end

data/lib/rdoc_plugin/parser.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require 'rbs'
+
+module RBS
+  module RDocPlugin
+    class Parser
+
+      attr_accessor :top_level, :content
+
+      def initialize(top_level, content)
+        @top_level = top_level
+        @content = content
+      end
+
+      def scan
+        _, _, decls = ::RBS::Parser.parse_signature(@content)
+        decls.each do |decl|
+          parse_member(decl: decl, context: @top_level)
+        end
+        @top_level
+      end
+
+      def parse_member(decl:, context:, outer_name: nil)
+        case decl
+        when ::RBS::AST::Declarations::Class
+          parse_class_decl(decl: decl, context: context, outer_name: outer_name)
+        when ::RBS::AST::Declarations::Module
+          parse_module_decl(decl: decl, context: context, outer_name: outer_name)
+        when ::RBS::AST::Declarations::Constant
+          context = @top_level.find_class_or_module outer_name.to_s if outer_name
+          parse_constant_decl(decl: decl, context: context, outer_name: outer_name)
+        when ::RBS::AST::Declarations::Interface
+          parse_module_decl(decl: decl, context: context, outer_name: outer_name)
+        when ::RBS::AST::Members::MethodDefinition
+          context = @top_level.find_class_or_module outer_name.to_s if outer_name
+          parse_method_decl(decl: decl, context: context, outer_name: outer_name)
+        when ::RBS::AST::Members::Alias
+          context = @top_level.find_class_or_module outer_name.to_s if outer_name
+          parse_method_alias_decl(decl: decl, context: context, outer_name: outer_name)
+        when ::RBS::AST::Members::AttrReader, ::RBS::AST::Members::AttrWriter, ::RBS::AST::Members::AttrAccessor
+          context = @top_level.find_class_or_module outer_name.to_s if outer_name
+          parse_attr_decl(decl: decl, context: context, outer_name: outer_name)
+        when ::RBS::AST::Members::Include
+          context = @top_level.find_class_or_module outer_name.to_s if outer_name
+          parse_include_decl(decl: decl, context: context, outer_name: outer_name)
+        when ::RBS::AST::Members::Extend
+          context = @top_level.find_class_or_module outer_name.to_s if outer_name
+          parse_extend_decl(decl: decl, context: context, outer_name: outer_name)
+        end
+      end
+
+      def parse_class_decl(decl:, context:, outer_name: nil)
+        full_name = fully_qualified_name(outer_name: outer_name, decl: decl)
+        klass = context.add_class(RDoc::NormalClass, full_name.to_s, decl.super_class&.name&.to_s || "::Object")
+        klass.add_comment(construct_comment(context: context, comment: comment_string(decl)), context) if decl.comment
+        decl.members.each { |member| parse_member(decl: member, context: context, outer_name: full_name) }
+      end
+
+      def parse_module_decl(decl:, context:, outer_name: nil)
+        full_name = fully_qualified_name(outer_name: outer_name, decl: _ = decl)
+        kmodule = context.add_module(RDoc::NormalModule, full_name.to_s)
+        kmodule.add_comment(construct_comment(context: context, comment: comment_string(decl)), context) if decl.comment
+        decl.members.each { |member| parse_member(decl: member, context: context, outer_name: full_name) }
+      end
+
+      def parse_constant_decl(decl:, context:, outer_name: nil)
+        comment = decl.comment ? construct_comment(context: context, comment: comment_string(decl)) : nil
+        constant = RDoc::Constant.new(decl.name.to_s, decl.type.to_s, comment)
+        context.add_constant(constant)
+      end
+
+      def parse_method_decl(decl:, context:, outer_name: nil)
+        method = RDoc::AnyMethod.new(nil, decl.name.to_s)
+        method.singleton = decl.singleton?
+        method.visibility = decl.visibility
+        method.call_seq = decl.overloads.map {|overload| "#{decl.name.to_s}#{overload.method_type.to_s}" }.join("\n")
+        if loc = decl.location
+          method.start_collecting_tokens
+          method.add_token({ line_no: 1, char_no: 1, kind: :on_comment, text: "# File #{@top_level.relative_name}, line(s) #{loc.start_line}:#{loc.end_line}\n" })
+          method.add_token({ line_no: 1, char_no: 1, text: loc.source })
+          method.line = loc.start_line
+        end
+        method.comment = construct_comment(context: context, comment: comment_string(decl)) if decl.comment
+        context.add_method(method)
+      end
+
+      def parse_method_alias_decl(decl:, context:, outer_name: nil)
+        alias_def = RDoc::Alias.new(nil, decl.old_name.to_s, decl.new_name.to_s, nil, decl.kind == :singleton)
+        alias_def.comment = construct_comment(context: context, comment: comment_string(decl)) if decl.comment
+        context.add_alias(alias_def)
+      end
+
+      def parse_attr_decl(decl:, context:, outer_name: nil)
+        rw = case decl
+             when ::RBS::AST::Members::AttrReader
+               'R'
+             when ::RBS::AST::Members::AttrWriter
+               'W'
+             when ::RBS::AST::Members::AttrAccessor
+               'RW'
+             end
+        attribute = RDoc::Attr.new(nil, decl.name.to_s, rw, nil, decl.kind == :singleton)
+        attribute.visibility = decl.visibility
+        attribute.comment = construct_comment(context: context, comment: comment_string(decl)) if decl.comment
+        context.add_attribute(attribute)
+      end
+
+      def parse_include_decl(decl:, context:, outer_name: nil)
+        name = decl.name.to_s
+        outer_names = outer_name ? outer_name.to_s.split("::") : [] #: Array[String]
+        qualified_name = ''
+        outer_names.each do |namespace|
+          qualified_name += namespace
+          if (module_name = @top_level.find_module_named((qualified_name += "::") + name))
+            name = module_name.full_name
+            break
+          end
+        end
+        include_decl = RDoc::Include.new(name, nil)
+        include_decl.comment = construct_comment(context: context, comment: comment_string(decl)) if decl.comment
+        context.add_include(include_decl)
+      end
+
+      def parse_extend_decl(decl:, context:, outer_name: nil)
+        name = decl.name.to_s
+        outer_names = outer_name ? outer_name.to_s.split("::") : [] #: Array[String]
+        qualified_name = ''
+        outer_names.each do |namespace|
+          qualified_name += namespace
+          if (module_name = @top_level.find_module_named((qualified_name += "::") + name))
+            name = module_name.full_name
+            break
+          end
+        end
+        extend_decl = RDoc::Extend.new(name, nil)
+        extend_decl.comment = construct_comment(context: context, comment: comment_string(decl)) if decl.comment
+        context.add_extend(extend_decl)
+      end
+
+      private
+
+      def construct_comment(context:, comment:)
+        comment = RDoc::Comment.new(comment, context)
+        comment.format = "markdown"
+        comment
+      end
+
+      def comment_string(with_comment)
+        comment = with_comment.comment or raise "Object with `#comment` returning a object is expected"
+        comment.string
+      end
+
+      def fully_qualified_name(outer_name:, decl:)
+        if outer_name
+          (outer_name + decl.name)
+        else
+          decl.name
+        end
+      end
+    end
+  end
+end