klenod-lsp 0.0.29 → 0.0.30

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c9a6fa41793e20e187ce323020348b56930bfb1d3ca84431ff124ea917cec1f7
-  data.tar.gz: 2a3ee612b372207dfbb7f4e86874d6237476d6159b701b68add8b55ff58c2f9d
+  metadata.gz: 4e64b40c339a0f3b2e2338120f4fce1a631202dad834e0ca30566048db1f5f0f
+  data.tar.gz: 5458d0f7574457c17214c08e84db53ecb14677fa75f89dffe229de1f1dac8543
 SHA512:
-  metadata.gz: 1e20ea7abb80b7c3cfd250d286adb2372ade08b85d9927794a63e13df10e1626be7b32b41135f57095da7a8243735dc9caac3b3a0fe82604028e3cd9246c6c85
-  data.tar.gz: b6cde269621b3ee407f5bf6a504be3537e16a2a21c34ec81d23a35f5c683e6233ece936c7192b8f248f7d9067dfb0fa1216ce0341a9892dd5b3a03868dd60f9f
+  metadata.gz: a448b50f1d21c57317f13893c48ee376560cd4324900b2d8fbd1ab841c7d849c6f4d1be99237e4f7893149dafbeb15137ab997220c5ad6c968fb8245ff627e4a
+  data.tar.gz: 9093c27e1d87afee0d355d121371aa9c37ec555a03e1e9090dc52ee4a0e18f619406b2d8de7f83dfd81d8d0679991af3546f9c5865e5eccd6a04c982bb5eeea8

data/README.md

@@ -43,6 +43,26 @@ bundle exec klenod lsp
 The `klenod` command comes from the `klenod` meta gem. The meta gem does not
 install `klenod-lsp` automatically.
 
+## Checking a whole project
+
+`klenod check` reports the editor's diagnostics for every Ruby, Haml, and CSS
+file under the source directory, like a linter:
+
+```sh
+bundle exec klenod check
+bundle exec klenod check src/components src/pages/Home.haml
+```
+
+```
+src/pages/Home.haml:4:3: warning: Card is imported but never used
+src/pages/Home.haml:9:12: error: Could not resolve "./Missing"
+1 error, 1 warning, 42 files checked.
+```
+
+It collects the whole module graph first, so cross-file diagnostics such as
+unknown props and scoped classes are included. Paths limit which files are
+reported. The command exits with status 1 when it reports any diagnostic.
+
 Configure the editor to run that command for `.haml` files. Ruby and CSS files
 can also use it alongside their usual language servers.
 
@@ -90,6 +110,17 @@ exit Klenod::LSP::Server.new(
 - `input:` and `output:` — the JSON-RPC streams; default to stdin and stdout.
 - `logger:` — server logging; defaults to stderr.
 
+`Klenod::LSP::Check` runs the same checks without a server. It takes the same
+`context:`, `entrypoints:`, and `logger:`:
+
+```ruby
+results = Klenod::LSP::Check.new(context: context, entrypoints: config.entrypoints).call
+exit Klenod::LSP::Check.report(results, output: $stdout).zero? ? 0 : 1
+```
+
+`call` accepts absolute file and directory paths to limit the files checked.
+`report` prints each diagnostic and a summary, and returns the diagnostic count.
+
 The web example has a complete runner at `example/web/bin/lsp`.
 
 ## How it works

data/lib/klenod/lsp/check.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "async"
+require "logger"
+
+require_relative "documents"
+require_relative "graph_index"
+require_relative "languages"
+require_relative "workspace"
+
+module Klenod
+  module LSP
+    # Reports the language server's diagnostics for every source file at
+    # once, for terminals and CI.
+    #
+    # The graph index collects the whole application first, as the server
+    # does in the background, so cross-file diagnostics such as unknown props
+    # and scoped classes are complete. Nothing is ever evaluated.
+    class Check
+      Constant = LanguageServer::Protocol::Constant
+
+      SEVERITY_NAMES = {
+        Constant::DiagnosticSeverity::ERROR => "error",
+        Constant::DiagnosticSeverity::WARNING => "warning",
+        Constant::DiagnosticSeverity::INFORMATION => "info",
+        Constant::DiagnosticSeverity::HINT => "hint"
+      }.freeze
+
+      # One checked file and its diagnostics, which may be empty.
+      Result = Data.define(:path, :diagnostics)
+
+      def initialize(context:, entrypoints: [], logger: nil)
+        @workspace = Workspace.new(context: context)
+        @index = GraphIndex.new(
+          workspace: @workspace,
+          entrypoints: entrypoints,
+          logger: logger || Logger.new($stderr, progname: "klenod-lsp", level: :warn)
+        )
+      end
+
+      # Checks the source files below `paths`, or all of them when `paths` is
+      # empty. Paths are absolute files or directories.
+      def call(paths = [])
+        Sync do |task|
+          @index.start(task)
+          @index.wait
+        end
+
+        @index.source_module_ids.filter_map do |module_id|
+          path = @workspace.path_for_module_id(module_id)
+          next unless selected?(path, paths)
+
+          document = Document.new(uri: @workspace.uri_for_path(path), path: path, module_id: module_id, text: File.read(path), version: nil)
+          language = Languages.for(document)
+          next unless language
+
+          Result.new(path: path, diagnostics: language.diagnostics(@workspace.analyze(module_id, document.text), @workspace, @index))
+        end
+      end
+
+      # Prints one `path:line:column: severity: message` entry per diagnostic
+      # with paths relative to `root`, then a summary. Returns the number of
+      # diagnostics.
+      def self.report(results, output:, root: Dir.pwd)
+        diagnostics = results.flat_map do |result|
+          result.diagnostics
+            .sort_by { |diagnostic| [diagnostic.range.start.line, diagnostic.range.start.character] }
+            .map { |diagnostic| [display_path(result.path, root), diagnostic] }
+        end
+
+        diagnostics.each do |path, diagnostic|
+          start = diagnostic.range.start
+          first_line, *rest = diagnostic.message.lines(chomp: true)
+          output.puts "#{path}:#{start.line + 1}:#{start.character + 1}: #{SEVERITY_NAMES.fetch(diagnostic.severity)}: #{first_line}"
+          rest.each { |line| output.puts "  #{line}" }
+        end
+
+        output.puts summary(results, diagnostics.map(&:last))
+        diagnostics.length
+      end
+
+      def self.summary(results, diagnostics)
+        files = "#{results.length} #{(results.length == 1) ? "file" : "files"} checked"
+        return "No problems found, #{files}." if diagnostics.empty?
+
+        counts = diagnostics.group_by(&:severity).sort.map do |severity, group|
+          name = SEVERITY_NAMES.fetch(severity)
+          "#{group.length} #{(group.length == 1) ? name : "#{name}s"}"
+        end
+        "#{counts.join(", ")}, #{files}."
+      end
+
+      def self.display_path(path, root)
+        relative = Pathname.new(path).relative_path_from(Pathname.new(root)).to_s
+        relative.start_with?("../") ? path : relative
+      end
+
+      private
+
+      def selected?(path, paths)
+        return true if paths.empty?
+
+        paths.any? { |selected| path == selected || path.start_with?("#{selected}/") }
+      end
+    end
+  end
+end

data/lib/klenod/lsp/cli.rb

@@ -7,24 +7,54 @@ require_relative "../lsp"
 module Klenod
   module LSP
     module CLI
+      # Loads the nearest klenod.config.rb and yields it from its base
+      # directory. Returns 1 when there is no config.
+      def self.with_config(output)
+        config_path = Klenod::Build::ConfigLoader.find
+        unless config_path
+          output.puts "Could not find klenod.config.rb"
+          return 1
+        end
+
+        config = nil
+        Dir.chdir(File.dirname(config_path)) do
+          config = Klenod::Build::ConfigLoader.load(config_path)
+        end
+
+        Dir.chdir(config.base_dir) { yield config }
+      end
+
       class Command < Samovar::Command
         self.description = "Start a language server for editors."
 
         def call
-          config_path = Klenod::Build::ConfigLoader.find
-          unless config_path
-            output.puts "Could not find klenod.config.rb"
-            return 1
+          CLI.with_config(output) do |config|
+            context = config.context(mode: :development, analysis: true)
+            Klenod::LSP::Server.new(context: context, entrypoints: config.entrypoints).start
           end
+        end
+      end
+
+      class CheckCommand < Samovar::Command
+        self.description = "Report language server diagnostics for every source file."
 
-          config = nil
-          Dir.chdir(File.dirname(config_path)) do
-            config = Klenod::Build::ConfigLoader.load(config_path)
+        many :paths, "Files or directories to check. Defaults to the whole source directory."
+
+        def call
+          root = Dir.pwd
+          paths = Array(@paths)
+          missing = paths.reject { |path| File.exist?(path) }
+          unless missing.empty?
+            missing.each { |path| output.puts "No such file or directory: #{path}" }
+            return 1
           end
+          # The source directory is a real path, so selections must be too.
+          paths = paths.map { |path| File.realpath(path) }
 
-          Dir.chdir(config.base_dir) do
+          CLI.with_config(output) do |config|
             context = config.context(mode: :development, analysis: true)
-            Klenod::LSP::Server.new(context: context, entrypoints: config.entrypoints).start
+            results = Klenod::LSP::Check.new(context: context, entrypoints: config.entrypoints).call(paths)
+            Klenod::LSP::Check.report(results, output: output, root: root).zero? ? 0 : 1
           end
         end
       end

data/lib/klenod/lsp/graph_index.rb

@@ -125,6 +125,18 @@ module Klenod
         end
       end
 
+      # Every Ruby, Haml, and CSS file under the source directory, skipping
+      # dotfiles and dot directories.
+      def source_module_ids
+        Dir.glob("**/*", base: @workspace.source_dir).sort.filter_map do |relative|
+          next if relative.split("/").any? { |segment| segment.start_with?(".") }
+          next unless ROOT_EXTENSIONS.include?(File.extname(relative))
+          next unless File.file?(File.join(@workspace.source_dir, relative))
+
+          Klenod::Build::ModuleId.new("app:/#{relative}")
+        end
+      end
+
       private
 
       def root_module_ids
@@ -133,13 +145,7 @@ module Klenod
           module_id = resolve_entrypoint(specifier)
           roots << module_id if module_id
         end
-        Dir.glob("**/*", base: @workspace.source_dir).sort.each do |relative|
-          next if relative.split("/").any? { |segment| segment.start_with?(".") }
-          next unless ROOT_EXTENSIONS.include?(File.extname(relative))
-          next unless File.file?(File.join(@workspace.source_dir, relative))
-
-          roots << Klenod::Build::ModuleId.new("app:/#{relative}")
-        end
+        roots.concat(source_module_ids)
         roots.uniq
       end
 

data/lib/klenod/lsp/languages/haml/classes.rb

@@ -22,6 +22,7 @@ module Klenod
           SHORTHAND_PREFIX = /\A\s*(?:%[A-Za-z][\w:-]*)?(?:[.#][\w-]+)*\.(?<partial>[\w-]*)\z/
           LOOKUP_PREFIX = /ClassNames\[:(?<partial>[\w-]*)\z/
           STYLE_KINDS = %i[companion_style inline_style].freeze
+          FILTER_HEAD = /\A\s*:\w/
 
           Occurrence = Data.define(:name, :span)
           Definition = Data.define(:module_id, :generated)
@@ -64,10 +65,14 @@ module Klenod
             end
           end
 
+          # Shorthand classes are only read outside filters, so a `:ruby`
+          # method chain such as `.freeze` is not a class. `ClassNames[:name]`
+          # lookups count everywhere.
           def occurrences(lines)
+            filter_body = filter_body_lines(lines)
             lines.each_with_index.flat_map do |line_text, index|
               found = []
-              if (head = TAG_HEAD.match(line_text))
+              if !filter_body.include?(index) && (head = TAG_HEAD.match(line_text))
                 offset = head.begin(:shorthand)
                 Text.each_match(head[:shorthand], index, SHORTHAND_CLASS, group: :name) do |match, span|
                   found << Occurrence.new(match[:name], span.with(start_character: span.start_character + offset, end_character: span.end_character + offset))
@@ -79,11 +84,24 @@ module Klenod
           end
 
           def occurrence_at(lines, position)
-            line_text = lines[position.line]
-            return nil unless line_text
+            return nil unless lines[position.line]
 
-            occurrences([line_text]).map { |occurrence| occurrence.with(span: occurrence.span.with(line: position.line)) }
-              .find { |occurrence| occurrence.span.include?(position) }
+            occurrences(lines).find { |occurrence| occurrence.span.include?(position) }
+          end
+
+          # Indexes of the lines inside filters: every line after a `:name`
+          # line that is blank or indented deeper than it, as Haml reads them.
+          # Indentation alone also works while the document does not parse.
+          def filter_body_lines(lines)
+            filter_indent = nil
+            lines.each_with_index.with_object(Set.new) do |(line_text, index), body|
+              indent = line_text[/\A\s*/].length
+              if filter_indent && (line_text.strip.empty? || indent > filter_indent)
+                body << index
+              else
+                filter_indent = line_text.match?(FILTER_HEAD) ? indent : nil
+              end
+            end
           end
 
           # Warnings for classes the stylesheets do not define. Components
@@ -127,7 +145,8 @@ module Klenod
           end
 
           def completion_items(prefix, position, analysis, workspace, index)
-            match = SHORTHAND_PREFIX.match(prefix) || LOOKUP_PREFIX.match(prefix)
+            in_filter = filter_body_lines(analysis.lines).include?(position.line)
+            match = (!in_filter && SHORTHAND_PREFIX.match(prefix)) || LOOKUP_PREFIX.match(prefix)
             return nil unless match
 
             map = map(analysis, workspace, index)

data/lib/klenod/lsp/version.rb

@@ -2,6 +2,6 @@
 
 module Klenod
   module LSP
-    VERSION = "0.0.29"
+    VERSION = "0.0.30"
   end
 end

data/lib/klenod/lsp.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "lsp/version"
+require_relative "lsp/check"
 require_relative "lsp/server"
 
 module Klenod

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: klenod-lsp
 version: !ruby/object:Gem::Version
-  version: 0.0.29
+  version: 0.0.30
 platform: ruby
 authors:
 - Andrés Alin
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.0.29
+        version: 0.0.30
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.0.29
+        version: 0.0.30
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
   requirement: !ruby/object:Gem::Requirement
@@ -48,6 +48,7 @@ files:
 - README.md
 - lib/klenod/lsp.rb
 - lib/klenod/lsp/analysis.rb
+- lib/klenod/lsp/check.rb
 - lib/klenod/lsp/cli.rb
 - lib/klenod/lsp/diagnostics.rb
 - lib/klenod/lsp/documents.rb