Merge pull request #854 from pocke/collection-local-directory-source

Add local source for rbs collection

Author: soutaro

docs/collection.md

@@ -79,6 +79,10 @@ sources:
     revision: main
     repo_dir: gems
 
+  # You can also add a local path as a collection source optionaly.
+  - type: local
+    path: path/to/local/dir
+
 # A directory to install the downloaded RBSs
 path: .gem_rbs_collection
 

lib/rbs/cli.rb

@@ -1076,11 +1076,16 @@ def run_collection(args, options)
         config_path.write(<<~'YAML')
           # Download sources
           sources:
-            - name: ruby/gem_rbs_collection
+            - type: git
+              name: ruby/gem_rbs_collection
               remote: https://github.com/ruby/gem_rbs_collection.git
               revision: main
               repo_dir: gems
 
+          # You can specify local directories as sources also.
+          # - type: local
+          #   path: path/to/your/local/repository
+
           # A directory to install the downloaded RBSs
           path: .gem_rbs_collection
 

lib/rbs/collection/cleaner.rb

@@ -16,7 +16,14 @@ def clean
           version or raise
           next if needed? gem_name, version
 
-          FileUtils.remove_entry_secure(dir.to_s)
+          case
+          when dir.symlink?
+            dir.unlink
+          when dir.directory?
+            FileUtils.remove_entry_secure(dir.to_s)
+          else
+            raise
+          end
         end
       end
 

lib/rbs/collection/config.rb

@@ -66,7 +66,7 @@ def repo_path_data
       def sources
         @sources ||= (
           @data['sources']
-            .map { |c| Sources.from_config_entry(c) }
+            .map { |c| Sources.from_config_entry(c, base_directory: @config_path.dirname) }
             .push(Sources::Stdlib.instance)
             .push(Sources::Rubygems.instance)
         )

lib/rbs/collection/config/lockfile.rb

@@ -75,7 +75,7 @@ def self.from_lockfile(lockfile_path:, data:)
           if gems = data["gems"]
             gems.each do |gem|
               src = gem["source"]
-              source = Sources.from_config_entry(src)
+              source = Sources.from_config_entry(src, base_directory: lockfile_path.dirname)
               lockfile.gems[gem["name"]] = {
                 name: gem["name"],
                 version: gem["version"],
@@ -106,6 +106,8 @@ def check_rbs_availability!
               meta_path = fullpath.join(gem[:name], gem[:version], Sources::Git::METADATA_FILENAME)
               raise CollectionNotAvailable unless meta_path.exist?
               raise CollectionNotAvailable unless library_data(gem) == YAML.load(meta_path.read)
+            when Sources::Local
+              raise CollectionNotAvailable unless fullpath.join(gem[:name], gem[:version]).symlink?
             end
           end
         end

lib/rbs/collection/config/lockfile_generator.rb

@@ -105,7 +105,7 @@ def generate
           unless locked
             source =
               if src_data
-                Sources.from_config_entry(src_data)
+                Sources.from_config_entry(src_data, base_directory: config.config_path.dirname)
               else
                 find_source(name: name)
               end

lib/rbs/collection/sources.rb

@@ -4,11 +4,12 @@
 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
           # @type var source_entry: Git::source_entry
@@ -18,6 +19,12 @@ def self.from_config_entry(source_entry)
             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'

lib/rbs/collection/sources/git.rb

@@ -45,7 +45,12 @@ def install(dest:, name:, version:, stdout:)
 
           gem_dir = dest.join(name, version)
 
-          if gem_dir.directory?
+          case
+          when gem_dir.symlink?
+            stdout.puts "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)
@@ -55,9 +60,11 @@ def install(dest:, name:, version:, stdout:)
               FileUtils.remove_entry_secure(gem_dir.to_s)
               _install(dest: dest, name: name, version: version)
             end
-          else
+          when !gem_dir.exist?
             stdout.puts "Installing #{format_config_entry(name, version)}"
             _install(dest: dest, name: name, version: version)
+          else
+            raise
           end
         end
 

lib/rbs/collection/sources/local.rb

@@ -0,0 +1,79 @@
+# 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)
+
+          case
+          when gem_dir.symlink? && gem_dir.readlink == from
+            stdout.puts "Using #{name}:#{version} (#{from})"
+          when gem_dir.symlink?
+            prev = gem_dir.readlink
+            gem_dir.unlink
+            _install(from, dest.join(name, version))
+            stdout.puts "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))
+            stdout.puts "Updating #{name}:#{version} from git source"
+          when !gem_dir.exist?
+            _install(from, dest.join(name, version))
+            stdout.puts "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

sig/collection/sources.rbs

@@ -1,8 +1,8 @@
 module RBS
   module Collection
     module Sources
-      def self.from_config_entry: (Git::source_entry) -> Git
-                                | (source_entry) -> t
+      def self.from_config_entry: (Git::source_entry, base_directory: Pathname) -> Git
+                                | (source_entry, base_directory: Pathname) -> t
 
       interface _Source
         def has?: (String name, String? version) -> boolish
@@ -13,11 +13,12 @@ module RBS
         def dependencies_of: (String name, String version) -> Array[manifest_dependency]?
       end
 
-      type t = Git | Stdlib | Rubygems
+      type t = Git | Stdlib | Rubygems | Local
 
       type source_entry = Git::source_entry
                         | Stdlib::source_entry
                         | Rubygems::source_entry
+                        | Local::source_entry
 
       type manifest_entry = {
         "dependencies" => Array[manifest_dependency]?,
@@ -126,6 +127,34 @@ module RBS
         def gems_versions: () -> Hash[String, Set[String]]
       end
 
+      class Local
+        include Base
+
+        type source_entry = {
+          'type' => 'local',
+          'path' => String,
+        }
+
+        attr_reader path: Pathname
+        attr_reader full_path: Pathname
+
+        def initialize: (path: String, base_directory: Pathname) -> void
+
+        def has?: (String name, String? version) -> boolish
+
+        def versions: (String name) -> Array[String]
+
+        def install: (dest: Pathname, name: String, version: String, stdout: CLI::_IO) -> void
+
+        def to_lockfile: () -> source_entry
+
+        def manifest_of: (String name, String version) -> manifest_entry?
+
+        private
+
+        def _install: (Pathname src, Pathname dest) -> void
+      end
+
       # signatures that are bundled in rbs gem under the stdlib/ directory
       class Stdlib