rbs 2.8.4 → 3.0.0.dev.1

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

@@ -12,25 +12,22 @@ 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)
+          manifest_path = (lookup(name, version) or raise).join('manifest.yaml')
           YAML.safe_load(manifest_path.read) if manifest_path.exist?
         end
 
@@ -40,8 +37,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

@@ -11,7 +11,13 @@ module RBS
       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))
+          # @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 'stdlib'
           Stdlib.instance
         when 'rubygems'

data/lib/rbs/collection.rb

@@ -5,6 +5,7 @@ require 'bundler'
 
 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

@@ -65,7 +65,7 @@ module RBS
         def overload?
           case mem = member
           when AST::Members::MethodDefinition
-            mem.overload?
+            mem.overloading?
           else
             false
           end

data/lib/rbs/definition_builder/method_builder.rb

@@ -113,14 +113,14 @@ module RBS
                       build_method(
                         methods,
                         type,
-                        member: member.update(types: member.types.map {|type| type.sub(subst) }),
+                        member: member.update(overloads: member.overloads.map {|overload| overload.sub(subst) }),
                         accessibility: member.visibility || accessibility
                       )
                     when :singleton_instance
                       build_method(
                         methods,
                         type,
-                        member: member.update(types: member.types.map {|type| type.sub(subst) }),
+                        member: member.update(overloads: member.overloads.map {|overload| overload.sub(subst) }),
                         accessibility: :private
                       )
                     end
@@ -215,7 +215,7 @@ module RBS
       def build_method(methods, type, member:, accessibility:)
         defn = methods.methods[member.name] ||= Methods::Definition.empty(type: type, name: member.name)
 
-        if member.overload?
+        if member.overloading?
           defn.overloads << member
         else
           defn.accessibilities << accessibility