klenod-lsp 0.0.32 → 0.0.33

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f41f8fc46c0ec27d4ac70f84f6e60f9d3ad44f9fb50fafe7b4c13d71f935e071
-  data.tar.gz: 418a82a7691f2f70927806291379740e789d14795aa6e3afe8e2dbbee1825a74
+  metadata.gz: 96ad37bd6ec750e9c26613eddc39034c1ee2b93837d4ef4d9b5427ca72b1072c
+  data.tar.gz: e17b0235f5cf7a6142cf5d6042a0f09a75158cf5aa21fb949f1460b0477772e4
 SHA512:
-  metadata.gz: 3bfa7e60f2ca9e16b1aa01398a3ef1f44cca62907436cb120e313b3fc79a9fb959f0e560f1a51a4dcc47021371de999a1a4d24755df517e658066815218a3822
-  data.tar.gz: 2bd0c26fe1062883602fc4ff9f91d17730e6327f40c9f33e0cc739833a313cb03a5384724faf88e459e57605809e2e73ff051270ba06ece03bdf60d94b871b77
+  metadata.gz: a933f96338104e6e505e1a28aecf759215b989c86487c6bb173628d97d52a0898c73e4bedff36270aa6d9fd35d31d91256b103ab5398b9650d781768b956e3dd
+  data.tar.gz: 497c4009b5f27f79c08a18f3b9022cb55376f3184152eacfa8f44fe3c039fcc986ba77a5f62dd4daba557fcc5cafcfc4d9ca7b69f76d5aa7444438efe5da6e92

data/README.md

@@ -17,8 +17,11 @@ application code.
 - Symbol rename within a Haml or Ruby file and import-preserving edits when
   files or directories move.
 - Prop and slot information for Haml components, including spelling suggestions
-  for unknown props.
-- Scoped CSS class definition, hover, completion, and validation in Haml.
+  for unknown props. Prop checks inspect the outer attribute hash and leave
+  nested hash keys and text inside values alone.
+- Scoped CSS class definition, hover, completion, and validation in Haml, for
+  `.name` shorthand, symbols in `class:` attributes such as
+  `class: [:name, { active: open? }]`, and `ClassNames[:name]` lookups.
 - Route lenses and hovers when `RouterPlugin` is configured.
 
 Ruby support is intentionally limited to Klenod imports and their bound

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

@@ -1,17 +1,20 @@
 # frozen_string_literal: true
 
 require "language_server-protocol"
+require "prism"
 
 require_relative "../../text"
+require_relative "ruby_regions"
 
 module Klenod
   module LSP
     module Languages
       class Haml
-        # CSS class names in a Haml component: the `.name` shorthand on tags
-        # and `ClassNames[:name]` lookups, checked against the class map of
-        # the companion stylesheet and any inline `:css` filters. The map
-        # comes from the graph's records, collected on demand.
+        # CSS class names in a Haml component: the `.name` shorthand on tags,
+        # symbols in a tag's `class:` attribute, and `ClassNames[:name]`
+        # lookups, checked against the class map of the companion stylesheet
+        # and any inline `:css` filters. The map comes from the graph's
+        # records, collected on demand.
         module Classes
           Interface = LanguageServer::Protocol::Interface
           Constant = LanguageServer::Protocol::Constant
@@ -21,6 +24,10 @@ module Klenod
           LOOKUP = /ClassNames\[:(?<name>[\w-]+)\]/
           SHORTHAND_PREFIX = /\A\s*(?:%[A-Za-z][\w:-]*)?(?:[.#][\w-]+)*\.(?<partial>[\w-]*)\z/
           LOOKUP_PREFIX = /ClassNames\[:(?<partial>[\w-]*)\z/
+          CLASS_KEY_PREFIX = /(?:(?<![\w:])class:|:class\s*=>|["']class["']\s*(?::|=>))/
+          SYMBOL_PREFIX = /(?:\A|[\s\[,]):(?<partial>[\w-]*)\z/
+          OPENERS = "[{("
+          CLOSERS = "]})"
           STYLE_KINDS = %i[companion_style inline_style].freeze
           FILTER_HEAD = /\A\s*:(?<name>\w+)/
 
@@ -65,24 +72,76 @@ 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.
+          # Shorthand and `class:` attribute 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 !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))
+              unless filter_body.include?(index)
+                if (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))
+                  end
                 end
+                found.concat(attribute_occurrences(line_text, index))
               end
               Text.each_match(line_text, index, LOOKUP, group: :name) { |match, span| found << Occurrence.new(match[:name], span) }
               found
             end
           end
 
+          # Symbols in the `class:` value of an attribute hash closed on the
+          # tag line: `class: :name`, `:class => :name`, symbols in an array,
+          # and symbol keys of a conditional hash such as `{ active: open? }`.
+          # Computed values are left alone, and strings are unscoped classes.
+          def attribute_occurrences(line_text, line_index)
+            head = RubyRegions::TAG_HEAD.match(line_text)
+            return [] unless head
+
+            RubyRegions.attribute_regions(line_text[head.end(0)..].to_s).flat_map do |region_offset, region|
+              next [] unless region.start_with?("{")
+
+              result = Prism.parse(region)
+              hash = result.value.statements.body.first
+              next [] unless result.success? && hash.is_a?(Prism::HashNode)
+
+              offset = head.end(0) + region_offset
+              hash.elements.flat_map do |element|
+                next [] unless element.is_a?(Prism::AssocNode) && class_key?(element.key)
+
+                class_symbols(element.value).map do |symbol|
+                  location = symbol.value_loc
+                  Occurrence.new(
+                    symbol.unescaped,
+                    Text::Span.new(line_index, offset + location.start_character_offset, offset + location.end_character_offset)
+                  )
+                end
+              end
+            end
+          end
+
+          def class_key?(node)
+            (node.is_a?(Prism::SymbolNode) || node.is_a?(Prism::StringNode)) && node.unescaped == "class"
+          end
+
+          def class_symbols(node)
+            case node
+            when Prism::SymbolNode
+              node.value_loc ? [node] : []
+            when Prism::ArrayNode
+              node.elements.flat_map { class_symbols(it) }
+            when Prism::HashNode, Prism::KeywordHashNode
+              node.elements.flat_map do |element|
+                (element.is_a?(Prism::AssocNode) && element.key.is_a?(Prism::SymbolNode)) ? class_symbols(element.key) : []
+              end
+            else
+              []
+            end
+          end
+
           def occurrence_at(lines, position)
             return nil unless lines[position.line]
 
@@ -148,7 +207,7 @@ module Klenod
 
           def completion_items(prefix, position, analysis, workspace, index)
             in_filter = filter_body_lines(analysis.lines).include?(position.line)
-            match = (!in_filter && SHORTHAND_PREFIX.match(prefix)) || LOOKUP_PREFIX.match(prefix)
+            match = (!in_filter && (SHORTHAND_PREFIX.match(prefix) || class_symbol_prefix(prefix))) || LOOKUP_PREFIX.match(prefix)
             return nil unless match
 
             map = map(analysis, workspace, index)
@@ -168,6 +227,26 @@ module Klenod
             end
           end
 
+          # A symbol being typed in a tag's `class:` value, such as
+          # `%p{ class: [:lead, :k`. A comma outside brackets ends the value,
+          # so the next attribute's symbols are not completed as classes.
+          def class_symbol_prefix(prefix)
+            return nil unless RubyRegions::TAG_HEAD.match?(prefix)
+
+            key = prefix.to_enum(:scan, CLASS_KEY_PREFIX).map { Regexp.last_match }.last
+            return nil unless key
+
+            value = prefix[key.end(0)..]
+            depth = 0
+            value.each_char do |char|
+              depth += 1 if OPENERS.include?(char)
+              depth -= 1 if CLOSERS.include?(char)
+              return nil if depth.negative? || (depth.zero? && char == ",")
+            end
+
+            SYMBOL_PREFIX.match(value)
+          end
+
           def style_record(module_id, workspace, index)
             index.record(module_id) || workspace.context.graph.collect_module(module_id)
           rescue StandardError, ScriptError

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

@@ -2,6 +2,7 @@
 
 require "did_you_mean"
 require "language_server-protocol"
+require "prism"
 
 require_relative "../../text"
 require_relative "../imports"
@@ -25,13 +26,6 @@ module Klenod
           # `key="value"`, `key=value`, or a bare boolean `key`; a consumed
           # value cannot be mistaken for the next key.
           HTML_KEY = /(?<![\w-])(?<key>[A-Za-z_][\w-]*)(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s()]+))?/
-          HASH_KEYS = [
-            /(?<=[{,]|\A)\s*(?<key>[A-Za-z_]\w*):(?!:)/,
-            /(?<=[{,]|\A)\s*"(?<key>[^"]+)":/,
-            /(?<=[{,]|\A)\s*:(?<key>\w+)\s*=>/,
-            /(?<=[{,]|\A)\s*"(?<key>[^"]+)"\s*=>/
-          ].freeze
-          SPLAT = /\*\*/
           CLOSERS = {"{" => "}", "(" => ")", "[" => "]"}.freeze
           # Props every component accepts: Haml passes `children`, `%Foo[item]`
           # passes `key`, and `slot` places the component in its parent's slot.
@@ -79,13 +73,15 @@ module Klenod
           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]
-              patterns.each do |pattern|
-                Text.each_match(inner, line_index, pattern, group: :key) do |match, span|
+              if region.start_with?("{")
+                hash_keys = explicit_hash_keys(region, line_index, offset + region_offset)
+                return nil unless hash_keys
+
+                keys.concat(hash_keys)
+              elsif region.start_with?("(")
+                Text.each_match(region[1...-1], line_index, HTML_KEY, group: :key) do |match, span|
                   start = offset + region_offset + 1 + span.start_character
                   keys << Key.new(match[:key], Text::Span.new(line_index, start, start + match[:key].length))
                 end
@@ -94,6 +90,27 @@ module Klenod
             keys.uniq { |key| key.span.start_character }
           end
 
+          # Only the outer hash supplies props. Keys in nested hashes, blocks,
+          # and strings belong to values, and only an outer splat prevents us
+          # from knowing which props the component receives.
+          def explicit_hash_keys(source, line_index, offset)
+            result = Prism.parse(source, partial_script: true)
+            hash = result.value.statements.body.first
+            return nil unless result.success? && hash.is_a?(Prism::HashNode)
+            return nil if hash.elements.any? { |element| element.is_a?(Prism::AssocSplatNode) }
+
+            hash.elements.filter_map do |element|
+              name, location =
+                case (key = element.key)
+                when Prism::SymbolNode then [key.value, key.value_loc]
+                when Prism::StringNode then [key.unescaped, key.content_loc]
+                else next
+                end
+              start = offset + source.byteslice(0, location.start_offset).length
+              Key.new(name, Text::Span.new(line_index, start, start + location.slice.length))
+            end
+          end
+
           def component_props(specifier, analysis, workspace, index)
             module_id = analysis.resolved_module_id_for(specifier) || workspace.resolve(specifier, importer_id: analysis.module_id)
             return nil unless module_id

data/lib/klenod/lsp/version.rb

@@ -2,6 +2,6 @@
 
 module Klenod
   module LSP
-    VERSION = "0.0.32"
+    VERSION = "0.0.33"
   end
 end

metadata

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