rbs 1.2.0 → 1.3.2

data/bin/query-rdoc

@@ -1,103 +0,0 @@
-#!/usr/bin/env ruby
-
-require "rdoc"
-
-def store_for_class(name, stores:)
-  stores.find do |store|
-    store.find_class_named(name) || store.find_module_named(name)
-  end
-end
-
-def format_comment(comment)
-  out = RDoc::Markup::Document.new
-  out << comment
-  formatter = RDoc::Markup::ToMarkdown.new
-  out.accept(formatter)
-end
-
-def comment_for_constant(name, stores:)
-  *class_components, const_name = name.split(/::/)
-  class_name = class_components.join("::")
-
-  klass = store_for_class(class_name, stores: stores)&.yield_self {|store|
-    store.find_class_named(class_name) || store.find_module_named(class_name)
-  }
-
-  constant = klass.constants.find do |const|
-    const.name == const_name
-  end
-
-  if constant&.documented?
-    format_comment(constant.comment)
-  end
-end
-
-def comment_for_class(class_name, stores:)
-  klass = store_for_class(class_name, stores: stores)&.yield_self {|store|
-    store.find_class_named(class_name) || store.find_module_named(class_name)
-  }
-
-  if klass&.documented?
-    format_comment(klass.comment)
-  end
-end
-
-def comment_for_method(klass, method, stores:)
-  method = store_for_class(klass, stores: stores)&.load_method(klass, method)
-
-  if method&.documented?
-    out = RDoc::Markup::Document.new
-
-    out << method.comment
-
-    if method.arglists
-      out << RDoc::Markup::Heading.new(1, "arglists 💪👽🚨 << Delete this section")
-      arglists = method.arglists.chomp.split("\n").map {|line| line + "\n" }
-      out << RDoc::Markup::Verbatim.new(*arglists)
-    end
-
-    out.accept(RDoc::Markup::ToMarkdown.new)
-  end
-rescue RDoc::Store::MissingFileError
-  nil
-end
-
-if ARGV.empty?
-  puts 'query-rdoc [subject]'
-  puts "  subject ::= ClassName         (class, module, or constant)"
-  puts "            | ClassName.method  (singleton method)"
-  puts "            | ClassName#method  (instance method)"
-  exit
-end
-
-stores = []
-RDoc::RI::Paths.each true, true, false, false do |path, type|
-  STDERR.puts "Loading store from #{path}..."
-  store = RDoc::RI::Store.new(path, type)
-  store.load_all
-  stores << store
-end
-
-subject = ARGV[0]
-
-case
-when match = subject.match(/(?<constant_name>[^#]+)#(?<method_name>.+)/)
-  STDERR.puts "Finding instance method #{match[:constant_name]} # #{match[:method_name]} ..."
-  comment = comment_for_method(match[:constant_name], "##{match[:method_name]}", stores: stores)
-when match = subject.match(/(?<constant_name>[^.]+)\.(?<method_name>.+)/)
-  STDERR.puts "Finding singleton method #{match[:constant_name]} . #{match[:method_name]} ..."
-  comment = comment_for_method(match[:constant_name], "::#{match[:method_name]}", stores: stores)
-else
-  STDERR.puts "Finding class/module/constant #{subject} ..."
-  comment = comment_for_class(subject, stores: stores) || comment_for_constant(subject, stores: stores)
-end
-
-if comment
-  STDERR.puts "Printing document..."
-  comment.each_line do |line|
-    puts "# #{line}"
-  end
-else
-  STDERR.puts "Nothing to print; failed to query the document..."
-  exit 1
-end

data/bin/rbs-prof

@@ -1,9 +0,0 @@
-#!/usr/bin/env ruby
-
-require "stackprof"
-
-out = ENV["RBS_STACKPROF_OUT"] || 'tmp/stackprof-cpu-rbs.dump'
-
-StackProf.run(mode: :cpu, out: out, raw: true) do
-  load File.join(__dir__, "../exe/rbs")
-end

data/bin/run_in_md.rb

@@ -1,49 +0,0 @@
-require "tmpdir"
-require "shellwords"
-
-ARGV.each do |path|
-  puts "~~~~~~~ Checking #{path} ~~~~~~"
-  content = File.read(path)
-
-  snippets = []
-  lines = []
-  content.lines.each.with_index do |line, index|
-    case line
-    when /run-start:/
-      lines = [[line, index+1]]
-    when /run-end/
-      lines << [line, index+1]
-      snippets << lines
-      lines = []
-    else
-      lines << [line, index+1]
-    end
-  end
-
-  snippets.each do |lines|
-    puts ">>> Code detected: "
-    hd, _, *code_lines, _, _ = lines
-
-    head = hd[0]
-    head.gsub!(/^<!-- +/, "").gsub!(/ +-->$/, "")
-    _,name,command = head.split(/:/)
-
-    puts "# command=#{Shellwords.split(command).inspect}"
-    puts "# name=#{name}"
-    puts code_lines.map {|line, i| "#{"%4d" % i}  #{line}" }.join
-
-    code = code_lines.map(&:first).join
-
-    puts ">>> Running..."
-    Dir.mktmpdir do |dir|
-      File.write(File.join(dir, name), code)
-      pid = spawn({ "BUNDLE_GEMFILE" => File.join(__dir__, "../Gemfile") },
-                  *Shellwords.split(command),
-                  chdir: dir)
-
-      _, status = Process.waitpid2(pid)
-
-      status.success? or raise "Failed to execute code: #{code_lines.join}"
-    end
-  end
-end

data/bin/setup

@@ -1,8 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-IFS=$'\n\t'
-set -vx
-
-bundle install --jobs 4 --retry 3
-
-# Do any other automated setup that you need to do here

data/bin/sort

@@ -1,89 +0,0 @@
-#!/usr/bin/env ruby
-
-require "bundler/setup"
-require "rbs"
-
-Members = RBS::AST::Members
-
-def group(member)
-  case member
-  when Members::Include, Members::Extend, Members::Prepend
-    0
-  when Members::ClassVariable
-    -3
-  when Members::ClassInstanceVariable
-    -2
-  when Members::InstanceVariable
-    -1
-  when Members::AttrAccessor, Members::AttrWriter, Members::AttrReader
-    2
-  when Members::MethodDefinition
-    if member.singleton?
-      if member.name == :new
-        0.4
-      else
-        1
-      end
-    else
-      if member.name == :initialize
-        0.5
-      else
-        3
-      end
-    end
-  when Members::Alias
-    if member.singleton?
-      1
-    else
-      3
-    end
-  when Members::Private, Members::Public
-    -4
-  end
-end
-
-def key(member)
-  case member
-  when Members::Include, Members::Extend, Members::Prepend
-    member.name.to_s
-  when Members::ClassVariable, Members::ClassInstanceVariable, Members::InstanceVariable
-    member.name.to_s
-  when Members::AttrAccessor, Members::AttrWriter, Members::AttrReader
-    member.name.to_s
-  when Members::MethodDefinition
-    member.name.to_s
-  when Members::Alias
-    member.new_name.to_s
-  else
-    1
-  end
-end
-
-ARGV.map {|f| Pathname(f) }.each do |path|
-  puts "Opening #{path}..."
-
-  buffer = RBS::Buffer.new(name: path, content: path.read)
-  sigs = RBS::Parser.parse_signature(buffer)
-
-  sigs.each do |sig|
-    case sig
-    when RBS::AST::Declarations::Class, RBS::AST::Declarations::Module, RBS::AST::Declarations::Interface
-      sig.members.sort! do |m1, m2|
-        group1 = group(m1)
-        group2 = group(m2)
-
-        if group1 == group2
-          key(m1) <=> key(m2)
-        else
-          group1 <=> group2
-        end
-      end
-    end
-  end
-
-  puts "Writing #{path}..."
-  path.open('w') do |out|
-    writer = RBS::Writer.new(out: out)
-    writer.write sigs
-  end
-end

data/bin/steep

@@ -1,4 +0,0 @@
-#!/bin/sh
-
-GEMFILE=$(cd $(dirname $0); pwd)/../steep/Gemfile
-bundle exec --gemfile=${GEMFILE} steep $*

data/bin/test_runner.rb

@@ -1,29 +0,0 @@
-#!/usr/bin/env ruby
-
-$LOAD_PATH << File.join(__dir__, "../lib")
-
-require "set"
-
-IS_LATEST_RUBY = Gem::Version.new(RUBY_VERSION).yield_self do |ruby_version|
-  Gem::Version.new('3.0.0') <= ruby_version && ruby_version < Gem::Version.new('3.1.0')
-end
-
-unless IS_LATEST_RUBY
-  STDERR.puts "⚠️⚠️⚠️⚠️ stdlib test assumes Ruby 3.0 but RUBY_VERSION==#{RUBY_VERSION} ⚠️⚠️⚠️⚠️"
-end
-
-KNOWN_FAILS = %w(dbm).map do |lib|
-  /cannot load such file -- #{lib}/
-end
-
-ARGV.each do |arg|
-  begin
-    load arg
-  rescue LoadError => exn
-    if KNOWN_FAILS.any? {|pat| pat =~ exn.message }
-      STDERR.puts "Loading #{arg} failed, ignoring it: #{exn.inspect}"
-    else
-      raise
-    end
-  end
-end