rbs 1.5.1 → 1.7.0.beta.1

data/ext/rbs/extension/ruby_objs.h

@@ -0,0 +1,46 @@
+#ifndef RBS__RUBY_OBJS_H
+#define RBS__RUBY_OBJS_H
+
+#include "ruby.h"
+
+VALUE rbs_alias(VALUE typename, VALUE location);
+VALUE rbs_ast_annotation(VALUE string, VALUE location);
+VALUE rbs_ast_comment(VALUE string, VALUE location);
+VALUE rbs_ast_decl_alias(VALUE name, VALUE type, VALUE annotations, VALUE location, VALUE comment);
+VALUE rbs_ast_decl_class_super(VALUE name, VALUE args, VALUE location);
+VALUE rbs_ast_decl_class(VALUE name, VALUE type_params, VALUE super_class, VALUE members, VALUE annotations, VALUE location, VALUE comment);
+VALUE rbs_ast_decl_constant(VALUE name, VALUE type, VALUE location, VALUE comment);
+VALUE rbs_ast_decl_global(VALUE name, VALUE type, VALUE location, VALUE comment);
+VALUE rbs_ast_decl_interface(VALUE name, VALUE type_params, VALUE members, VALUE annotations, VALUE location, VALUE comment);
+VALUE rbs_ast_decl_module_self(VALUE name, VALUE args, VALUE location);
+VALUE rbs_ast_decl_module_type_params_param(VALUE name, VALUE variance, VALUE skip_validation, VALUE location);
+VALUE rbs_ast_decl_module_type_params();
+VALUE rbs_ast_decl_module(VALUE name, VALUE type_params, VALUE self_types, VALUE members, VALUE annotations, VALUE location, VALUE comment);
+VALUE rbs_ast_members_alias(VALUE new_name, VALUE old_name, VALUE kind, VALUE annotations, VALUE location, VALUE comment);
+VALUE rbs_ast_members_attribute(VALUE klass, VALUE name, VALUE type, VALUE ivar_name, VALUE kind, VALUE annotations, VALUE location, VALUE comment);
+VALUE rbs_ast_members_method_definition(VALUE name, VALUE kind, VALUE types, VALUE annotations, VALUE location, VALUE comment, VALUE overload);
+VALUE rbs_ast_members_mixin(VALUE klass, VALUE name, VALUE args, VALUE annotations, VALUE location, VALUE comment);
+VALUE rbs_ast_members_variable(VALUE klass, VALUE name, VALUE type, VALUE location, VALUE comment);
+VALUE rbs_ast_members_visibility(VALUE klass, VALUE location);
+VALUE rbs_base_type(VALUE klass, VALUE location);
+VALUE rbs_block(VALUE type, VALUE required);
+VALUE rbs_class_instance(VALUE typename, VALUE type_args, VALUE location);
+VALUE rbs_class_singleton(VALUE typename, VALUE location);
+VALUE rbs_function_param(VALUE type, VALUE name, VALUE location);
+VALUE rbs_function(VALUE required_positional_params, VALUE optional_positional_params, VALUE rest_positional_params, VALUE trailing_positional_params, VALUE required_keywords, VALUE optional_keywords, VALUE rest_keywords, VALUE return_type);
+VALUE rbs_interface(VALUE typename, VALUE type_args, VALUE location);
+VALUE rbs_intersection(VALUE types, VALUE location);
+VALUE rbs_literal(VALUE literal, VALUE location);
+VALUE rbs_method_type(VALUE type_params, VALUE type, VALUE block, VALUE location);
+VALUE rbs_namespace(VALUE path, VALUE absolute);
+VALUE rbs_optional(VALUE type, VALUE location);
+VALUE rbs_proc(VALUE function, VALUE block, VALUE location);
+VALUE rbs_record(VALUE fields, VALUE location);
+VALUE rbs_tuple(VALUE types, VALUE location);
+VALUE rbs_type_name(VALUE namespace, VALUE name);
+VALUE rbs_union(VALUE types, VALUE location);
+VALUE rbs_variable(VALUE name, VALUE location);
+
+void pp(VALUE object);
+
+#endif

data/ext/rbs/extension/unescape.c

@@ -0,0 +1,65 @@
+#include "rbs_extension.h"
+
+static VALUE REGEXP = 0;
+static VALUE HASH = 0;
+
+static const char *regexp_str = "\\\\[abefnrstv\"]";
+
+static ID gsub = 0;
+
+void rbs_unescape_string(VALUE string) {
+  if (!REGEXP) {
+    REGEXP = rb_reg_new(regexp_str, strlen(regexp_str), 0);
+    rb_global_variable(&REGEXP);
+  }
+
+  if (!gsub) {
+    gsub = rb_intern("gsub!");
+  }
+
+  if (!HASH) {
+    HASH = rb_hash_new();
+    rb_hash_aset(HASH, rb_str_new_literal("\\a"), rb_str_new_literal("\a"));
+    rb_hash_aset(HASH, rb_str_new_literal("\\b"), rb_str_new_literal("\b"));
+    rb_hash_aset(HASH, rb_str_new_literal("\\e"), rb_str_new_literal("\e"));
+    rb_hash_aset(HASH, rb_str_new_literal("\\f"), rb_str_new_literal("\f"));
+    rb_hash_aset(HASH, rb_str_new_literal("\\n"), rb_str_new_literal("\n"));
+    rb_hash_aset(HASH, rb_str_new_literal("\\r"), rb_str_new_literal("\r"));
+    rb_hash_aset(HASH, rb_str_new_literal("\\s"), rb_str_new_literal(" "));
+    rb_hash_aset(HASH, rb_str_new_literal("\\t"), rb_str_new_literal("\t"));
+    rb_hash_aset(HASH, rb_str_new_literal("\\v"), rb_str_new_literal("\v"));
+    rb_hash_aset(HASH, rb_str_new_literal("\\\""), rb_str_new_literal("\""));
+    rb_global_variable(&HASH);
+  }
+
+  rb_funcall(string, gsub, 2, REGEXP, HASH);
+}
+
+VALUE rbs_unquote_string(parserstate *state, range rg, int offset_bytes) {
+  VALUE string = state->lexstate->string;
+  rb_encoding *enc = rb_enc_get(string);
+
+  unsigned int first_char = rb_enc_mbc_to_codepoint(
+    RSTRING_PTR(string) + rg.start.byte_pos + offset_bytes,
+    RSTRING_END(string),
+    enc
+  );
+
+  int byte_length = rg.end.byte_pos - rg.start.byte_pos - offset_bytes;
+
+  if (first_char == '"' || first_char == '\'' || first_char == '`') {
+    int bs = rb_enc_codelen(first_char, enc);
+    offset_bytes += bs;
+    byte_length -= 2 * bs;
+  }
+
+  char *buffer = RSTRING_PTR(state->lexstate->string) + rg.start.byte_pos + offset_bytes;
+  VALUE str = rb_enc_str_new(buffer, byte_length, enc);
+
+  if (first_char == '\"') {
+    rbs_unescape_string(str);
+  }
+
+  return str;
+}
+

data/goodcheck.yml

@@ -40,7 +40,7 @@ rules:
     glob:
       - "**/*.rbs"
     justification:
-      - When you strictly want `true | false`.
+      - When you strictly want `true | false`. Use `bool` in this case.
     pass:
       - "(arg: boolish)"
       - "{ () -> boolish }"

data/lib/rbs/ast/comment.rb

@@ -22,18 +22,6 @@ module RBS
       def to_json(state = _ = nil)
         { string: string, location: location }.to_json(state)
       end
-
-      def concat(string:, location:)
-        @string.concat string
-
-        if loc = @location
-          loc.concat location
-        else
-          @location = location
-        end
-
-        self
-      end
     end
   end
 end

data/lib/rbs/buffer.rb

@@ -46,5 +46,9 @@ module RBS
     def last_position
       content.size
     end
+
+    def inspect
+      "#<RBS::Buffer:#{__id__} @name=#{name}, @content=#{content.bytesize} bytes, @lines=#{lines.size} lines,>"
+    end
   end
 end

data/lib/rbs/builtin_names.rb

@@ -51,5 +51,6 @@ module RBS
     Regexp = Name.define(:Regexp)
     TrueClass = Name.define(:TrueClass)
     FalseClass = Name.define(:FalseClass)
+    Numeric = Name.define(:Numeric)
   end
 end

data/lib/rbs/cli.rb

@@ -6,6 +6,7 @@ module RBS
   class CLI
     class LibraryOptions
       attr_accessor :core_root
+      attr_accessor :config_path
       attr_reader :repos
       attr_reader :libs
       attr_reader :dirs
@@ -16,6 +17,7 @@ module RBS
 
         @libs = []
         @dirs = []
+        @config_path = Collection::Config::PATH
       end
 
       def loader
@@ -25,6 +27,8 @@ module RBS
         end
 
         loader = EnvironmentLoader.new(core_root: core_root, repository: repository)
+        lock = config_path&.then { |p| Collection::Config.lockfile_of(p) }
+        loader.add_collection(lock) if lock
 
         dirs.each do |dir|
           loader.add(path: Pathname(dir))
@@ -52,6 +56,14 @@ module RBS
           self.core_root = nil
         end
 
+        opts.on('--collection PATH', "File path of collection configration (default: #{Collection::Config::PATH})") do |path|
+          self.config_path = Pathname(path).expand_path
+        end
+
+        opts.on('--no-collection', 'Ignore collection configration') do
+          self.config_path = nil
+        end
+
         opts.on("--repo DIR", "Add RBS repository") do |dir|
           repos << dir
         end
@@ -68,7 +80,7 @@ module RBS
       @stderr = stderr
     end
 
-    COMMANDS = [:ast, :list, :ancestors, :methods, :method, :validate, :constant, :paths, :prototype, :vendor, :parse, :test]
+    COMMANDS = [:ast, :list, :ancestors, :methods, :method, :validate, :constant, :paths, :prototype, :vendor, :parse, :test, :collection]
 
     def parse_logging_options(opts)
       opts.on("--log-level LEVEL", "Specify log level (defaults to `warn`)") do |level|
@@ -737,14 +749,11 @@ Examples:
       args.each do |path|
         path = Pathname(path)
         loader.each_file(path, skip_hidden: false, immediate: true) do |file_path|
-          Parser.parse_signature(file_path.read)
-        rescue RBS::Parser::SyntaxError => ex
-          loc = ex.error_value.location
-          stdout.puts "#{file_path}:#{loc.start_line}:#{loc.start_column}: parse error on value: (#{ex.token_str})"
-          syntax_error = true
-        rescue RBS::Parser::SemanticsError => ex
-          loc = ex.location
-          stdout.puts "#{file_path}:#{loc.start_line}:#{loc.start_column}: #{ex.original_message}"
+          RBS.logger.info "Parsing #{file_path}..."
+          buffer = Buffer.new(content: file_path.read, name: file_path)
+          Parser.parse_signature(buffer)
+        rescue RBS::ParsingError => ex
+          stdout.puts ex.message
           syntax_error = true
         end
       end
@@ -819,11 +828,90 @@ EOB
 
       # @type var out: String
       # @type var err: String
-      out, err, status = Open3.capture3(env_hash, *args)
+      out, err, status = __skip__ = Open3.capture3(env_hash, *args)
       stdout.print(out)
       stderr.print(err)
 
       status
     end
+
+    def run_collection(args, options)
+      warn "warning: rbs collection is experimental, and the behavior may change until RBS v2.0"
+
+      opts = collection_options(args)
+      params = {}
+      opts.order args.drop(1), into: params
+      config_path = options.config_path or raise
+      lock_path = Collection::Config.to_lockfile_path(config_path)
+
+      case args[0]
+      when 'install'
+        unless params[:frozen]
+          Collection::Config.generate_lockfile(config_path: config_path, gemfile_lock_path: Pathname('./Gemfile.lock'))
+        end
+        Collection::Installer.new(lockfile_path: lock_path, stdout: stdout).install_from_lockfile
+      when 'update'
+        # TODO: Be aware of argv to update only specified gem
+        Collection::Config.generate_lockfile(config_path: config_path, gemfile_lock_path: Pathname('./Gemfile.lock'), with_lockfile: false)
+        Collection::Installer.new(lockfile_path: lock_path, stdout: stdout).install_from_lockfile
+      when 'init'
+        if config_path.exist?
+          puts "#{config_path} already exists"
+          exit 1
+        end
+
+        config_path.write(<<~'YAML')
+          # Download sources
+          sources:
+            - name: ruby/gem_rbs_collection
+              remote: https://github.com/ruby/gem_rbs_collection.git
+              revision: main
+              repo_dir: gems
+
+          # A directory to install the downloaded RBSs
+          path: .gem_rbs_collection
+
+          gems:
+            # Skip loading rbs gem's RBS.
+            # It's unnecessary if you don't use rbs as a library.
+            - name: rbs
+              ignore: true
+        YAML
+        stdout.puts "created: #{config_path}"
+      when 'clean'
+        unless lock_path.exist?
+          puts "#{lock_path} should exist to clean"
+          exit 1
+        end
+        Collection::Cleaner.new(lockfile_path: lock_path)
+      when 'help'
+        puts opts.help
+      else
+        puts opts.help
+        exit 1
+      end
+    end
+
+    def collection_options(args)
+      OptionParser.new do |opts|
+        opts.banner = <<~HELP
+          Usage: rbs collection [install|update|init|clean|help]
+
+          Manage RBS collection, which contains third party RBS.
+
+          Examples:
+
+            # Initialize the configration file
+            $ rbs collection init
+
+            # Generate the lock file and install RBSs from the lock file
+            $ rbs collection install
+
+            # Update the RBSs
+            $ rbs collection update
+        HELP
+        opts.on('--frozen') if args[0] == 'install'
+      end
+    end
   end
 end

data/lib/rbs/collection/cleaner.rb

@@ -0,0 +1,29 @@
+module RBS
+  module Collection
+    class Cleaner
+      attr_reader :lock
+
+      def initialize(lockfile_path:)
+        @lock = Config.from_path(lockfile_path)
+      end
+
+      def clean
+        lock.repo_path.glob('*/*') do |dir|
+          *_, gem_name, version = dir.to_s.split('/')
+          gem_name or raise
+          version or raise
+          next if needed? gem_name, version
+
+          FileUtils.remove_entry_secure(dir.to_s)
+        end
+      end
+
+      def needed?(gem_name, version)
+        gem = lock.gem(gem_name)
+        return false unless gem
+
+        gem['version'] == version
+      end
+    end
+  end
+end

data/lib/rbs/collection/config/lockfile_generator.rb

@@ -0,0 +1,95 @@
+module RBS
+  module Collection
+
+    # This class represent the configration file.
+    class Config
+      class LockfileGenerator
+        attr_reader :config, :lock, :gemfile_lock, :lock_path
+
+        def self.generate(config_path:, gemfile_lock_path:, with_lockfile: true)
+          new(config_path: config_path, gemfile_lock_path: gemfile_lock_path, with_lockfile: with_lockfile).generate
+        end
+
+        def initialize(config_path:, gemfile_lock_path:, with_lockfile:)
+          @config = Config.from_path config_path
+          @lock_path = Config.to_lockfile_path(config_path)
+          @lock = Config.from_path(lock_path) if lock_path.exist? && with_lockfile
+          @gemfile_lock = Bundler::LockfileParser.new(gemfile_lock_path.read)
+        end
+
+        def generate
+          config.gems.each do |gem|
+            assign_gem(gem_name: gem['name'], version: gem['version'])
+          end
+
+          gemfile_lock_gems do |spec|
+            assign_gem(gem_name: spec.name, version: spec.version)
+          end
+          remove_ignored_gems!
+
+          config.dump_to(lock_path)
+          config
+        end
+
+        private def assign_gem(gem_name:, version:)
+          locked = lock&.gem(gem_name)
+          specified = config.gem(gem_name)
+
+          return if specified&.dig('ignore')
+          return if specified&.dig('source') # skip if the source is already filled
+
+          if locked
+            # If rbs_collection.lock.yaml contain the gem, use it.
+            upsert_gem specified, locked
+          else
+            # Find the gem from gem_collection.
+            source = find_source(gem_name: gem_name)
+            return unless source
+
+            installed_version = version
+            best_version = find_best_version(version: installed_version, versions: source.versions({ 'name' => gem_name }))
+            # @type var new_content: RBS::Collection::Config::gem_entry
+            new_content = {
+              'name' => gem_name,
+              'version' => best_version.to_s,
+              'source' => source.to_lockfile,
+            }
+            upsert_gem specified, new_content
+          end
+        end
+
+        private def upsert_gem(old, new)
+          if old
+            old.merge! new
+          else
+            config.add_gem new
+          end
+        end
+
+        private def remove_ignored_gems!
+          config.gems.reject! { |gem| gem['ignore'] }
+        end
+
+        private def gemfile_lock_gems(&block)
+          gemfile_lock.specs.each do |spec|
+            yield spec
+          end
+        end
+
+        private def find_source(gem_name:)
+          sources = config.sources
+
+          sources.find { |c| c.has?({ 'name' => gem_name, 'revision' => nil } ) }
+        end
+
+        private def find_best_version(version:, versions:)
+          candidates = versions.map { |v| Gem::Version.create(v) or raise }
+          return candidates.max || raise unless version
+
+          v = Gem::Version.create(version) or raise
+          Repository.find_best_version(v, candidates)
+        end
+      end
+    end
+  end
+end