rbs 0.14.0 → 0.18.1

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/hook.rb

@@ -5,6 +5,8 @@ module RBS
   module Test
     module Hook
       OPERATORS = {
+        :[] => "indexlookup",
+        :[]= => "indexset",
         :== => "eqeq",
         :=== => "eqeqeq",
         :!= => "noteq",
@@ -25,26 +27,28 @@ module RBS
         :>> => "rshift",
         :~ => "tilda"
       }
-      def self.alias_names(target)
+      def self.alias_names(target, random)
+        suffix = "#{RBS::Test.suffix}_#{random}"
+
         case target
         when *OPERATORS.keys
           name = OPERATORS[target]
           [
-            "#{name}____with__#{Test.suffix}",
-            "#{name}____without__#{Test.suffix}"
+            "#{name}____with__#{suffix}",
+            "#{name}____without__#{suffix}"
           ]
         else
           aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1
 
           [
-            "#{aliased_target}__with__#{Test.suffix}#{punctuation}",
-            "#{aliased_target}__without__#{Test.suffix}#{punctuation}"
+            "#{aliased_target}__with__#{suffix}#{punctuation}",
+            "#{aliased_target}__without__#{suffix}#{punctuation}"
           ]
         end
       end
 
-      def self.setup_alias_method_chain(klass, target)
-        with_method, without_method = alias_names(target)
+      def self.setup_alias_method_chain(klass, target, random:)
+        with_method, without_method = alias_names(target, random)
 
         RBS.logger.debug "alias name: #{target}, #{with_method}, #{without_method}"
 
@@ -63,12 +67,12 @@ module RBS
         end
       end
 
-      def self.hook_method_source(prefix, method_name, key)
-        with_name, without_name = alias_names(method_name)
+      def self.hook_method_source(prefix, method_name, key, random:)
+        with_name, without_name = alias_names(method_name, random)
         full_method_name = "#{prefix}#{method_name}"
 
         [__LINE__ + 1, <<RUBY]
-def #{with_name}(*args)
+def #{with_name}(*args, &block)
   ::RBS.logger.debug { "#{full_method_name} with arguments: [" + args.map(&:inspect).join(", ") + "]" }
 
   begin
@@ -76,11 +80,17 @@ def #{with_name}(*args)
     block_calls = []
 
     if block_given?
+      receiver = self
       result = __send__(:"#{without_name}", *args) do |*block_args|
         return_from_block = false
 
         begin
-          block_result = yield(*block_args)
+          block_result = if receiver.equal?(self)
+                           yield(*block_args)
+                         else
+                           instance_exec(*block_args, &block)
+                         end
+
           return_from_block = true
         ensure
           exn = $!
@@ -152,17 +162,19 @@ RUBY
       end
 
       def self.hook_instance_method(klass, method, key:)
-        line, source = hook_method_source("#{klass}#", method, key)
+        random = SecureRandom.hex(4)
+        line, source = hook_method_source("#{klass}#", method, key, random: random)
 
         klass.module_eval(source, __FILE__, line)
-        setup_alias_method_chain klass, method
+        setup_alias_method_chain klass, method, random: random
       end
 
       def self.hook_singleton_method(klass, method, key:)
-        line, source = hook_method_source("#{klass}.",method, key)
+        random = SecureRandom.hex(4)
+        line, source = hook_method_source("#{klass}.",method, key, random: random)
 
         klass.singleton_class.module_eval(source, __FILE__, line)
-        setup_alias_method_chain klass.singleton_class, method
+        setup_alias_method_chain klass.singleton_class, method, random: random
       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/test/tester.rb

@@ -56,7 +56,10 @@ module RBS
                 RBS.logger.info { "Skipping ##{name} because of `#{reason}`..." }
               end
             else
-              if klass.instance_methods(false).include?(name) && !set.include?(name)
+              if !set.include?(name) && (
+                  name == :initialize ||
+                  klass.instance_methods(false).include?(name) ||
+                  klass.private_instance_methods(false).include?(name))
                 RBS.logger.info { "Setting up method hook in ##{name}..." }
                 Hook.hook_instance_method klass, name, key: instance_key
                 set << name

data/lib/rbs/test/type_check.rb

@@ -202,11 +202,17 @@ module RBS
       end
 
       def get_class(type_name)
-        const_cache[type_name] ||= Object.const_get(type_name.to_s)
+        const_cache[type_name] ||= begin
+                                     Object.const_get(type_name.to_s)
+                                   rescue NameError
+                                     nil
+                                   end
       end
 
       def is_double?(value)
         unchecked_classes.any? { |unchecked_class| Test.call(value, IS_AP, Object.const_get(unchecked_class))}
+      rescue NameError
+        false
       end
 
       def value(val, type)
@@ -219,7 +225,7 @@ module RBS
         when Types::Bases::Any
           true
         when Types::Bases::Bool
-          true
+          val.is_a?(TrueClass) || val.is_a?(FalseClass)
         when Types::Bases::Top
           true
         when Types::Bases::Bottom
@@ -235,7 +241,7 @@ module RBS
         when Types::Bases::Instance
           Test.call(val, IS_AP, self_class)
         when Types::ClassInstance
-          klass = get_class(type.name)
+          klass = get_class(type.name) or return false
           case
           when klass == ::Array
             Test.call(val, IS_AP, klass) && each_sample(val).all? {|v| value(v, type.args[0]) }
@@ -281,8 +287,13 @@ module RBS
             Test.call(val, IS_AP, klass)
           end
         when Types::ClassSingleton
-          klass = get_class(type.name)
-          val == klass
+          klass = get_class(type.name) or return false
+          singleton_class = begin
+                              klass.singleton_class
+                            rescue TypeError
+                              return false
+                            end
+          val.is_a?(singleton_class)
         when Types::Interface
           methods = Set.new(Test.call(val, METHODS))
           if (definition = builder.build_interface(type.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

data/lib/rbs/version.rb

@@ -1,3 +1,3 @@
 module RBS
-  VERSION = "0.14.0"
+  VERSION = "0.18.1"
 end

data/sig/cli.rbs

@@ -0,0 +1,58 @@
+module RBS
+  class CLI
+    class LibraryOptions
+      attr_accessor core_root: Pathname?
+
+      attr_reader libs: Array[String]
+      attr_reader dirs: Array[String]
+      attr_reader repos: Array[String]
+
+      def initialize: () -> void
+                    
+      def loader: () -> EnvironmentLoader
+    end
+
+    attr_reader stdout: IO
+    attr_reader stderr: IO
+
+    def initialize: (stdout: IO, stderr: IO) -> void
+                  
+    COMMANDS: Array[Symbol]
+
+    def library_parse: (OptionParser, options: LibraryOptions) -> void
+                     
+    def parse_logging_options: (OptionParser) -> void
+                             
+    def has_parser?: () -> bool
+                   
+    def run: (Array[String] args) -> void
+           
+    def run_ast: (Array[String], LibraryOptions) -> void
+               
+    def run_list: (Array[String], LibraryOptions) -> void
+                
+    def run_ancestors: (Array[String], LibraryOptions) -> void
+                     
+    def run_methods: (Array[String], LibraryOptions) -> void
+                   
+    def run_method: (Array[String], LibraryOptions) -> void
+                  
+    def run_validate: (Array[String], LibraryOptions) -> void
+                    
+    def run_constant: (Array[String], LibraryOptions) -> void
+                    
+    def run_paths: (Array[String], LibraryOptions) -> void
+                 
+    def run_prototype: (Array[String], LibraryOptions) -> void
+                     
+    def run_prototype_file: (String format, Array[String]) -> void
+                          
+    def run_vendor: (Array[String], LibraryOptions) -> void
+                  
+    def run_parse: (Array[String], LibraryOptions) -> void
+                 
+    def run_test: (Array[String], LibraryOptions) -> void
+                
+    def test_opt: (LibraryOptions) -> String?
+  end
+end