steep 1.8.3 → 1.9.0.dev.2

data/lib/steep/project/dsl.rb

@@ -1,137 +1,154 @@
 module Steep
   class Project
     class DSL
-      class TargetDSL
-        attr_reader :name
-        attr_reader :sources
-        attr_reader :libraries
-        attr_reader :signatures
-        attr_reader :ignored_sources
+      module LibraryOptions
         attr_reader :stdlib_root
         attr_reader :core_root
-        attr_reader :repo_paths
-        attr_reader :code_diagnostics_config
-        attr_reader :project
         attr_reader :collection_config_path
 
-        def initialize(name, sources: [], libraries: [], signatures: [], ignored_sources: [], repo_paths: [], code_diagnostics_config: {}, project: nil, collection_config_path: nil)
-          @name = name
-          @sources = sources
-          @libraries = libraries
-          @signatures = signatures
-          @ignored_sources = ignored_sources
-          @core_root = nil
-          @stdlib_root = nil
-          @repo_paths = []
-          @code_diagnostics_config = code_diagnostics_config
-          @project = project
-          @collection_config_path = collection_config_path
+        def stdlib_path(core_root:, stdlib_root:)
+          @core_root = Pathname(core_root)
+          @stdlib_root = Pathname(stdlib_root)
         end
 
-        def initialize_copy(other)
-          @name = other.name
-          @sources = other.sources.dup
-          @libraries = other.libraries.dup
-          @signatures = other.signatures.dup
-          @ignored_sources = other.ignored_sources.dup
-          @repo_paths = other.repo_paths.dup
-          @core_root = other.core_root
-          @stdlib_root = other.stdlib_root
-          @code_diagnostics_config = other.code_diagnostics_config.dup
-          @project = other.project
-          @collection_config_path = other.collection_config_path
+        def repo_path(*paths)
+          @library_configured = true
+          repo_paths.push(*paths.map {|s| Pathname(s) })
         end
 
-        def check(*args)
-          sources.push(*args)
+        def collection_config(path)
+          @library_configured = true
+          @collection_config_path = project.absolute_path(path)
         end
 
-        def ignore(*args)
-          ignored_sources.push(*args)
+        def disable_collection
+          @library_configured = true
+          @collection_config_path = false
         end
 
         def library(*args)
+          @library_configured = true
           libraries.push(*args)
         end
 
-        def typing_options(level = nil, **hash)
-          Steep.logger.error "#typing_options is deprecated and has no effect as of version 0.46.0. Update your Steepfile as follows for (almost) equivalent setting:"
+        def repo_paths
+          @repo_paths ||= []
+        end
 
-          messages = [] #: Array[String]
+        def libraries
+          @libraries ||= []
+        end
 
-          messages << "# D = Steep::Diagnostic                          # Define a constant to shorten namespace"
+        def library_configured?
+          @library_configured
+        end
 
-          case level
-          when :strict
-            messages << "configure_code_diagnostics(D::Ruby.strict)       # :strict"
-          when :default
-            messages << "configure_code_diagnostics(D::Ruby.default)      # :default"
-          when :lenient
-            messages << "configure_code_diagnostics(D::Ruby.lenient)      # :lenient"
-          end
+        def to_library_options
+          config_path =
+            case collection_config_path
+            when Pathname
+              collection_config_path
+            when nil
+              default = project.absolute_path(RBS::Collection::Config::PATH)
+              if default.file?
+                default
+              end
+            when false
+              nil
+            end
 
-          messages.each do |msg|
-            Steep.logger.error "  #{msg}"
+          Options.new.tap do |options|
+            options.libraries.push(*libraries)
+            options.paths = Options::PathOptions.new(
+              core_root: core_root,
+              stdlib_root: stdlib_root,
+              repo_paths: repo_paths
+            )
+            options.collection_config_path = config_path
           end
+        end
+      end
 
-          config = [] #: Array[String]
+      module WithPattern
+        def check(*args)
+          sources.concat(args)
+        end
 
-          if hash[:allow_missing_definitions]
-            config << "hash[D::Ruby::MethodDefinitionMissing] = nil   # allow_missing_definitions"
-          end
+        def ignore(*args)
+          ignored_sources.concat(args)
+        end
 
-          if hash[:allow_fallback_any]
-            config << "hash[D::Ruby::FallbackAny] = nil               # allow_fallback_any"
-          end
+        def signature(*args)
+          signatures.concat(args)
+        end
 
-          if hash[:allow_unknown_constant_assignment]
-            config << "hash[D::Ruby::UnknownConstantAssigned] = nil   # allow_unknown_constant_assignment"
-          end
+        def ignore_signature(*args)
+          ignored_signatures.concat(args)
+        end
 
-          if hash[:allow_unknown_method_calls]
-            config << "hash[D::Ruby::NoMethod] = nil                  # allow_unknown_method_calls"
-          end
+        def sources
+          @sources ||= []
+        end
 
-          unless config.empty?
-            Steep.logger.error "  configure_code_diagnostics do |hash|"
-            config.each do |c|
-              Steep.logger.error "    #{c}"
-            end
-            Steep.logger.error "  end"
-          end
+        def ignored_sources
+          @ignored_sources ||= []
+        end
 
+        def signatures
+          @signatures ||= []
         end
 
-        def signature(*args)
-          signatures.push(*args)
+        def ignored_signatures
+          @ignored_signatures ||= []
         end
 
-        def update(name: self.name, sources: self.sources, libraries: self.libraries, ignored_sources: self.ignored_sources, signatures: self.signatures, project: self.project)
-          self.class.new(
-            name,
-            sources: sources,
-            libraries: libraries,
-            signatures: signatures,
-            ignored_sources: ignored_sources,
-            project: project,
-          )
+        def source_pattern
+          Pattern.new(patterns: sources, ignores: ignored_sources, ext: ".rb")
         end
 
-        def no_builtin!(value = true)
-          Steep.logger.error "`#no_builtin!` in Steepfile is deprecated and ignored. Use `#stdlib_path` instead."
+        def signature_pattern
+          Pattern.new(patterns: signatures, ignores: ignored_signatures, ext: ".rbs")
         end
+      end
+
+      class TargetDSL
+        include LibraryOptions
+        include WithPattern
+
+        attr_reader :name
+        attr_reader :project
+        attr_reader :unreferenced
+        attr_reader :groups
 
-        def vendor(dir = "vendor/sigs", stdlib: nil, gems: nil)
-          Steep.logger.error "`#vendor` in Steepfile is deprecated and ignored. Use `#stdlib_path` instead."
+        def initialize(name, project:)
+          @name = name
+          @core_root = nil
+          @stdlib_root = nil
+          @project = project
+          @collection_config_path = collection_config_path
+          @unreferenced = false
+          @groups = []
         end
 
-        def stdlib_path(core_root:, stdlib_root:)
-          @core_root = Pathname(core_root)
-          @stdlib_root = Pathname(stdlib_root)
+        def initialize_copy(other)
+          @name = other.name
+          @libraries = other.libraries.dup
+          @sources = other.sources.dup
+          @signatures = other.signatures.dup
+          @ignored_sources = other.ignored_sources.dup
+          @ignored_signatures = other.ignored_signatures.dup
+          @repo_paths = other.repo_paths.dup
+          @core_root = other.core_root
+          @stdlib_root = other.stdlib_root
+          @code_diagnostics_config = other.code_diagnostics_config.dup
+          @project = other.project
+          @collection_config_path = other.collection_config_path
+          @unreferenced = other.unreferenced
+          @groups = other.groups.dup
         end
 
-        def repo_path(*paths)
-          @repo_paths.push(*paths.map {|s| Pathname(s) })
+        def unreferenced!(value = true)
+          @unreferenced = value
         end
 
         def configure_code_diagnostics(hash = nil)
@@ -142,91 +159,99 @@ module Steep
           yield code_diagnostics_config if block_given?
         end
 
-        def project!
-          project or raise "TargetDSL doesn't have project (#{name})"
+        def code_diagnostics_config
+          @code_diagnostics_config ||= Diagnostic::Ruby.default.dup
         end
 
-        def collection_config(path)
-          @collection_config_path = project!.absolute_path(path)
-        end
+        def group(name, &block)
+          group = GroupDSL.new(name, self)
 
-        def disable_collection
-          @collection_config_path = false
+          Steep.logger.tagged "group=#{name}" do
+            group.instance_exec(&block) if block
+          end
+
+          groups << group
         end
       end
 
-      attr_reader :project
+      class GroupDSL
+        include WithPattern
+
+        attr_reader :name
+
+        attr_reader :target
+
+        attr_reader :code_diagnostics_config
 
-      @@templates = {
-        gemfile: TargetDSL.new(:gemfile).tap do |target|
-          target.check "Gemfile"
-          target.library "gemfile"
+        def initialize(name, target)
+          @name = name
+          @target = target
         end
-      }
 
-      def self.templates
-        @@templates
+        def configure_code_diagnostics(config = nil)
+          if block_given?
+            if code_diagnostics_config
+              if config
+                code_diagnostics_config.merge!(config)
+              end
+            else
+              @code_diagnostics_config = (config || target.code_diagnostics_config).dup
+            end
+
+            yield (code_diagnostics_config || raise)
+          else
+            @code_diagnostics_config = config&.dup
+          end
+        end
       end
 
+      include LibraryOptions
+
+      attr_reader :project
+
       def initialize(project:)
         @project = project
       end
 
-      def self.register_template(name, target)
-        templates[name] = target
-      end
-
       def self.parse(project, code, filename: "Steepfile")
         Steep.logger.tagged filename do
-          self.new(project: project).instance_eval(code, filename)
+          dsl = self.new(project: project)
+          dsl.instance_eval(code, filename)
+          project.global_options = dsl.to_library_options
         end
       end
 
-      def target(name, template: nil, &block)
-        target = if template
-                   self.class.templates[template]&.dup&.update(name: name, project: project) or
-                     raise "Unknown template: #{template}, available templates: #{@@templates.keys.join(", ")}"
-                 else
-                   TargetDSL.new(name, code_diagnostics_config: Diagnostic::Ruby.default.dup, project: project)
-                 end
-
-        Steep.logger.tagged "target=#{name}" do
-          target.instance_eval(&block) if block
+      def self.eval(project, &block)
+        Steep.logger.tagged "DSL.eval" do
+          dsl = self.new(project: project)
+          dsl.instance_exec(&block)
+          project.global_options = dsl.to_library_options
         end
+      end
 
-        source_pattern = Pattern.new(patterns: target.sources, ignores: target.ignored_sources, ext: ".rb")
-        signature_pattern = Pattern.new(patterns: target.signatures, ext: ".rbs")
+      def target(name, &block)
+        dsl = TargetDSL.new(name, project: project)
 
-        config_path =
-          case target.collection_config_path
-          when Pathname
-            target.collection_config_path
-          when nil
-            default = project.absolute_path(RBS::Collection::Config::PATH)
-            if default.file?
-              default
-            end
-          when false
-            nil
-          end
+        Steep.logger.tagged "target=#{name}" do
+          dsl.instance_eval(&block) if block
+        end
 
-        Project::Target.new(
-          name: target.name,
-          source_pattern: source_pattern,
-          signature_pattern: signature_pattern,
-          options: Options.new.tap do |options|
-            options.libraries.push(*target.libraries)
-            options.paths = Options::PathOptions.new(
-              core_root: target.core_root,
-              stdlib_root: target.stdlib_root,
-              repo_paths: target.repo_paths
-            )
-            options.collection_config_path = config_path
-          end,
-          code_diagnostics_config: target.code_diagnostics_config
-        ).tap do |target|
-          project.targets << target
+        target = Project::Target.new(
+          name: dsl.name,
+          source_pattern: dsl.source_pattern,
+          signature_pattern: dsl.signature_pattern,
+          options: dsl.library_configured? ? dsl.to_library_options : nil,
+          code_diagnostics_config: dsl.code_diagnostics_config,
+          project: project,
+          unreferenced: dsl.unreferenced
+        )
+
+        dsl.groups.each do
+          group = Group.new(target, _1.name, _1.source_pattern, _1.signature_pattern, _1.code_diagnostics_config || target.code_diagnostics_config)
+          target.groups << group
         end
+
+        project.targets << target
       end
     end
   end

data/lib/steep/project/group.rb

@@ -0,0 +1,31 @@
+module Steep
+  class Project
+    class Group
+      attr_reader :name
+      attr_reader :source_pattern
+      attr_reader :signature_pattern
+      attr_reader :target
+      attr_reader :code_diagnostics_config
+
+      def initialize(target, name, source_pattern, signature_pattern, code_diagnostics_config)
+        @target = target
+        @name = name
+        @source_pattern = source_pattern
+        @signature_pattern = signature_pattern
+        @code_diagnostics_config = code_diagnostics_config
+      end
+
+      def project
+        target.project
+      end
+
+      def possible_source_file?(path)
+        source_pattern =~ path
+      end
+
+      def possible_signature_file?(path)
+        signature_pattern =~ path
+      end
+    end
+  end
+end

data/lib/steep/project/pattern.rb

@@ -50,6 +50,10 @@ module Steep
         patterns.any? {|pat| File.fnmatch(pat, string, File::FNM_PATHNAME) } ||
           prefixes.any? {|prefix| File.fnmatch("#{prefix}**/*#{ext}", string, File::FNM_PATHNAME) }
       end
+
+      def empty?
+        patterns.empty?
+      end
     end
   end
 end

data/lib/steep/project/target.rb

@@ -2,29 +2,55 @@ module Steep
   class Project
     class Target
       attr_reader :name
-      attr_reader :options
+      attr_reader :target_options
 
       attr_reader :source_pattern
       attr_reader :signature_pattern
       attr_reader :code_diagnostics_config
+      attr_reader :project
+      attr_reader :unreferenced
+      attr_reader :groups
 
-      def initialize(name:, options:, source_pattern:, signature_pattern:, code_diagnostics_config:)
+      def initialize(name:, options:, source_pattern:, signature_pattern:, code_diagnostics_config:, project:, unreferenced:)
         @name = name
-        @options = options
+        @target_options = options
         @source_pattern = source_pattern
         @signature_pattern = signature_pattern
         @code_diagnostics_config = code_diagnostics_config
+        @project = project
+        @unreferenced = unreferenced
+        @groups = []
+      end
+
+      def options
+        target_options || project.global_options
       end
 
       def possible_source_file?(path)
-        source_pattern =~ path
+        if target = groups.find { _1.possible_source_file?(path) }
+          return target
+        end
+
+        if source_pattern =~ path
+          return self
+        end
+
+        nil
       end
 
       def possible_signature_file?(path)
-        signature_pattern =~ path
+        if target = groups.find { _1.possible_signature_file?(path) }
+          return target
+        end
+
+        if signature_pattern =~ path
+          return self
+        end
+
+        nil
       end
 
-      def new_env_loader(project:)
+      def new_env_loader()
         Target.construct_env_loader(options: options, project: project)
       end
 

data/lib/steep/project.rb

@@ -3,6 +3,7 @@ module Steep
     attr_reader :targets
     attr_reader :steepfile_path
     attr_reader :base_dir
+    attr_accessor :global_options
 
     def initialize(steepfile_path:, base_dir: nil)
       @targets = []
@@ -30,21 +31,48 @@ module Steep
       (base_dir + path).cleanpath
     end
 
+    def group_for_source_path(path)
+      path = relative_path(path)
+      targets.each do |target|
+        ret = target.possible_source_file?(path)
+        return ret if ret
+      end
+      nil
+    end
+
+    def group_for_path(path)
+      group_for_source_path(path) || group_for_signature_path(path)
+    end
+
+    def group_for_signature_path(path)
+      relative = relative_path(path)
+      targets.each do
+        ret = _1.possible_signature_file?(relative)
+        return ret if ret
+      end
+      nil
+    end
+
     def target_for_source_path(path)
-      targets.find do |target|
-        target.possible_source_file?(path)
+      case group = group_for_source_path(path)
+      when Target
+        group
+      when Group
+        group.target
       end
     end
 
-    def targets_for_path(path)
-      if target = target_for_source_path(path)
-        target
-      else
-        ts = targets.select {|target| target.possible_signature_file?(path) }
-        unless ts.empty?
-          ts
-        end
+    def target_for_signature_path(path)
+      case group = group_for_signature_path(path)
+      when Target
+        group
+      when Group
+        group.target
       end
     end
+
+    def target_for_path(path)
+      target_for_source_path(path) || target_for_signature_path(path)
+    end
   end
 end

data/lib/steep/server/custom_methods.rb

@@ -29,6 +29,14 @@ module Steep
         end
       end
 
+      module TypeCheckGroups
+        METHOD = "$/steep/typecheck/groups"
+
+        def self.notification(params)
+          { method: METHOD, params: params }
+        end
+      end
+
       module TypeCheck__Start
         METHOD = "$/steep/typecheck/start"
 
@@ -56,6 +64,14 @@ module Steep
           { id: id, result: result }
         end
       end
+
+      module Groups
+        METHOD = "$/steep/groups"
+
+        def self.response(id, result)
+          { id: id, result: result }
+        end
+      end
     end
   end
 end

data/lib/steep/server/delay_queue.rb

@@ -10,9 +10,6 @@ module Steep
 
         @thread = Thread.new do
           while (scheduled_at, proc = queue.pop)
-            # @type var scheduled_at: Time
-            # @type var proc: ^() -> void
-
             diff = scheduled_at - Time.now
             case
             when diff > 0.1

data/lib/steep/server/interaction_worker.rb

@@ -3,7 +3,6 @@ module Steep
     class InteractionWorker < BaseWorker
       include ChangeBuffer
 
-      ApplyChangeJob = _ = Class.new()
       HoverJob = _ = Struct.new(:id, :path, :line, :column, keyword_init: true)
       CompletionJob = _ = Struct.new(:id, :path, :line, :column, :trigger, keyword_init: true)
       SignatureHelpJob = _ = Struct.new(:id, :path, :line, :column, keyword_init: true)
@@ -31,8 +30,6 @@ module Steep
           end
 
           case job
-          when ApplyChangeJob
-            # nop
           when HoverJob
             writer.write(
               {
@@ -72,9 +69,7 @@ module Steep
 
       def queue_job(job)
         @last_job_mutex.synchronize do
-          unless job.is_a?(ApplyChangeJob)
-            @last_job = job
-          end
+          @last_job = job
         end
         queue << job
       end
@@ -86,20 +81,17 @@ module Steep
 
         when "textDocument/didChange"
           collect_changes(request)
-          queue_job ApplyChangeJob.new
 
         when CustomMethods::FileLoad::METHOD
           params = request[:params] #: CustomMethods::FileLoad::params
           input = params[:content]
           load_files(input)
-          queue_job ApplyChangeJob.new
 
         when CustomMethods::FileReset::METHOD
           params = request[:params] #: CustomMethods::FileReset::params
           uri = params[:uri]
           text = params[:content]
           reset_change(uri: uri, text: text)
-          queue_job ApplyChangeJob.new
 
         when "textDocument/hover"
           id = request[:id]
@@ -183,8 +175,7 @@ module Steep
                 is_incomplete: false,
                 items: completion_items
               )
-            when (targets = project.targets_for_path(job.path)).is_a?(Array)
-              target = targets[0] or raise
+            when target = project.target_for_signature_path(job.path)
               sig_service = service.signature_services[target.name] or raise
               relative_path = job.path