rbs 1.4.0 → 1.6.1

data/lib/rbs/collection/installer.rb

@@ -0,0 +1,27 @@
+module RBS
+  module Collection
+    class Installer
+      attr_reader :lockfile
+      attr_reader :stdout
+
+      def initialize(lockfile_path:, stdout: $stdout)
+        @lockfile = Config.from_path(lockfile_path)
+        @stdout = stdout
+      end
+
+      def install_from_lockfile
+        install_to = lockfile.repo_path
+        lockfile.gems.each do |config_entry|
+          source_for(config_entry).install(dest: install_to, config_entry: config_entry, stdout: stdout)
+        end
+        stdout.puts "It's done! #{lockfile.gems.size} gems' RBSs now installed."
+      end
+
+      private def source_for(config_entry)
+        @source_for ||= {}
+        key = config_entry['source'] or raise
+        @source_for[key] ||= Sources.from_config_entry(key)
+      end
+    end
+  end
+end

data/lib/rbs/collection/sources/git.rb

@@ -0,0 +1,147 @@
+require 'digest/sha2'
+require 'open3'
+
+module RBS
+  module Collection
+    module Sources
+      class Git
+        METADATA_FILENAME = '.rbs_meta.yaml'
+
+        class CommandError < StandardError; end
+
+        attr_reader :name, :remote, :repo_dir
+
+        def initialize(name:, revision:, remote:, repo_dir:)
+          @name = name
+          @remote = remote
+          @repo_dir = repo_dir || 'gems'
+
+          setup!(revision: revision)
+        end
+
+        def has?(config_entry)
+          gem_name = config_entry['name']
+          gem_repo_dir.join(gem_name).directory?
+        end
+
+        def versions(config_entry)
+          gem_name = config_entry['name']
+          gem_repo_dir.join(gem_name).glob('*/').map { |path| path.basename.to_s }
+        end
+
+        def install(dest:, config_entry:, stdout:)
+          gem_name = config_entry['name']
+          version = config_entry['version'] or raise
+          gem_dir = dest.join(gem_name, version)
+
+          if gem_dir.directory?
+            if (prev = YAML.load_file(gem_dir.join(METADATA_FILENAME))) == config_entry
+              stdout.puts "Using #{format_config_entry(config_entry)}"
+            else
+              # @type var prev: RBS::Collection::Config::gem_entry
+              stdout.puts "Updating to #{format_config_entry(config_entry)} from #{format_config_entry(prev)}"
+              FileUtils.remove_entry_secure(gem_dir.to_s)
+              _install(dest: dest, config_entry: config_entry)
+            end
+          else
+            stdout.puts "Installing #{format_config_entry(config_entry)}"
+            _install(dest: dest, config_entry: config_entry)
+          end
+        end
+
+        private def _install(dest:, config_entry:)
+          gem_name = config_entry['name']
+          version = config_entry['version'] or raise
+          dest = dest.join(gem_name)
+          dest.mkpath
+          src = gem_repo_dir.join(gem_name, version)
+
+          FileUtils.cp_r(src, dest)
+          dest.join(version, METADATA_FILENAME).write(YAML.dump(config_entry))
+        end
+
+        def to_lockfile
+          {
+            'type' => 'git',
+            'name' => name,
+            'revision' => resolved_revision,
+            'remote' => remote,
+            'repo_dir' => repo_dir,
+          }
+        end
+
+        private def format_config_entry(config_entry)
+          name = config_entry['name']
+          v = config_entry['version']
+
+          rev = resolved_revision[0..10]
+          desc = "#{name}@#{rev}"
+
+          "#{name}:#{v} (#{desc})"
+        end
+
+        private def setup!(revision:)
+          git_dir.mkpath
+          if git_dir.join('.git').directory?
+            if need_to_fetch?(revision)
+              git 'fetch', 'origin'
+            end
+          else
+            git 'clone', remote, git_dir.to_s
+          end
+
+          begin
+            git 'checkout', "origin/#{revision}" # for branch name as `revision`
+          rescue CommandError
+            git 'checkout', revision
+          end
+        end
+
+        private def need_to_fetch?(revision)
+          return true unless revision.match?(/\A[a-f0-9]{40}\z/)
+
+          begin
+            git('cat-file', '-e', revision)
+            false
+          rescue CommandError
+            true
+          end
+        end
+
+        private def git_dir
+          @git_dir ||= (
+            base = Pathname(ENV['XDG_CACHE_HOME'] || File.expand_path("~/.cache"))
+            dir = base.join('rbs', Digest::SHA256.hexdigest(remote))
+            dir.mkpath
+            dir
+          )
+        end
+
+        private def gem_repo_dir
+          git_dir.join @repo_dir
+        end
+
+        private def resolved_revision
+          @resolved_revision ||= resolve_revision
+        end
+
+        private def resolve_revision
+          git('rev-parse', 'HEAD').chomp
+        end
+
+        private def git(*cmd)
+          sh! 'git', *cmd
+        end
+
+        private def sh!(*cmd)
+          RBS.logger.debug "$ #{cmd.join(' ')}"
+          (__skip__ = Open3.capture3(*cmd, chdir: git_dir)).then do |out, err, status|
+            raise CommandError, "Unexpected status #{status.exitstatus}\n\n#{err}" unless status.success?
+
+            out
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rbs/collection/sources/rubygems.rb

@@ -0,0 +1,40 @@
+require 'singleton'
+
+module RBS
+  module Collection
+    module Sources
+      # Signatures that are inclduded in gem package as sig/ directory.
+      class Rubygems
+        include Singleton
+
+        def has?(config_entry)
+          gem_sig_path(config_entry)
+        end
+
+        def versions(config_entry)
+          spec, _ = gem_sig_path(config_entry)
+          spec or raise
+          [spec.version.to_s]
+        end
+
+        def install(dest:, config_entry:, stdout:)
+          # Do nothing because stdlib RBS is available by default
+          name = config_entry['name']
+          version = config_entry['version'] or raise
+          _, from = gem_sig_path(config_entry)
+          stdout.puts "Using #{name}:#{version} (#{from})"
+        end
+
+        def to_lockfile
+          {
+            'type' => 'rubygems',
+          }
+        end
+
+        private def gem_sig_path(config_entry)
+          RBS::EnvironmentLoader.gem_sig_path(config_entry['name'], config_entry['version'])
+        end
+      end
+    end
+  end
+end

data/lib/rbs/collection/sources/stdlib.rb

@@ -0,0 +1,38 @@
+require 'singleton'
+
+module RBS
+  module Collection
+    module Sources
+      # signatures that are bundled in rbs gem under the stdlib/ directory
+      class Stdlib
+        include Singleton
+
+        def has?(config_entry)
+          gem_dir(config_entry).exist?
+        end
+
+        def versions(config_entry)
+          gem_dir(config_entry).glob('*/').map { |path| path.basename.to_s }
+        end
+
+        def install(dest:, config_entry:, stdout:)
+          # Do nothing because stdlib RBS is available by default
+          name = config_entry['name']
+          version = config_entry['version'] or raise
+          from = gem_dir(config_entry) / version
+          stdout.puts "Using #{name}:#{version} (#{from})"
+        end
+
+        def to_lockfile
+          {
+            'type' => 'stdlib',
+          }
+        end
+
+        private def gem_dir(config_entry)
+          Repository::DEFAULT_STDLIB_ROOT.join(config_entry['name'])
+        end
+      end
+    end
+  end
+end

data/lib/rbs/collection/sources.rb

@@ -0,0 +1,22 @@
+require_relative './sources/git'
+require_relative './sources/stdlib'
+require_relative './sources/rubygems'
+
+module RBS
+  module Collection
+    module Sources
+      def self.from_config_entry(source_entry)
+        case source_entry['type']
+        when 'git', nil # git source by default
+          __skip__ = Git.new(**source_entry.slice('name', 'revision', 'remote', 'repo_dir').transform_keys(&:to_sym))
+        when 'stdlib'
+          Stdlib.instance
+        when 'rubygems'
+          Rubygems.instance
+        else
+          raise
+        end
+      end
+    end
+  end
+end

data/lib/rbs/collection.rb

@@ -0,0 +1,13 @@
+require 'yaml'
+require 'bundler'
+
+require_relative './collection/sources'
+require_relative './collection/config'
+require_relative './collection/config/lockfile_generator'
+require_relative './collection/installer'
+require_relative './collection/cleaner'
+
+module RBS
+  module Collection
+  end
+end

data/lib/rbs/environment_loader.rb

@@ -47,6 +47,18 @@ module RBS
       end
     end
 
+    def add_collection(collection_config)
+      warn "warning: rbs collection is experimental, and the behavior may change until RBS v2.0"
+
+      collection_config.check_rbs_availability!
+
+      repository.add(collection_config.repo_path)
+
+      collection_config.gems.each do |gem|
+        add(library: gem['name'], version: gem['version'])
+      end
+    end
+
     def has_library?(library:, version:)
       if self.class.gem_sig_path(library, version) || repository.lookup(library, version)
         true

data/lib/rbs/errors.rb

@@ -383,6 +383,8 @@ module RBS
         "include"
       when AST::Members::Extend
         "extend"
+      else
+        raise
       end
     end
   end

data/lib/rbs/repository.rb

@@ -55,13 +55,8 @@ module RBS
       end
 
       def find_best_version(version)
-        return latest_version unless version
-
-        if v = version_names.reverse.bsearch {|v| v <= version ? true : false }
-          versions[v]
-        else
-          oldest_version
-        end
+        best_version = Repository.find_best_version(version, version_names)
+        versions[best_version]
       end
 
       def empty?
@@ -89,6 +84,17 @@ module RBS
       end
     end
 
+    def self.find_best_version(version, candidates)
+      candidates = candidates.sort
+      return candidates.last || raise unless version
+
+      if v = candidates.reverse.bsearch {|v| v <= version ? true : false }
+        v
+      else
+        candidates.first or raise
+      end
+    end
+
     def add(dir)
       dirs << dir
 

data/lib/rbs/validator.rb

@@ -56,7 +56,10 @@ module RBS
 
     def validate_type_alias(entry:)
       @type_alias_dependency ||= TypeAliasDependency.new(env: env)
-      raise RecursiveTypeAliasError.new(alias_names: [entry.decl.name], location: entry.decl.location) if @type_alias_dependency.circular_definition?(entry.decl.name)
+      if @type_alias_dependency.circular_definition?(entry.decl.name)
+        location = entry.decl.location or raise
+        raise RecursiveTypeAliasError.new(alias_names: [entry.decl.name], location: location)
+      end
     end
   end
 end

data/lib/rbs/version.rb

@@ -1,3 +1,3 @@
 module RBS
-  VERSION = "1.4.0"
+  VERSION = "1.6.1"
 end

data/lib/rbs.rb

@@ -45,6 +45,7 @@ require "rbs/repository"
 require "rbs/ancestor_graph"
 require "rbs/locator"
 require "rbs/type_alias_dependency"
+require "rbs/collection"
 
 begin
   require "rbs/parser"

data/sig/builtin_names.rbs

@@ -37,5 +37,6 @@ module RBS
     Regexp: Name
     TrueClass: Name
     FalseClass: Name
+    Numeric: Name
   end
 end

data/sig/cli.rbs

@@ -2,6 +2,7 @@ module RBS
   class CLI
     class LibraryOptions
       attr_accessor core_root: Pathname?
+      attr_accessor config_path: Pathname?
 
       attr_reader libs: Array[String]
       attr_reader dirs: Array[String]
@@ -63,6 +64,10 @@ module RBS
 
     def run_test: (Array[String], LibraryOptions) -> void
 
+    def run_collection: (Array[String], LibraryOptions) -> void
+
     def test_opt: (LibraryOptions) -> String?
+
+    def collection_options: (Array[String]) -> OptionParser
   end
 end

data/sig/collection/cleaner.rbs

@@ -0,0 +1,13 @@
+module RBS
+  module Collection
+    class Cleaner
+      attr_reader lock: Config
+
+      def initialize: (lockfile_path: Pathname) -> void
+
+      def clean: () -> void
+
+      def needed?: (String gem_name, String version) -> bool
+    end
+  end
+end

data/sig/collection/collections.rbs

@@ -0,0 +1,112 @@
+module RBS
+  module Collection
+    module Sources
+      def self.from_config_entry: (source_entry) -> _Source
+
+      interface _Source
+        def has?: (Config::gem_entry) -> boolish
+        def versions: (Config::gem_entry) -> Array[String]
+        def install: (dest: Pathname, config_entry: Config::gem_entry, stdout: CLI::_IO) -> void
+        def to_lockfile: () -> source_entry
+      end
+
+      type source_entry = Git::source_entry
+                            | Stdlib::source_entry
+                            | Rubygems::source_entry
+
+      class Git
+        METADATA_FILENAME: String
+
+        type source_entry = {
+          'type' => 'git',
+          'name' => String,
+          'remote' => String,
+          'revision' => String,
+          'repo_dir' => String?,
+        }
+
+        class CommandError < StandardError
+        end
+
+        attr_reader name: String
+        attr_reader remote: String
+        attr_reader repo_dir: String
+
+        def initialize: (name: String, revision: String, remote: String, repo_dir: String?) -> untyped
+
+        def has?: (Config::gem_entry) -> bool
+
+        def versions: (Config::gem_entry) -> Array[String]
+
+        def install: (dest: Pathname, config_entry: Config::gem_entry, stdout: CLI::_IO) -> void
+
+        def to_lockfile: () -> source_entry
+
+        private
+
+        def _install: (dest: Pathname , config_entry: Config::gem_entry) -> void
+
+        def setup!: (revision: String) -> void
+
+        def need_to_fetch?: (String revision ) -> bool
+
+        def git_dir: () -> Pathname
+
+        def gem_repo_dir: () -> Pathname
+
+        def with_revision: [T] () { () -> T } -> T
+
+        def resolved_revision: () -> String
+
+        def resolve_revision: () -> String
+
+        def git: (*String cmd) -> String
+
+        def sh!: (*String cmd) -> String
+
+        def format_config_entry: (Config::gem_entry) -> String
+      end
+
+      # signatures that are bundled in rbs gem under the stdlib/ directory
+      class Stdlib
+        type source_entry =  {
+          'type' => 'stdlib',
+        }
+
+        # polyfill of singleton module
+        def self.instance: () -> instance
+
+        def has?: (Config::gem_entry) -> bool
+
+        def versions: (Config::gem_entry) -> Array[String]
+
+        def install: (dest: Pathname, config_entry: Config::gem_entry, stdout: CLI::_IO) -> void
+
+        def to_lockfile: () -> source_entry
+
+        private
+
+        def gem_dir: (Config::gem_entry) -> Pathname
+      end
+
+      # sig/ directory
+      class Rubygems
+        type source_entry = {
+          'type' => 'rubygems',
+        }
+
+        # polyfill of singleton module
+        def self.instance: () -> instance
+
+        def has?: (Config::gem_entry) -> boolish
+        def versions: (Config::gem_entry) -> Array[String]
+        def install: (dest: Pathname, config_entry: Config::gem_entry, stdout: CLI::_IO) -> void
+        def to_lockfile: () -> source_entry
+
+        private
+
+        def gem_sig_path: (Config::gem_entry) -> [Gem::Specification, Pathname]?
+      end
+    end
+  end
+end