klenod-lsp 0.0.30 → 0.0.31

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4e64b40c339a0f3b2e2338120f4fce1a631202dad834e0ca30566048db1f5f0f
-  data.tar.gz: 5458d0f7574457c17214c08e84db53ecb14677fa75f89dffe229de1f1dac8543
+  metadata.gz: 0d5602eca5221374939807c3f33d43a9ac7794453a73b049e579a77ac229b551
+  data.tar.gz: 8dd3d801a3a62fc2405b84a221afef3a8ca9b2577a0a33bc3ac73a3a26579651
 SHA512:
-  metadata.gz: a448b50f1d21c57317f13893c48ee376560cd4324900b2d8fbd1ab841c7d849c6f4d1be99237e4f7893149dafbeb15137ab997220c5ad6c968fb8245ff627e4a
-  data.tar.gz: 9093c27e1d87afee0d355d121371aa9c37ec555a03e1e9090dc52ee4a0e18f619406b2d8de7f83dfd81d8d0679991af3546f9c5865e5eccd6a04c982bb5eeea8
+  metadata.gz: cd906ff2ed13c6ab65b62b7215b5d8db1fe2b1999a41a0cd517d9dbe7a44f9ffb0729925c3eed473836f2fab32e61d478d58780445f504e3d13d19a0c10ca829
+  data.tar.gz: 3f3ca9d50efaaae456a5eece277790d95369e5276585d1c13b742dcf4144bf09a919d1eebbab4c7ecbfc2c58f60a829bae584cab42b681473f9ca50cc1c7ccab

data/README.md

@@ -54,14 +54,17 @@ 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"
+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.

data/lib/klenod/lsp/check.rb

@@ -26,6 +26,20 @@ module Klenod
         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)
 
@@ -58,38 +72,78 @@ module Klenod
         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
+      # 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 { |diagnostic| [display_path(result.path, root), diagnostic] }
+            .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
-
-        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}" }
+        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
 
-        output.puts summary(results, diagnostics.map(&:last))
+        diagnostics = results.flat_map(&:diagnostics)
+        output.puts summary(results, diagnostics, paint)
         diagnostics.length
       end
 
-      def self.summary(results, diagnostics)
+      def self.summary(results, diagnostics, paint = ->(_name, text) { text })
         files = "#{results.length} #{(results.length == 1) ? "file" : "files"} checked"
-        return "No problems found, #{files}." if diagnostics.empty?
+        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)
-          "#{group.length} #{(group.length == 1) ? name : "#{name}s"}"
+          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

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

@@ -117,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

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.30"
+    VERSION = "0.0.31"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: klenod-lsp
 version: !ruby/object:Gem::Version
-  version: 0.0.30
+  version: 0.0.31
 platform: ruby
 authors:
 - Andrés Alin
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.0.30
+        version: 0.0.31
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.0.30
+        version: 0.0.31
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
   requirement: !ruby/object:Gem::Requirement