rbs 2.8.4 → 3.8.1

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

@@ -13,64 +13,87 @@ module RBS
 
         class CommandError < StandardError; end
 
-        attr_reader :name, :remote, :repo_dir
+        attr_reader :name, :remote, :repo_dir, :revision
 
         def initialize(name:, revision:, remote:, repo_dir:)
           @name = name
           @remote = remote
           @repo_dir = repo_dir || 'gems'
-
-          setup!(revision: revision)
+          @revision = revision
+          @need_setup = true
         end
 
-        def has?(config_entry)
-          gem_name = config_entry['name']
-          gem_repo_dir.join(gem_name).directory?
+        def has?(name, version)
+          setup! do
+            if version
+              (gems_versions[name] || Set[]).include?(version)
+            else
+              gems_versions.key?(name)
+            end
+          end
         end
 
-        def versions(config_entry)
-          gem_name = config_entry['name']
-          gem_repo_dir.join(gem_name).glob('*/').map { |path| path.basename.to_s }
+        def versions(name)
+          setup! do
+            versions = gems_versions[name] or raise "Git source `#{name}` doesn't have `#{name}`"
+            versions.sort
+          end
         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)
+        def install(dest:, name:, version:, stdout:)
+          setup!()
+
+          gem_dir = dest.join(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)}"
+          colored_io = CLI::ColoredIO.new(stdout: stdout)
+
+          case
+          when gem_dir.symlink?
+            colored_io.puts_green("Updating to #{format_config_entry(name, version)} from a local source")
+            gem_dir.unlink
+            _install(dest: dest, name: name, version: version)
+          when gem_dir.directory?
+            prev = load_metadata(dir: gem_dir)
+
+            if prev == metadata_content(name: name, version: version)
+              colored_io.puts "Using #{format_config_entry(name, version)}"
             else
-              # @type var prev: RBS::Collection::Config::gem_entry
-              stdout.puts "Updating to #{format_config_entry(config_entry)} from #{format_config_entry(prev)}"
+              colored_io.puts_green("Updating to #{format_config_entry(name, version)} from #{format_config_entry(prev["name"], prev["version"])}")
               FileUtils.remove_entry_secure(gem_dir.to_s)
-              _install(dest: dest, config_entry: config_entry)
+              _install(dest: dest, name: name, version: version)
             end
+          when !gem_dir.exist?
+            colored_io.puts_green("Installing #{format_config_entry(name, version)}")
+            _install(dest: dest, name: name, version: version)
           else
-            stdout.puts "Installing #{format_config_entry(config_entry)}"
-            _install(dest: dest, config_entry: config_entry)
+            raise
           end
         end
 
-        def manifest_of(config_entry)
-          gem_name = config_entry['name']
-          version = config_entry['version'] or raise
-          gem_dir = gem_repo_dir.join(gem_name, version)
-
-          manifest_path = gem_dir.join('manifest.yaml')
-          YAML.safe_load(manifest_path.read) if manifest_path.exist?
+        def manifest_of(name, version)
+          setup! do
+            path = File.join(repo_dir, name, version, 'manifest.yaml')
+            content = git('cat-file', '-p', "#{resolved_revision}:#{path}")
+            YAML.safe_load(content)
+          rescue CommandError
+            if has?(name, version)
+              nil
+            else
+              raise
+            end
+          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)
+        private def _install(dest:, name:, version:)
+          # Should checkout that revision to support symlinks
+          git("reset", "--hard", resolved_revision)
+
+          dir = dest.join(name, version)
+          dir.mkpath
+          src = gem_repo_dir.join(name, version)
 
-          cp_r(src, dest)
-          dest.join(METADATA_FILENAME).write(YAML.dump(config_entry))
+          cp_r(src, dir)
+          write_metadata(dir: dir, name: name, version: version)
         end
 
         private def cp_r(src, dest)
@@ -97,47 +120,39 @@ module RBS
           }
         end
 
-        private def format_config_entry(config_entry)
-          name = config_entry['name']
-          v = config_entry['version']
-
+        private def format_config_entry(name, version)
           rev = resolved_revision[0..10]
           desc = "#{name}@#{rev}"
 
-          "#{name}:#{v} (#{desc})"
+          "#{name}:#{version} (#{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
-            begin
-              # git v2.27.0 or greater
-              git 'clone', '--filter=blob:none', remote, git_dir.to_s, chdir: nil
-            rescue CommandError
-              git 'clone', remote, git_dir.to_s, chdir: nil
+        private def setup!
+          if @need_setup
+            git_dir.mkpath
+            if git_dir.join('.git').directory?
+              if need_to_fetch?(revision)
+                git 'fetch', 'origin'
+              end
+            else
+              begin
+                # git v2.27.0 or greater
+                git 'clone', '--filter=blob:none', remote, git_dir.to_s, chdir: nil
+              rescue CommandError
+                git 'clone', remote, git_dir.to_s, chdir: nil
+              end
             end
-          end
 
-          begin
-            git 'checkout', "origin/#{revision}" # for branch name as `revision`
-          rescue CommandError
-            git 'checkout', revision
+            @need_setup = false
           end
+
+          yield if block_given?
         end
 
         private def need_to_fetch?(revision)
-          return true unless revision.match?(/\A[a-f0-9]{40}\z/)
+          return true unless commit_hash?
 
-          begin
-            git('cat-file', '-e', revision)
-            false
-          rescue CommandError
-            true
-          end
+          !git?('cat-file', '-e', revision)
         end
 
         private def git_dir
@@ -154,18 +169,31 @@ module RBS
           git_dir.join @repo_dir
         end
 
-        private def resolved_revision
-          @resolved_revision ||= resolve_revision
+        def resolved_revision
+          @resolved_revision ||=
+            begin
+              if commit_hash?
+                revision
+              else
+                setup! { git('rev-parse', "refs/remotes/origin/#{revision}").chomp }
+              end
+            end
         end
 
-        private def resolve_revision
-          git('rev-parse', 'HEAD').chomp
+        private def commit_hash?
+          revision.match?(/\A[a-f0-9]{40}\z/)
         end
 
         private def git(*cmd, **opt)
           sh! 'git', *cmd, **opt
         end
 
+        private def git?(*cmd, **opt)
+          git(*cmd, **opt)
+        rescue CommandError
+          nil
+        end
+
         private def sh!(*cmd, **opt)
           RBS.logger.debug "$ #{cmd.join(' ')}"
           opt = { chdir: git_dir }.merge(opt).compact
@@ -175,6 +203,55 @@ module RBS
             out
           end
         end
+
+        def metadata_content(name:, version:)
+          {
+            "name" => name,
+            "version" => version,
+            "source" => to_lockfile
+          }
+        end
+
+        def write_metadata(dir:, name:, version:)
+          dir.join(METADATA_FILENAME).write(
+            YAML.dump(
+              metadata_content(name: name, version: version)
+            )
+          )
+        end
+
+        def load_metadata(dir:)
+          # @type var content: Hash[String, untyped]
+          content = YAML.load_file(dir.join(METADATA_FILENAME).to_s)
+          _ = content.slice("name", "version", "source")
+        end
+
+        private def gems_versions
+          @gems_versions ||= begin
+            repo_path = Pathname(repo_dir)
+
+            paths = git('ls-tree', '--full-tree', '-dr', '--name-only', '-z', resolved_revision, File.join(repo_dir, "")).split("\0").map {|line| Pathname(line) }
+
+            # @type var versions: Hash[String, Set[String]]
+            versions = {}
+
+            paths.each do |full_path|
+              path = full_path.relative_path_from(repo_path)
+
+              gem_name, version = path.descend.take(2)
+
+              if gem_name
+                versions[gem_name.to_s] ||= Set[]
+
+                if version && !version.basename.to_s.start_with?('_')
+                  versions[gem_name.to_s] << version.basename.to_s
+                end
+              end
+            end
+
+            versions
+          end
+        end
       end
     end
   end

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module RBS
+  module Collection
+    module Sources
+      class Local
+        include Base
+
+        attr_reader :path, :full_path
+
+        def initialize(path:, base_directory:)
+          # TODO: resolve relative path from dir of rbs_collection.yaml
+          @path = Pathname(path)
+          @full_path = base_directory / path
+        end
+
+        def has?(name, version)
+          if version
+            @full_path.join(name, version).directory?
+          else
+            not versions(name).empty?
+          end
+        end
+
+        def versions(name)
+          @full_path.join(name).glob('*/').map { |path| path.basename.to_s }
+        end
+
+        # Create a symlink instead of copying file to refer files in @path.
+        # By avoiding copying RBS files, the users do not need re-run `rbs collection install`
+        # when the RBS files are updated.
+        def install(dest:, name:, version:, stdout:)
+          from = @full_path.join(name, version)
+          gem_dir = dest.join(name, version)
+
+          colored_io = CLI::ColoredIO.new(stdout: stdout)
+
+          case
+          when gem_dir.symlink? && gem_dir.readlink == from
+            colored_io.puts "Using #{name}:#{version} (#{from})"
+          when gem_dir.symlink?
+            prev = gem_dir.readlink
+            gem_dir.unlink
+            _install(from, dest.join(name, version))
+            colored_io.puts_green("Updating #{name}:#{version} to #{from} from #{prev}")
+          when gem_dir.directory?
+            # TODO: Show version of git source
+            FileUtils.remove_entry_secure(gem_dir.to_s)
+            _install(from, dest.join(name, version))
+            colored_io.puts_green("Updating #{name}:#{version} from git source")
+          when !gem_dir.exist?
+            _install(from, dest.join(name, version))
+            colored_io.puts_green("Installing #{name}:#{version} (#{from})")
+          else
+            raise
+          end
+        end
+
+        private def _install(src, dst)
+          dst.dirname.mkpath
+          File.symlink(src, dst)
+        end
+
+        def manifest_of(name, version)
+          gem_dir = @full_path.join(name, version)
+          raise unless gem_dir.exist?
+
+          manifest_path = gem_dir.join('manifest.yaml')
+          YAML.safe_load(manifest_path.read) if manifest_path.exist?
+        end
+
+        def to_lockfile
+          {
+            'type' => 'local',
+            'path' => @path.to_s,
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -10,26 +10,24 @@ module RBS
         include Base
         include Singleton
 
-        def has?(config_entry)
-          gem_sig_path(config_entry)
+        def has?(name, version)
+          gem_sig_path(name, version)
         end
 
-        def versions(config_entry)
-          spec, _ = gem_sig_path(config_entry)
+        def versions(name)
+          spec, _ = gem_sig_path(name, nil)
           spec or raise
           [spec.version.to_s]
         end
 
-        def install(dest:, config_entry:, stdout:)
+        def install(dest:, name:, version:, 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)
+          _, from = gem_sig_path(name, version)
           stdout.puts "Using #{name}:#{version} (#{from})"
         end
 
-        def manifest_of(config_entry)
-          _, sig_path = gem_sig_path(config_entry)
+        def manifest_of(name, version)
+          _, sig_path = gem_sig_path(name, version)
           sig_path or raise
           manifest_path = sig_path.join('manifest.yaml')
           YAML.safe_load(manifest_path.read) if manifest_path.exist?
@@ -41,8 +39,8 @@ module RBS
           }
         end
 
-        private def gem_sig_path(config_entry)
-          RBS::EnvironmentLoader.gem_sig_path(config_entry['name'], config_entry['version'])
+        private def gem_sig_path(name, version)
+          RBS::EnvironmentLoader.gem_sig_path(name, version)
         end
       end
     end

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

@@ -12,25 +12,26 @@ module RBS
 
         REPO = Repository.default
 
-        def has?(config_entry)
-          lookup(config_entry)
+        def has?(name, version)
+          lookup(name, version)
         end
 
-        def versions(config_entry)
-          REPO.gems[config_entry['name']].versions.keys.map(&:to_s)
+        def versions(name)
+          REPO.gems[name].versions.keys.map(&:to_s)
         end
 
-        def install(dest:, config_entry:, stdout:)
+        def install(dest:, name:, version:, stdout:)
           # Do nothing because stdlib RBS is available by default
-          name = config_entry['name']
-          version = config_entry['version'] or raise
-          from = lookup(config_entry)
+          from = lookup(name, version)
           stdout.puts "Using #{name}:#{version} (#{from})"
         end
 
-        def manifest_of(config_entry)
-          config_entry['version'] or raise
-          manifest_path = (lookup(config_entry) or raise).join('manifest.yaml')
+        def manifest_of(name, version)
+          unless path = lookup(name, version)
+            RBS.logger.warn "`#{name}` is specified in rbs_collection.lock.yaml. But it is not found in #{REPO.dirs.join(",")}"
+            return
+          end
+          manifest_path = path.join('manifest.yaml')
           YAML.safe_load(manifest_path.read) if manifest_path.exist?
         end
 
@@ -40,8 +41,8 @@ module RBS
           }
         end
 
-        private def lookup(config_entry)
-          REPO.lookup(config_entry['name'], config_entry['version'])
+        private def lookup(name, version)
+          REPO.lookup(name, version)
         end
       end
     end

data/lib/rbs/collection/sources.rb

@@ -4,14 +4,27 @@ require_relative './sources/base'
 require_relative './sources/git'
 require_relative './sources/stdlib'
 require_relative './sources/rubygems'
+require_relative './sources/local'
 
 module RBS
   module Collection
     module Sources
-      def self.from_config_entry(source_entry)
+      def self.from_config_entry(source_entry, base_directory:)
         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))
+          # @type var source_entry: Git::source_entry
+          Git.new(
+            name: source_entry["name"],
+            revision: source_entry["revision"],
+            remote: source_entry["remote"],
+            repo_dir: source_entry["repo_dir"]
+          )
+        when 'local'
+          # @type var source_entry: Local::source_entry
+          Local.new(
+            path: source_entry['path'],
+            base_directory: base_directory,
+          )
         when 'stdlib'
           Stdlib.instance
         when 'rubygems'

data/lib/rbs/collection.rb

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
 
 require 'yaml'
-require 'bundler'
 
+require_relative './cli/colored_io'
 require_relative './collection/sources'
 require_relative './collection/config'
+require_relative './collection/config/lockfile'
 require_relative './collection/config/lockfile_generator'
 require_relative './collection/installer'
 require_relative './collection/cleaner'

data/lib/rbs/definition.rb

@@ -28,12 +28,18 @@ module RBS
         attr_reader :member
         attr_reader :defined_in
         attr_reader :implemented_in
+        attr_reader :member_annotations
+        attr_reader :overload_annotations
+        attr_reader :annotations
 
-        def initialize(type:, member:, defined_in:, implemented_in:)
+        def initialize(type:, member:, defined_in:, implemented_in:, overload_annotations: [])
           @type = type
           @member = member
           @defined_in = defined_in
           @implemented_in = implemented_in
+          @member_annotations = member.annotations
+          @overload_annotations = overload_annotations
+          @annotations = member.annotations + overload_annotations
         end
 
         def ==(other)
@@ -54,18 +60,14 @@ module RBS
           member.comment
         end
 
-        def annotations
-          member.annotations
-        end
-
         def update(type: self.type, member: self.member, defined_in: self.defined_in, implemented_in: self.implemented_in)
-          TypeDef.new(type: type, member: member, defined_in: defined_in, implemented_in: implemented_in)
+          TypeDef.new(type: type, member: member, defined_in: defined_in, implemented_in: implemented_in, overload_annotations: overload_annotations)
         end
 
         def overload?
           case mem = member
           when AST::Members::MethodDefinition
-            mem.overload?
+            mem.overloading?
           else
             false
           end
@@ -82,7 +84,7 @@ module RBS
         @super_method = super_method
         @defs = defs
         @accessibility = accessibility
-        @extra_annotations = annotations
+        @extra_annotations = []
         @alias_of = alias_of
       end
 
@@ -124,7 +126,7 @@ module RBS
       end
 
       def annotations
-        @annotations ||= @extra_annotations + defs.flat_map {|d| d.annotations }
+        @annotations ||= defs.flat_map {|d| d.member_annotations }
       end
 
       def members
@@ -237,13 +239,8 @@ module RBS
         @ancestors = ancestors
       end
 
-      def apply(args, location:)
-        InvalidTypeApplicationError.check!(
-          type_name: type_name,
-          args: args,
-          params: params,
-          location: location
-        )
+      def apply(args, env:, location:)
+        InvalidTypeApplicationError.check2!(env: env, type_name: type_name, args: args, location: location)
 
         subst = Substitution.build(params, args)