klenod-lsp 0.0.30 → 0.0.32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4e64b40c339a0f3b2e2338120f4fce1a631202dad834e0ca30566048db1f5f0f
-  data.tar.gz: 5458d0f7574457c17214c08e84db53ecb14677fa75f89dffe229de1f1dac8543
+  metadata.gz: f41f8fc46c0ec27d4ac70f84f6e60f9d3ad44f9fb50fafe7b4c13d71f935e071
+  data.tar.gz: 418a82a7691f2f70927806291379740e789d14795aa6e3afe8e2dbbee1825a74
 SHA512:
-  metadata.gz: a448b50f1d21c57317f13893c48ee376560cd4324900b2d8fbd1ab841c7d849c6f4d1be99237e4f7893149dafbeb15137ab997220c5ad6c968fb8245ff627e4a
-  data.tar.gz: 9093c27e1d87afee0d355d121371aa9c37ec555a03e1e9090dc52ee4a0e18f619406b2d8de7f83dfd81d8d0679991af3546f9c5865e5eccd6a04c982bb5eeea8
+  metadata.gz: 3bfa7e60f2ca9e16b1aa01398a3ef1f44cca62907436cb120e313b3fc79a9fb959f0e560f1a51a4dcc47021371de999a1a4d24755df517e658066815218a3822
+  data.tar.gz: 2bd0c26fe1062883602fc4ff9f91d17730e6327f40c9f33e0cc739833a313cb03a5384724faf88e459e57605809e2e73ff051270ba06ece03bdf60d94b871b77

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

@@ -22,7 +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/
+          FILTER_HEAD = /\A\s*:(?<name>\w+)/
 
           Occurrence = Data.define(:name, :span)
           Definition = Data.define(:module_id, :generated)
@@ -92,14 +92,16 @@ module Klenod
           # 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)
+          # Filters named in `except` are left out.
+          def filter_body_lines(lines, except: [])
             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
+                head = FILTER_HEAD.match(line_text)
+                filter_indent = (head && !except.include?(head[:name])) ? indent : nil
               end
             end
           end
@@ -117,7 +119,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

@@ -5,6 +5,7 @@ require "language_server-protocol"
 
 require_relative "../../text"
 require_relative "../imports"
+require_relative "classes"
 require_relative "ruby_regions"
 
 module Klenod
@@ -13,9 +14,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 +32,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)
 
@@ -39,10 +43,13 @@ module Klenod
 
           def diagnostics(analysis, workspace, index)
             lines = analysis.lines
-            bindings = Imports.bindings(lines)
+            bindings = Haml.bindings(lines)
             props_cache = {}
+            filter_body = Classes.filter_body_lines(lines)
 
             lines.each_with_index.flat_map do |line_text, line_index|
+              next [] if filter_body.include?(line_index)
+
               tag = TAG_LINE.match(line_text)
               next [] unless tag
 
@@ -57,16 +64,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 +107,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/rename.rb

@@ -2,6 +2,7 @@
 
 require_relative "../../text"
 require_relative "../imports"
+require_relative "classes"
 require_relative "ruby_regions"
 
 module Klenod
@@ -9,9 +10,9 @@ module Klenod
     module Languages
       class Haml
         # Where a bound constant appears in a Haml document: the `%Name` tags
-        # and the whole-word uses inside Ruby, meaning `:ruby` filters, script
-        # lines, tag attributes, and printed tag content. Plain text keeps
-        # its words.
+        # outside filters and the whole-word uses inside Ruby, meaning `:ruby`
+        # filters, script lines, tag attributes, and printed tag content.
+        # Plain text keeps its words.
         module Rename
           module_function
 
@@ -25,7 +26,10 @@ module Klenod
               end
             end
 
+            filter_body = Classes.filter_body_lines(lines)
             lines.each_with_index do |line_text, index|
+              next if filter_body.include?(index)
+
               Text.each_match(line_text, index, Haml::COMPONENT_TAG, group: :name) do |match, span|
                 next unless match[:name].split("::").first == name
 

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/haml.rb

@@ -68,13 +68,22 @@ module Klenod
 
         # `%Details` compiles to the constant `Details`, bound by an import in
         # the leading `:ruby` filter such as `Details = import("/components/Details")`.
+        # Imports in other filters, such as code samples in `:markdown`, are
+        # text.
         def self.bindings(lines)
-          Imports.bindings(lines)
+          text = Classes.filter_body_lines(lines, except: %w[ruby])
+          Imports.bindings(lines.reject.with_index { |_line_text, index| text.include?(index) })
+        end
+
+        def bindings(lines)
+          self.class.bindings(lines)
         end
 
         private
 
         def component_target_at(line_text, position, lines)
+          return nil if Classes.filter_body_lines(lines).include?(position.line)
+
           Text.each_match(line_text, position.line, COMPONENT_TAG, group: :name) do |match, span|
             next unless span.include?(position)
 

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)
@@ -209,6 +218,11 @@ module Klenod
           Syntax::Ruby
         end
 
+        # Constant names bound to imports in a document, keyed by name.
+        def bindings(lines)
+          Imports.bindings(lines)
+        end
+
         def definition(analysis, position, workspace, _index = nil)
           target = target_at(analysis, position)
           module_id = target && Imports.resolve(target, analysis, workspace)
@@ -367,11 +381,14 @@ module Klenod
         def usage_spans(importer_id, lines, specifiers)
           return [] unless importer_id.extname == ".haml"
 
-          names = Imports.bindings(lines).select { |_name, specifier| specifiers.include?(specifier) }.keys
+          names = Languages::Haml.bindings(lines).select { |_name, specifier| specifiers.include?(specifier) }.keys
           return [] if names.empty?
 
           spans = []
+          filter_body = Languages::Haml::Classes.filter_body_lines(lines)
           lines.each_with_index do |line_text, index|
+            next if filter_body.include?(index)
+
             Text.each_match(line_text, index, Languages::Haml::COMPONENT_TAG, group: :name) do |match, span|
               spans << span if names.include?(match[:name].split("::").first)
             end
@@ -382,7 +399,7 @@ module Klenod
         # Bindings whose constant is never used in the file. Languages give
         # the spans a constant occupies, the binding included.
         def unused_binding_diagnostics(analysis)
-          Imports.bindings(analysis.lines).filter_map do |name, _specifier|
+          bindings(analysis.lines).filter_map do |name, _specifier|
             spans = rename_spans(analysis, name)
             next if spans.length > 1
 
@@ -391,7 +408,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.32"
   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.32
 platform: ruby
 authors:
 - Andrés Alin
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.0.30
+        version: 0.0.32
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.0.30
+        version: 0.0.32
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
   requirement: !ruby/object:Gem::Requirement