rbs 1.5.1 → 1.7.0.beta.1

data/lib/rbs/collection/config.rb

@@ -0,0 +1,85 @@
+module RBS
+  module Collection
+
+    # This class represent the configration file.
+    class Config
+      class CollectionNotAvailable < StandardError
+        def initialize
+          super <<~MSG
+            rbs collection is not initialized.
+            Run `rbs collection install` to install RBSs from collection.
+          MSG
+        end
+      end
+
+      PATH = Pathname('rbs_collection.yaml')
+
+      # Generate a rbs lockfile from Gemfile.lock to `config_path`.
+      # If `with_lockfile` is true, it respects existing rbs lockfile.
+      def self.generate_lockfile(config_path:, gemfile_lock_path:, with_lockfile: true)
+        LockfileGenerator.generate(config_path: config_path, gemfile_lock_path: gemfile_lock_path, with_lockfile: with_lockfile)
+      end
+
+      def self.from_path(path)
+        new(YAML.load(path.read), config_path: path)
+      end
+
+      def self.lockfile_of(config_path)
+        lock_path = to_lockfile_path(config_path)
+        from_path lock_path if lock_path.exist?
+      end
+
+      def self.to_lockfile_path(config_path)
+        config_path.sub_ext('.lock' + config_path.extname)
+      end
+
+      def initialize(data, config_path:)
+        @data = data
+        @config_path = config_path
+      end
+
+      def add_gem(gem)
+        gems << gem
+      end
+
+      def gem(gem_name)
+        gems.find { |gem| gem['name'] == gem_name }
+      end
+
+      def repo_path
+        @config_path.dirname.join @data['path']
+      end
+
+      def sources
+        @sources ||= (
+          @data['sources']
+            .map { |c| Sources.from_config_entry(c) }
+            .push(Sources::Stdlib.instance)
+            .push(Sources::Rubygems.instance)
+        )
+      end
+
+      def dump_to(io)
+        YAML.dump(@data, io)
+      end
+
+      def gems
+        @data['gems'] ||= []
+      end
+
+      # It raises an error when there are non-available libraries
+      def check_rbs_availability!
+        raise CollectionNotAvailable unless repo_path.exist?
+
+        gems.each do |gem|
+          case gem['source']['type']
+          when 'git'
+            meta_path = repo_path.join(gem['name'], gem['version'], Sources::Git::METADATA_FILENAME)
+            raise CollectionNotAvailable unless meta_path.exist?
+            raise CollectionNotAvailable unless gem == YAML.load(meta_path.read)
+          end
+        end
+      end
+    end
+  end
+end

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,162 @@
+require 'digest/sha2'
+require 'open3'
+require 'find'
+
+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, version)
+          dest.mkpath
+          src = gem_repo_dir.join(gem_name, version)
+
+          cp_r(src, dest)
+          dest.join(METADATA_FILENAME).write(YAML.dump(config_entry))
+        end
+
+        private def cp_r(src, dest)
+          Find.find(src) do |file_src|
+            file_src = Pathname(file_src)
+
+            # Skip file if it starts with _, such as _test/
+            Find.prune if file_src.basename.to_s.start_with?('_')
+
+            file_src_relative = file_src.relative_path_from(src)
+            file_dest = dest.join(file_src_relative)
+            file_dest.dirname.mkpath
+            FileUtils.copy_entry(file_src, file_dest, false, true) unless file_src.directory?
+          end
+        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

@@ -15,10 +15,23 @@ module RBS
   end
 
   class ErrorBase < StandardError; end
-  class ParsingError < ErrorBase; end
   class LoadingError < ErrorBase; end
   class DefinitionError < ErrorBase; end
 
+  class ParsingError < ErrorBase
+    attr_reader :location
+    attr_reader :error_message
+    attr_reader :token_type
+
+    def initialize(location, error_message, token_type)
+      @location = location
+      @error_message = error_message
+      @token_type = token_type
+
+      super "#{Location.to_string location}: Syntax error: #{error_message}, token=`#{location.source}` (#{token_type})"
+    end
+  end
+
   class InvalidTypeApplicationError < DefinitionError
     attr_reader :type_name
     attr_reader :args
@@ -383,6 +396,8 @@ module RBS
         "include"
       when AST::Members::Extend
         "extend"
+      else
+        raise
       end
     end
   end