class RBS::Writer

attribute (kind, attr)

(:reader | :writer | :accessor, AST::Members::Attribute) → void

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/lib/rbs/writer.rb, line 366
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

format_annotation (annotation)

(AST::Annotation) → String

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/lib/rbs/writer.rb, line 42
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

indent (size = 2) { || ... }

(?Integer size) { () → void } → void

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/lib/rbs/writer.rb, line 23
def indent(size = 2)
  indentation.push(" " * size)
  yield
ensure
  indentation.pop
end

Increases the indentation and yields the block.

method_name (name)

(Symbol) → String

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/lib/rbs/writer.rb, line 293
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

name_and_args (name, args)

(TypeName, Array[Types::t]) → String?

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/lib/rbs/writer.rb, line 219
def name_and_args(name, args)
  if name && args
    if args.empty?
      "#{name}"
    else
      "#{name}[#{args.join(", ")}]"
    end
  end
end

name_and_params (name, params)

(TypeName, Array[AST::TypeParam]) → String?

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/lib/rbs/writer.rb, line 207
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

prefix ()

() → String

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/lib/rbs/writer.rb, line 30
def prefix
  indentation.join()
end

Returns the current indentation of lines.

preserve! (preserve: true)

(?preserve: bool) → self

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/lib/rbs/writer.rb, line 18
def preserve!(preserve: true)
  @preserve = preserve
  self
end

preserve? ()

() → bool

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/lib/rbs/writer.rb, line 14
def preserve?
  @preserve
end

preserve_empty_line (prev, decl)

(_Located?, _Located) → void

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/lib/rbs/writer.rb, line 396
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

put_lines (lines, leading_spaces:)

(String, leading_spaces: Integer) → void

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/lib/rbs/writer.rb, line 229
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

Prints a (possibly) multi-line string.

Drops leading_spaces of spaces at the beginning of each line.

put_lines(<<TEXT, leading_spaces: 0)
Hello
  world!
TEXT

# Outputs
# Hello
#   world!

put_lines(<<TEXT, leading_spaces: 2)
Hello
  world!
TEXT

# Outputs
# Hello
# world!

This is for Location#source. The #source returns the text spans from the beginning to end of the element. It will look like the following.

module Foo
  type t = Integer     # the definition of `t` starts from line=2, column=2
         | String
         | :false      # the definition of `t` ends from line=4, column=17
end

The expected output will be something like:

type t = Integer       # Extracted from `Foo` definition and keeps the line breaks
       | String
       | :false

And it can be done with a #put_lines(source, leading_spaces: 2) call.

puts (string = "")

(?String) → void

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/lib/rbs/writer.rb, line 34
def puts(string = "")
  if string.size > 0
    @out.puts("#{prefix}#{string}")
  else
    @out.puts
  end
end

Prints a string. Automatically appends the prefix and newline at the end.

write (contents)

(Array[AST::Declarations::t | AST::Directives::t]) → void

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/lib/rbs/writer.rb, line 79
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

Output the array of declarations. It automatically inserts empty lines between the declarations.

write_alias

(AST::Declarations::TypeAlias) → void

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/sig/writer.rbs, line 113
def write_alias: (AST::Declarations::TypeAlias) -> void

write_annotation (annotations)

(Array[AST::Annotation]) → void

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/lib/rbs/writer.rb, line 60
def write_annotation(annotations)
  annotations.each do |annotation|
    puts format_annotation(annotation)
  end
end

write_comment (comment)

(AST::Comment?) → void

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/lib/rbs/writer.rb, line 66
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

write_decl (decl)

(AST::Declarations::t) → void

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/lib/rbs/writer.rb, line 119
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

write_def (member)

(AST::Members::MethodDefinition) → void

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/lib/rbs/writer.rb, line 314
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

write_loc_source (located) { || ... }

(_Located) { () → void } → void

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/lib/rbs/writer.rb, line 306
def write_loc_source(located)
  if preserve? && loc = located.location
    put_lines(loc.source, leading_spaces: loc.start_column)
  else
    yield
  end
end

write_member (member)

(AST::Declarations::Module::member) → void

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/lib/rbs/writer.rb, line 239
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

write_use_directive (dir)

(AST::Directives::Use) → void

Source

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.0.3/lib/rbs/writer.rb, line 102
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

Attributes

Public Class Methods

Public Instance Methods