rbs 0.15.0 → 0.16.0

data/lib/rbs/environment_loader.rb

@@ -1,156 +1,130 @@
 module RBS
   class EnvironmentLoader
-    class UnknownLibraryNameError < StandardError
-      attr_reader :name
+    class UnknownLibraryError < StandardError
+      attr_reader :library
 
-      def initialize(name:)
-        @name = name
-        super "Cannot find a library or gem: `#{name}`"
+      def initialize(lib:)
+        @library = lib
+
+        super("Cannot find type definitions for library: #{lib.name} (#{lib.version || "[nil]"})")
       end
     end
 
-    LibraryPath = _ = Struct.new(:name, :path, keyword_init: true)
-    GemPath = _ = Struct.new(:name, :version, :path, keyword_init: true)
+    Library = _ = Struct.new(:name, :version, keyword_init: true)
+
+    attr_reader :core_root
+    attr_reader :repository
 
-    attr_reader :paths
-    attr_reader :stdlib_root
-    attr_reader :gem_vendor_path
+    attr_reader :libs
+    attr_reader :dirs
 
-    STDLIB_ROOT = Pathname(_ = __dir__) + "../../stdlib"
+    DEFAULT_CORE_ROOT = Pathname(_ = __dir__) + "../../core"
 
     def self.gem_sig_path(name, version)
-      Pathname(Gem::Specification.find_by_name(name, version).gem_dir) + "sig"
+      spec = Gem::Specification.find_by_name(name, version)
+      path = Pathname(spec.gem_dir) + "sig"
+      if path.directory?
+        [spec, path]
+      end
     rescue Gem::MissingSpecError
       nil
     end
 
-    def initialize(stdlib_root: STDLIB_ROOT, gem_vendor_path: nil)
-      @stdlib_root = stdlib_root
-      @gem_vendor_path = gem_vendor_path
-      @paths = []
-      @no_builtin = false
+    def initialize(core_root: DEFAULT_CORE_ROOT, repository: Repository.new)
+      @core_root = core_root
+      @repository = repository
+
+      @libs = []
+      @dirs = []
     end
 
-    def add(path: nil, library: nil)
+    def add(path: nil, library: nil, version: nil)
       case
       when path
-        @paths << path
+        dirs << path
       when library
-        name, version = self.class.parse_library(library)
-
-        case
-        when !version && path = stdlib?(name)
-          @paths << LibraryPath.new(name: name, path: path)
-        when (path = gem?(name, version))
-          @paths << GemPath.new(name: name, version: version, path: path)
-        else
-          raise UnknownLibraryNameError.new(name: library)
-        end
+        libs << Library.new(name: library, version: version)
       end
     end
 
-    def self.parse_library(lib)
-      _ = lib.split(/:/)
+    def has_library?(library:, version:)
+      self.class.gem_sig_path(library, version) || repository.lookup(library, version)
     end
 
-    def stdlib?(name)
-      path = stdlib_root + name
-      if path.directory?
-        path
+    def load(env:)
+      # @type var loaded: Array[[AST::Declarations::t, Pathname, source]]
+      loaded = []
+
+      each_decl do |decl, buf, source, path|
+        env << decl
+        loaded << [decl, path, source]
       end
+
+      loaded
     end
 
-    def gem?(name, version)
-      if path = gem_vendor_path
-        # Try vendored RBS first
-        gem_dir = path + name
-        if gem_dir.directory?
-          return gem_dir
-        end
+    def each_dir
+      if root = core_root
+        yield :core, root
       end
 
-      # Try ruby gem library
-      self.class.gem_sig_path(name, version)
-    end
+      libs.each do |lib|
+        unless has_library?(version: lib.version, library: lib.name)
+          raise UnknownLibraryError.new(lib: lib) 
+        end
 
-    def each_signature(path, immediate: true, &block)
-      if block
         case
-        when path.file?
-          if path.extname == ".rbs" || immediate
-            yield path
-          end
-        when path.directory?
-          path.children.each do |child|
-            each_signature child, immediate: false, &block
-          end
+        when from_gem = self.class.gem_sig_path(lib.name, lib.version)
+          yield lib, from_gem[1]
+        when from_repo = repository.lookup(lib.name, lib.version)
+          yield lib, from_repo
         end
-      else
-        enum_for :each_signature, path, immediate: immediate
       end
-    end
 
-    def each_library_path
-      paths.each do |path|
-        case path
-        when Pathname
-          yield path, path
-        when LibraryPath
-          yield path, path.path
-        when GemPath
-          yield path, path.path
-        end
+      dirs.each do |dir|
+        yield dir, dir
       end
     end
 
-    def no_builtin!(skip = true)
-      @no_builtin = skip
-      self
-    end
-
-    def no_builtin?
-      @no_builtin
-    end
-
-    def each_decl
-      if block_given?
-        # @type var signature_files: Array[[path | :stdlib, Pathname]]
-        signature_files = []
-
-        unless no_builtin?
-          each_signature(stdlib_root + "builtin") do |path|
-            signature_files << [:stdlib, path]
-          end
+    def each_file(path, immediate:, skip_hidden:, &block)
+      case
+      when path.file?
+        if path.extname == ".rbs" || immediate
+          yield path
         end
 
-        each_library_path do |library_path, pathname|
-          each_signature(pathname) do |path|
-            signature_files << [library_path, path]
+      when path.directory?
+        if path.basename.to_s.start_with?("_")
+          if skip_hidden
+            unless immediate
+              return 
+            end
           end
         end
 
-        signature_files.each do |lib_path, file_path|
-          buffer = Buffer.new(name: file_path.to_s, content: file_path.read)
-          Parser.parse_signature(buffer).each do |decl|
-            yield decl, buffer, file_path, lib_path
-          end
+        path.each_child do |child|
+          each_file(child, immediate: false, skip_hidden: skip_hidden, &block)
         end
-      else
-        enum_for :each_decl
       end
     end
 
-    def load(env:)
-      # @type var loadeds: Array[[AST::Declarations::t, Pathname, path | :stdlib]]
-      loadeds = []
+    def each_decl
+      files = Set[]
 
-      each_decl do |decl, buffer, file_path, lib_path|
-        env.buffers.push(buffer)
-        env << decl
-        loadeds << [decl, file_path, lib_path]
-      end
+      each_dir do |source, dir|
+        skip_hidden = !source.is_a?(Pathname)
+
+        each_file(dir, skip_hidden: skip_hidden, immediate: true) do |path|
+          next if files.include?(path)
 
-      loadeds
+          files << path
+          buffer = Buffer.new(name: path.to_s, content: path.read)
+
+          Parser.parse_signature(buffer).each do |decl|
+            yield decl, buffer, source, path
+          end
+        end
+      end
     end
   end
 end

data/lib/rbs/repository.rb

@@ -0,0 +1,121 @@
+module RBS
+  class Repository
+    DEFAULT_STDLIB_ROOT = Pathname(_ = __dir__) + "../../stdlib"
+
+    class GemRBS
+      attr_reader :name
+      attr_reader :paths
+
+      def initialize(name:)
+        @name = name
+        @paths = []
+        @versions = nil
+      end
+
+      def versions
+        load! unless @versions
+        @versions or raise
+      end
+
+      def load!
+        @versions = {}
+        versions = @versions or raise
+
+        paths.each do |gem_path|
+          gem_path.each_child(false) do |child|
+            next unless Gem::Version.correct?(child.to_s)
+
+            if version = Gem::Version.create(child.to_s)
+              unless version.prerelease?
+                path = gem_path + child
+
+                if prev = versions[version]
+                  RBS.logger.info { "Overwriting gem RBS in repository: gem=#{name}, prev_path=#{prev.path}, new_path=#{path}" }
+                end
+
+                versions[version] = VersionPath.new(gem: self, version: version, path: path)
+              end
+            end
+          end
+        end
+      end
+
+      def version_names
+        versions.keys.sort_by(&:version)
+      end
+
+      def oldest_version
+        oldest = version_names.first or raise
+        versions[oldest] or raise
+      end
+
+      def latest_version
+        latest = version_names.last or raise
+        versions[latest] or raise
+      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
+      end
+
+      def empty?
+        versions.empty?
+      end
+    end
+
+    VersionPath = _ = Struct.new(:gem, :version, :path, keyword_init: true)
+
+    attr_reader :dirs
+    attr_reader :gems
+
+    def initialize(no_stdlib: false)
+      @dirs = []
+      @gems = {}
+
+      unless no_stdlib
+        add(DEFAULT_STDLIB_ROOT)
+      end
+    end
+
+    def self.default
+      new().tap do |repo|
+        repo.add(DEFAULT_STDLIB_ROOT)
+      end
+    end
+
+    def add(dir)
+      dirs << dir
+
+      dir.each_child(false) do |child|
+        gem_name = child.to_s
+        gem_rbs = (gems[gem_name] ||= GemRBS.new(name: gem_name))
+        gem_rbs.paths << dir + child
+      end
+    end
+
+    def lookup(gem, version)
+      _, set = lookup_path(gem, version)
+      set&.path
+    end
+
+    def lookup_path(gem, version)
+      if gem_rbs = gems[gem]
+        unless gem_rbs.empty?
+          set = if v = Gem::Version.create(version)&.release
+            gem_rbs.find_best_version(v)
+          else
+            gem_rbs.latest_version
+          end
+
+          [gem_rbs, set]
+        end
+      end
+    end
+  end
+end

data/lib/rbs/test/setup.rb

@@ -2,6 +2,7 @@ require "rbs"
 require "rbs/test"
 require "optparse"
 require "shellwords"
+require "rbs/cli"
 
 include RBS::Test::SetupHelper
 
@@ -32,12 +33,13 @@ if filter.empty?
   exit 1
 end
 
-loader = RBS::EnvironmentLoader.new
+options = RBS::CLI::LibraryOptions.new()
+
 OptionParser.new do |opts|
-  opts.on("-r [LIB]") do |name| loader.add(library: name) end
-  opts.on("-I [DIR]") do |dir| loader.add(path: Pathname(dir)) end
+  options.setup_library_options(opts)
 end.parse!(opts)
 
+loader = options.loader
 env = RBS::Environment.from_loader(loader).resolve_type_names
 
 def match(filter, name)

data/lib/rbs/type_name.rb

@@ -16,7 +16,8 @@ module RBS
               when "_"
                 :interface
               else
-                raise
+                # Defaults to :class
+                :class
               end
     end
 

data/lib/rbs/vendorer.rb

@@ -1,9 +1,11 @@
 module RBS
   class Vendorer
     attr_reader :vendor_dir
+    attr_reader :loader
 
-    def initialize(vendor_dir:)
+    def initialize(vendor_dir:, loader:)
       @vendor_dir = vendor_dir
+      @loader = loader
     end
 
     def ensure_dir
@@ -21,27 +23,47 @@ module RBS
       end
     end
 
-    def stdlib!()
-      ensure_dir do
-        RBS.logger.info "Vendoring stdlib: #{EnvironmentLoader::STDLIB_ROOT} => #{vendor_dir + "stdlib"}..."
-        FileUtils.copy_entry EnvironmentLoader::STDLIB_ROOT, vendor_dir + "stdlib"
+    def copy!
+      # @type var paths: Set[[Pathname, Pathname]]
+      paths = Set[]
+
+      if core_root = loader.core_root
+        RBS.logger.info "Vendoring core RBSs in #{vendor_dir + "core"}..."
+        loader.each_file(core_root, immediate: false, skip_hidden: true) do |file_path|
+          paths << [file_path, Pathname("core") + file_path.relative_path_from(core_root)]
+        end
       end
-    end
 
-    def gem!(name, version)
-      ensure_dir do
-        sig_path = EnvironmentLoader.gem_sig_path(name, version)
-        RBS.logger.debug "Checking gem signature path: name=#{name}, version=#{version}, path=#{sig_path}"
+      loader.libs.each do |lib|
+        case
+        when (spec, path = EnvironmentLoader.gem_sig_path(lib.name, lib.version))
+          dest_dir = Pathname("#{lib.name}-#{spec.version}")
+
+          RBS.logger.info "Vendoring #{lib.name}(#{spec.version}) RBSs in #{vendor_dir + dest_dir}..."
 
-        if sig_path&.directory?
-          gems_dir = vendor_dir + "gems"
-          gems_dir.mkpath unless gems_dir.directory?
+          loader.each_file(path, skip_hidden: true, immediate: false) do |file_path|
+            paths << [file_path, dest_dir + file_path.relative_path_from(path)]
+          end
 
-          gem_dir = gems_dir + name
-          RBS.logger.info "Vendoring gem(#{name}:#{version}): #{sig_path} => #{gem_dir}..."
-          FileUtils.copy_entry sig_path, gem_dir
+        when (rbs, path = loader.repository.lookup_path(lib.name, lib.version))
+          dest_dir = Pathname("#{rbs.name}-#{path.version}")
+
+          RBS.logger.info "Vendoring #{lib.name}(#{path.version}) RBSs in #{vendor_dir + dest_dir}..."
+
+          loader.each_file(path.path, skip_hidden: true, immediate: false) do |file_path|
+            paths << [file_path, dest_dir + file_path.relative_path_from(path.path)]
+          end
+        else
+          RBS.logger.error "Couldn't find RBSs for #{lib.name} (#{lib.version}); skipping..."
         end
       end
+
+      paths.each do |from, to|
+        dest = vendor_dir + to
+        dest.parent.mkpath unless dest.parent.directory?
+
+        FileUtils.copy_file(from.to_s, dest.to_s)
+      end
     end
   end
 end