klenod-lsp 0.0.31 → 0.0.33

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0d5602eca5221374939807c3f33d43a9ac7794453a73b049e579a77ac229b551
-  data.tar.gz: 8dd3d801a3a62fc2405b84a221afef3a8ca9b2577a0a33bc3ac73a3a26579651
+  metadata.gz: 96ad37bd6ec750e9c26613eddc39034c1ee2b93837d4ef4d9b5427ca72b1072c
+  data.tar.gz: e17b0235f5cf7a6142cf5d6042a0f09a75158cf5aa21fb949f1460b0477772e4
 SHA512:
-  metadata.gz: cd906ff2ed13c6ab65b62b7215b5d8db1fe2b1999a41a0cd517d9dbe7a44f9ffb0729925c3eed473836f2fab32e61d478d58780445f504e3d13d19a0c10ca829
-  data.tar.gz: 3f3ca9d50efaaae456a5eece277790d95369e5276585d1c13b742dcf4144bf09a919d1eebbab4c7ecbfc2c58f60a829bae584cab42b681473f9ca50cc1c7ccab
+  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,8 +24,12 @@ 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*:\w/
+          FILTER_HEAD = /\A\s*:(?<name>\w+)/
 
           Occurrence = Data.define(:name, :span)
           Definition = Data.define(:module_id, :generated)
@@ -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]
 
@@ -92,14 +151,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
@@ -146,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)
@@ -166,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,9 +2,11 @@
 
 require "did_you_mean"
 require "language_server-protocol"
+require "prism"
 
 require_relative "../../text"
 require_relative "../imports"
+require_relative "classes"
 require_relative "ruby_regions"
 
 module Klenod
@@ -24,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.
@@ -42,10 +37,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
 
@@ -75,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
@@ -90,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/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.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

@@ -218,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)
@@ -376,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
@@ -391,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
 

data/lib/klenod/lsp/version.rb

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