klenod-lsp 0.0.29 → 0.0.31

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c9a6fa41793e20e187ce323020348b56930bfb1d3ca84431ff124ea917cec1f7
-  data.tar.gz: 2a3ee612b372207dfbb7f4e86874d6237476d6159b701b68add8b55ff58c2f9d
+  metadata.gz: 0d5602eca5221374939807c3f33d43a9ac7794453a73b049e579a77ac229b551
+  data.tar.gz: 8dd3d801a3a62fc2405b84a221afef3a8ca9b2577a0a33bc3ac73a3a26579651
 SHA512:
-  metadata.gz: 1e20ea7abb80b7c3cfd250d286adb2372ade08b85d9927794a63e13df10e1626be7b32b41135f57095da7a8243735dc9caac3b3a0fe82604028e3cd9246c6c85
-  data.tar.gz: b6cde269621b3ee407f5bf6a504be3537e16a2a21c34ec81d23a35f5c683e6233ece936c7192b8f248f7d9067dfb0fa1216ce0341a9892dd5b3a03868dd60f9f
+  metadata.gz: cd906ff2ed13c6ab65b62b7215b5d8db1fe2b1999a41a0cd517d9dbe7a44f9ffb0729925c3eed473836f2fab32e61d478d58780445f504e3d13d19a0c10ca829
+  data.tar.gz: 3f3ca9d50efaaae456a5eece277790d95369e5276585d1c13b742dcf4144bf09a919d1eebbab4c7ecbfc2c58f60a829bae584cab42b681473f9ca50cc1c7ccab

data/README.md

@@ -43,6 +43,29 @@ 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
+  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.
+Output is colored in a terminal; set `NO_COLOR` to turn colors off.
+
 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 +113,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,161 @@
+# 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
+
+      COLORS = {
+        path: "\e[4m",
+        location: "\e[2m",
+        error: "\e[31m",
+        warning: "\e[33m",
+        info: "\e[1;34m",
+        hint: "\e[2m",
+        detail: "\e[2m",
+        code: "\e[36m",
+        success: "\e[1;32m"
+      }.freeze
+      RESET = "\e[0m"
+      CODE = /`([^`\n]+)`/
+
+      # 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 the diagnostics grouped by file, like ESLint's stylish format,
+      # with paths relative to `root`, then a summary:
+      #
+      #   src/pages/Home.haml
+      #     4:3   warning  `Card` is imported but never used
+      #     9:12  error    Could not resolve "./Missing"
+      #
+      #   1 error, 1 warning, 42 files checked.
+      #
+      # Columns share one width across all files, so every row lines up.
+      # Returns the number of diagnostics. Colors default to on for a terminal
+      # unless NO_COLOR is set.
+      def self.report(results, output:, root: Dir.pwd, color: color?(output))
+        paint = color ? ->(name, text) { "#{COLORS.fetch(name)}#{text}#{RESET}" } : ->(_name, text) { text }
+        files = results.reject { |result| result.diagnostics.empty? }.map do |result|
+          rows = result.diagnostics
+            .sort_by { |diagnostic| [diagnostic.range.start.line, diagnostic.range.start.character] }
+            .map do |diagnostic|
+              start = diagnostic.range.start
+              [start.line + 1, start.character + 1, SEVERITY_NAMES.fetch(diagnostic.severity), diagnostic.message]
+            end
+          [result.path, rows]
+        end
+        rows = files.flat_map(&:last)
+
+        # Line numbers align right and columns left, so the colons line up.
+        line_width = rows.map { |line, _, _, _| line.to_s.length }.max
+        column_width = rows.map { |_, column, _, _| column.to_s.length }.max
+        severity_width = rows.map { |_, _, severity, _| severity.length }.max
+        indent = " " * (2 + line_width.to_i + 1 + column_width.to_i + 2 + severity_width.to_i + 2)
+
+        files.each do |path, file_rows|
+          output.puts paint.call(:path, display_path(path, root))
+          file_rows.each do |line, column, severity, message|
+            location = "#{line.to_s.rjust(line_width)}:#{column.to_s.ljust(column_width)}"
+            first_line, *rest = message.lines(chomp: true)
+            first_line = highlight(first_line) if color
+            output.puts "  #{paint.call(:location, location)}  #{paint.call(severity.to_sym, severity.ljust(severity_width))}  #{first_line}"
+            rest.each { |text| output.puts "#{indent}#{color ? highlight(text, COLORS.fetch(:detail)) : text}" }
+          end
+          output.puts
+        end
+
+        diagnostics = results.flat_map(&:diagnostics)
+        output.puts summary(results, diagnostics, paint)
+        diagnostics.length
+      end
+
+      def self.summary(results, diagnostics, paint = ->(_name, text) { text })
+        files = "#{results.length} #{(results.length == 1) ? "file" : "files"} checked"
+        return "#{paint.call(:success, "No problems found")}, #{files}." if diagnostics.empty?
+
+        counts = diagnostics.group_by(&:severity).sort.map do |severity, group|
+          name = SEVERITY_NAMES.fetch(severity)
+          paint.call(name.to_sym, "#{group.length} #{(group.length == 1) ? name : "#{name}s"}")
+        end
+        "#{counts.join(", ")}, #{files}."
+      end
+
+      # Colors backticked names such as `Card` in place of their backticks.
+      # `base` is the color of the surrounding text, restored after each name.
+      def self.highlight(text, base = nil)
+        highlighted = text.gsub(CODE) { "#{COLORS.fetch(:code)}#{Regexp.last_match(1)}#{RESET}#{base}" }
+        base ? "#{base}#{highlighted}#{RESET}" : highlighted
+      end
+
+      def self.color?(output, env = ENV)
+        return false if env.key?("NO_COLOR")
+
+        output.respond_to?(:tty?) && output.tty?
+      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
@@ -99,7 +117,7 @@ module Klenod
                 range: occurrence.span.to_range,
                 severity: Constant::DiagnosticSeverity::WARNING,
                 source: "klenod",
-                message: "Unknown CSS class #{occurrence.name.inspect}: not defined in #{style_names(map, analysis).join(" or ")}"
+                message: "Unknown CSS class `#{occurrence.name}`: not defined in #{style_names(map, analysis).map { |name| "`#{name}`" }.join(" or ")}"
               )
             end
           end
@@ -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/languages/haml/props.rb

@@ -13,9 +13,9 @@ module Klenod
       class Haml
         # The props a `%Component` tag passes, checked against the props the
         # component reads. Only keys written out on the tag line count:
-        # `%Foo(bar="1"){ baz: 2 }`. A splat makes the tag unverifiable, and
-        # a component that reads no `$props`, or reads them all with `$*`,
-        # is left alone.
+        # `%Foo(bar="1"){ baz: 2 }`. A splat or attributes spanning several
+        # lines make the tag unverifiable, and a component that reads no
+        # `$props`, or reads them all with `$*`, is left alone.
         module Props
           Interface = LanguageServer::Protocol::Interface
           Constant = LanguageServer::Protocol::Constant
@@ -31,7 +31,10 @@ module Klenod
             /(?<=[{,]|\A)\s*"(?<key>[^"]+)"\s*=>/
           ].freeze
           SPLAT = /\*\*/
-          IMPLICIT = %w[children].freeze
+          CLOSERS = {"{" => "}", "(" => ")", "[" => "]"}.freeze
+          # Props every component accepts: Haml passes `children`, `%Foo[item]`
+          # passes `key`, and `slot` places the component in its parent's slot.
+          IMPLICIT = %w[children key slot].freeze
 
           Key = Data.define(:name, :span)
 
@@ -57,16 +60,23 @@ module Klenod
               next [] unless props && !props.splat && !props.names.empty?
 
               allowed = props.names + IMPLICIT
-              keys.reject { |key| allowed.include?(key.name) }.map { |key| diagnostic(key, tag[:name], allowed) }
+              keys.reject { |key| allowed.include?(prop_name(key.name)) }.map { |key| diagnostic(key, tag[:name], allowed) }
             end
           end
 
-          # Keys from the tag's attribute regions, or nil when a splat makes
-          # them unknowable.
+          # Components receive `video-id` as `$video_id`, like `merge_props`
+          # in the Haml plugin's helper source.
+          def prop_name(key)
+            key.tr("-", "_")
+          end
+
+          # Keys from the tag's attribute regions, or nil when a splat or an
+          # attribute list continuing on the next lines makes them unknowable.
           def explicit_keys(rest, line_index, offset)
             keys = []
             RubyRegions.attribute_regions(rest).each do |region_offset, region|
               return nil if region.start_with?("{") && region.match?(SPLAT)
+              return nil unless region.end_with?(CLOSERS.fetch(region[0]))
 
               patterns = region.start_with?("(") ? [HTML_KEY] : HASH_KEYS
               inner = region[1...-1]
@@ -93,9 +103,9 @@ module Klenod
           end
 
           def diagnostic(key, tag_name, allowed)
-            suggestion = DidYouMean::SpellChecker.new(dictionary: allowed).correct(key.name).first
-            message = "Unknown prop #{key.name.inspect} for #{tag_name}"
-            message += "; did you mean #{suggestion.inspect}?" if suggestion
+            suggestion = DidYouMean::SpellChecker.new(dictionary: allowed).correct(prop_name(key.name)).first
+            message = "Unknown prop `#{key.name}` for `#{tag_name}`"
+            message += "; did you mean `#{suggestion}`?" if suggestion
 
             Interface::Diagnostic.new(
               range: key.span.to_range,

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

@@ -9,7 +9,8 @@ module Klenod
         # Executable Ruby regions in a Haml document: Ruby filters, script
         # lines, tag attributes, and printed tag content.
         module RubyRegions
-          TAG_HEAD = /%[A-Za-z][\w:-]*(?:[.#][\w-]+)*/
+          # `%name.class#id`, or `.class#id` for an implicit `%div`.
+          TAG_HEAD = /\A\s*(?:%[A-Za-z][\w:-]*(?:[.#][\w-]+)*|(?:[.#][\w-]+)+)/
 
           module_function
 
@@ -35,22 +36,50 @@ module Klenod
               when :script, :silent_script
                 yield line_index, 0, lines[line_index].to_s
               when :tag
-                tag(node, lines[line_index].to_s, line_index, &block)
+                tag(node, lines, line_index, &block)
               end
               each_node(node.children, lines, &block) unless node.type == :filter
             end
           end
 
-          def tag(node, line_text, line_index)
+          def tag(node, lines, line_index, &block)
+            line_text = lines[line_index].to_s
             head = TAG_HEAD.match(line_text)
             return unless head
 
             rest_start = head.end(0)
             rest = line_text[rest_start..].to_s
+            regions = attribute_regions(rest)
             if node.value[:parse]
               yield line_index, rest_start, rest
             else
-              attribute_regions(rest).each { |offset, text| yield line_index, rest_start + offset, text }
+              regions.each { |offset, text| yield line_index, rest_start + offset, text }
+            end
+            continuation(lines, line_index + 1, regions.last&.last, parse: node.value[:parse], &block)
+          end
+
+          # The lines of an attribute region left open on the tag line, up to
+          # and including its closer. A tag printing Ruby content keeps the
+          # rest of the closing line too: `}= value`.
+          def continuation(lines, line_index, region, parse: false)
+            return unless region
+
+            opener = region[0]
+            closer = {"{" => "}", "(" => ")", "[" => "]"}.fetch(opener)
+            depth = region.count(opener) - region.count(closer)
+            while depth.positive? && line_index < lines.length
+              line_text = lines[line_index].to_s
+              length = line_text.length
+              line_text.each_char.with_index do |char, index|
+                depth += 1 if char == opener
+                depth -= 1 if char == closer
+                next unless depth.zero?
+
+                length = index + 1 unless parse
+                break
+              end
+              yield line_index, 0, line_text[0...length]
+              line_index += 1
             end
           end
 

data/lib/klenod/lsp/languages/imports.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "language_server-protocol"
+require "prism"
 
 require "klenod/build/module_id"
 
@@ -116,6 +117,7 @@ module Klenod
           tokens = []
           slots = []
           Haml::RubyRegions.each(source, lines) do |_line_index, _start_character, ruby_source|
+            ruby_source = without_comment(ruby_source)
             tokens.concat(ruby_source.scan(PROP_TOKEN).flatten)
             slots.concat(ruby_source.scan(SLOT_TOKEN).flatten)
           end
@@ -126,6 +128,13 @@ module Klenod
           )
         end
 
+        # The Ruby before a trailing `# comment`, so commented-out code reads
+        # no props. Prism tells a comment from `#` inside a string.
+        def without_comment(ruby_source)
+          comment = Prism.lex(ruby_source).value.find { |token, _state| token.type == :COMMENT }&.first
+          comment ? ruby_source.byteslice(0, comment.location.start_offset) : ruby_source
+        end
+
         # Completion items for the path being typed inside an import literal,
         # or nil when the line prefix is not inside one.
         def completion_items(prefix, position, analysis, workspace, syntax: Syntax::Ruby)
@@ -391,7 +400,7 @@ module Klenod
               range: span.to_range,
               severity: Imports::Constant::DiagnosticSeverity::WARNING,
               source: "klenod",
-              message: "#{name} is imported but never used",
+              message: "`#{name}` is imported but never used",
               tags: [Imports::Constant::DiagnosticTag::UNNECESSARY]
             )
           end

data/lib/klenod/lsp/version.rb

@@ -2,6 +2,6 @@
 
 module Klenod
   module LSP
-    VERSION = "0.0.29"
+    VERSION = "0.0.31"
   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.31
 platform: ruby
 authors:
 - Andrés Alin
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.0.29
+        version: 0.0.31
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.0.29
+        version: 0.0.31
 - !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