klenod-lsp 0.0.15

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

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+require "language_server-protocol"
+
+require_relative "../../text"
+
+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.
+        module Classes
+          Interface = LanguageServer::Protocol::Interface
+          Constant = LanguageServer::Protocol::Constant
+
+          TAG_HEAD = /\A\s*(?:%[A-Za-z][\w:-]*)?(?<shorthand>(?:[.#][\w-]+)+)/
+          SHORTHAND_CLASS = /\.(?<name>[\w-]+)/
+          LOOKUP = /ClassNames\[:(?<name>[\w-]+)\]/
+          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
+
+          Occurrence = Data.define(:name, :span)
+          Definition = Data.define(:module_id, :generated)
+
+          module_function
+
+          # Class name => Definition, or nil when the component has no styles
+          # at all, in which case class names are plain HTML classes. While
+          # the text does not transform, as with a half-typed attribute hash,
+          # the module's last collected record supplies the stylesheets.
+          def map(analysis, workspace, index)
+            style_ids = style_module_ids(analysis, index)
+            return nil if style_ids.empty?
+
+            style_ids.each_with_object({}) do |module_id, map|
+              record = style_record(module_id, workspace, index)
+              next unless record
+
+              record.metadata.fetch(:css_classes, {}).each do |key, generated|
+                name = key.to_s
+                next if name.start_with?("__")
+
+                map[name] ||= Definition.new(module_id, generated)
+              end
+            end
+          end
+
+          def style_module_ids(analysis, index)
+            if (transform = analysis.transform)
+              transform.dependencies.filter_map do |dependency|
+                next unless STYLE_KINDS.include?(dependency.kind)
+
+                dependency.metadata[:virtual_module_id] || analysis.resolved_module_id_for(dependency.specifier.to_s)
+              end
+            else
+              record = index.record(analysis.module_id)
+              return [] unless record
+
+              record.resolved_dependencies.filter_map { |resolved| resolved.module_id if STYLE_KINDS.include?(resolved.dependency.kind) }
+            end
+          end
+
+          def occurrences(lines)
+            lines.each_with_index.flat_map do |line_text, index|
+              found = []
+              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
+              Text.each_match(line_text, index, LOOKUP, group: :name) { |match, span| found << Occurrence.new(match[:name], span) }
+              found
+            end
+          end
+
+          def occurrence_at(lines, position)
+            line_text = lines[position.line]
+            return nil unless line_text
+
+            occurrences([line_text]).map { |occurrence| occurrence.with(span: occurrence.span.with(line: position.line)) }
+              .find { |occurrence| occurrence.span.include?(position) }
+          end
+
+          # Warnings for classes the stylesheets do not define. Components
+          # without styles are left alone.
+          def diagnostics(analysis, workspace, index)
+            map = map(analysis, workspace, index)
+            return [] unless map
+
+            occurrences(analysis.lines).filter_map do |occurrence|
+              next if map.key?(occurrence.name)
+
+              Interface::Diagnostic.new(
+                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 ")}"
+              )
+            end
+          end
+
+          # The selector in the stylesheet, or the `:css` filter line for an
+          # inline stylesheet.
+          def definition(occurrence, analysis, workspace, index)
+            map = map(analysis, workspace, index)
+            definition = map && map[occurrence.name]
+            return nil unless definition
+
+            selector_location(definition.module_id, occurrence.name, analysis, workspace, index)
+          end
+
+          def hover(occurrence, analysis, workspace, index)
+            map = map(analysis, workspace, index)
+            definition = map && map[occurrence.name]
+            return nil unless definition
+
+            value = "**.#{occurrence.name}** · `#{style_name(definition.module_id, analysis)}`\n\nRendered as `#{definition.generated}`"
+            Interface::Hover.new(
+              contents: Interface::MarkupContent.new(kind: Constant::MarkupKind::MARKDOWN, value: value),
+              range: occurrence.span.to_range
+            )
+          end
+
+          def completion_items(prefix, position, analysis, workspace, index)
+            match = SHORTHAND_PREFIX.match(prefix) || LOOKUP_PREFIX.match(prefix)
+            return nil unless match
+
+            map = map(analysis, workspace, index)
+            return [] unless map
+
+            partial = match[:partial]
+            range = Text::Span.new(position.line, position.character - partial.length, position.character).to_range
+            map.filter_map do |name, definition|
+              next unless name.start_with?(partial)
+
+              Interface::CompletionItem.new(
+                label: name,
+                kind: Constant::CompletionItemKind::PROPERTY,
+                detail: style_name(definition.module_id, analysis),
+                text_edit: Interface::TextEdit.new(range: range, new_text: name)
+              )
+            end
+          end
+
+          def style_record(module_id, workspace, index)
+            index.record(module_id) || workspace.context.graph.collect_module(module_id)
+          rescue StandardError, ScriptError
+            nil
+          end
+
+          def style_names(map, analysis)
+            map.values.map(&:module_id).uniq.map { |module_id| style_name(module_id, analysis) }
+          end
+
+          def style_name(module_id, analysis)
+            inline_origin(module_id, analysis) ? "inline :css" : module_id.path
+          end
+
+          def inline_origin(module_id, analysis)
+            return nil unless module_id.scheme == :app && module_id.path.start_with?("#{analysis.module_id.path}.inline.")
+
+            module_id
+          end
+
+          def selector_location(module_id, name, analysis, workspace, index)
+            record = style_record(module_id, workspace, index)
+            return nil unless record
+
+            selector = /\.#{Regexp.escape(name)}(?![\w-])/
+            css_lines = record.source.lines(chomp: true)
+            line_index = css_lines.index { |line_text| line_text.match?(selector) }
+
+            if inline_origin(module_id, analysis)
+              origin = workspace.context.graph.virtual_module_metadata(module_id)[:inline_css_origin]
+              uri = workspace.uri_for_module_id(analysis.module_id)
+              return nil unless origin && uri && line_index
+
+              haml_line = origin.fetch(:line_offset) + line_index
+              column = css_lines[line_index].index(selector) + (line_index.zero? ? origin.fetch(:column_offset) : 0)
+              Interface::Location.new(uri: uri, range: Text::Span.new(haml_line, column, column + name.length + 1).to_range)
+            else
+              uri = workspace.uri_for_module_id(module_id)
+              return nil unless uri
+
+              span = Text::Span.new(0, 0, 0)
+              if line_index
+                column = css_lines[line_index].index(selector)
+                span = Text::Span.new(line_index, column, column + name.length + 1)
+              end
+              Interface::Location.new(uri: uri, range: span.to_range)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "language_server-protocol"
+
+require_relative "../imports"
+require_relative "classes"
+
+module Klenod
+  module LSP
+    module Languages
+      class Haml
+        # Completes `%Component` tags from the constants bound by imports, and
+        # defers to the shared import path completion inside `import("...")`.
+        #
+        # Only the line up to the cursor is inspected, because the tag or
+        # literal is usually unterminated while it is being typed.
+        module Completion
+          Interface = LanguageServer::Protocol::Interface
+          Constant = LanguageServer::Protocol::Constant
+
+          COMPONENT_PREFIX = /%(?<partial>[A-Z][A-Za-z0-9_]*)?\z/
+
+          module_function
+
+          def call(analysis, position, workspace, index = nil)
+            line_text = analysis.lines[position.line]
+            return nil unless line_text
+
+            prefix = line_text[0...position.character].to_s
+            items = component_items(prefix, position, analysis, workspace) || Imports.completion_items(prefix, position, analysis, workspace)
+            items ||= Classes.completion_items(prefix, position, analysis, workspace, index) if index
+            return nil unless items
+
+            Interface::CompletionList.new(is_incomplete: false, items: items)
+          end
+
+          def component_items(prefix, position, analysis, workspace)
+            match = COMPONENT_PREFIX.match(prefix)
+            return nil unless match
+
+            partial = match[:partial].to_s
+            range = Imports.replacement_range(position, partial)
+
+            Haml.bindings(analysis.lines).filter_map do |name, specifier|
+              next unless name.start_with?(partial)
+
+              module_id = analysis.resolved_module_id_for(specifier) || workspace.resolve(specifier, importer_id: analysis.module_id)
+              Interface::CompletionItem.new(
+                label: name,
+                kind: Constant::CompletionItemKind::CLASS,
+                detail: module_id&.to_s || specifier,
+                text_edit: Interface::TextEdit.new(range: range, new_text: name)
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require "did_you_mean"
+require "language_server-protocol"
+
+require_relative "../../text"
+require_relative "../imports"
+require_relative "ruby_regions"
+
+module Klenod
+  module LSP
+    module Languages
+      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.
+        module Props
+          Interface = LanguageServer::Protocol::Interface
+          Constant = LanguageServer::Protocol::Constant
+
+          TAG_LINE = /\A\s*%(?<name>[A-Z][A-Za-z0-9_]*(?:::[A-Z][A-Za-z0-9_]*)*)(?:[.#][\w-]+)*/
+          # `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 = /\*\*/
+          IMPLICIT = %w[children].freeze
+
+          Key = Data.define(:name, :span)
+
+          module_function
+
+          def diagnostics(analysis, workspace, index)
+            lines = analysis.lines
+            bindings = Imports.bindings(lines)
+            props_cache = {}
+
+            lines.each_with_index.flat_map do |line_text, line_index|
+              tag = TAG_LINE.match(line_text)
+              next [] unless tag
+
+              constant = tag[:name].split("::").first
+              specifier = bindings[constant]
+              next [] unless specifier
+
+              keys = explicit_keys(line_text[tag.end(0)..].to_s, line_index, tag.end(0))
+              next [] if keys.nil? || keys.empty?
+
+              props = props_cache[specifier] ||= component_props(specifier, analysis, workspace, index)
+              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) }
+            end
+          end
+
+          # Keys from the tag's attribute regions, or nil when a splat 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)
+
+              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|
+                  start = offset + region_offset + 1 + span.start_character
+                  keys << Key.new(match[:key], Text::Span.new(line_index, start, start + match[:key].length))
+                end
+              end
+            end
+            keys.uniq { |key| key.span.start_character }
+          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
+
+            source = index.record(module_id)&.source
+            path = workspace.path_for_module_id(module_id)
+            source ||= File.read(path) if path && File.file?(path)
+            return nil unless source && module_id.extname == ".haml"
+
+            Imports.component_props(source, workspace)
+          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
+
+            Interface::Diagnostic.new(
+              range: key.span.to_range,
+              severity: Constant::DiagnosticSeverity::WARNING,
+              source: "klenod",
+              message: message
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "../../text"
+require_relative "../imports"
+require_relative "ruby_regions"
+
+module Klenod
+  module LSP
+    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.
+        module Rename
+          module_function
+
+          def spans(source, name)
+            lines = source.lines(chomp: true)
+            spans = []
+
+            RubyRegions.each(source, lines) do |line_index, start_character, text|
+              Imports.constant_spans(text, line_index, name).each do |span|
+                spans << span.with(start_character: span.start_character + start_character, end_character: span.end_character + start_character)
+              end
+            end
+
+            lines.each_with_index do |line_text, index|
+              Text.each_match(line_text, index, Haml::COMPONENT_TAG, group: :name) do |match, span|
+                next unless match[:name].split("::").first == name
+
+                spans << Text::Span.new(index, span.start_character, span.start_character + name.length)
+              end
+            end
+
+            spans.uniq.sort_by { |span| [span.line, span.start_character] }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "klenod/build/plugins/haml_plugin"
+
+module Klenod
+  module LSP
+    module Languages
+      class Haml
+        # 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-]+)*/
+
+          module_function
+
+          def each(source, lines, &block)
+            root = Klenod::Build::Plugins::HamlPlugin.parse_haml(source)
+            each_node(root.children, lines, &block)
+          rescue Klenod::Build::Error
+            lines.each_with_index do |line_text, index|
+              next unless line_text.match?(/\A\s*(?:-(?!#)|[=~])/)
+
+              yield index, 0, line_text
+            end
+          end
+
+          def each_node(nodes, lines, &block)
+            nodes.each do |node|
+              line_index = node.line - 1
+              case node.type
+              when :filter
+                if node.value[:name] == "ruby"
+                  node.value.fetch(:text).to_s.each_line.with_index(node.line) { |_text, index| yield index, 0, lines[index].to_s }
+                end
+              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)
+              end
+              each_node(node.children, lines, &block) unless node.type == :filter
+            end
+          end
+
+          def tag(node, line_text, line_index)
+            head = TAG_HEAD.match(line_text)
+            return unless head
+
+            rest_start = head.end(0)
+            rest = line_text[rest_start..].to_s
+            if node.value[:parse]
+              yield line_index, rest_start, rest
+            else
+              attribute_regions(rest).each { |offset, text| yield line_index, rest_start + offset, text }
+            end
+          end
+
+          # Attribute hashes and parenthesized attributes, matched by nesting.
+          def attribute_regions(rest)
+            regions = []
+            index = 0
+            while index < rest.length
+              opener = rest[index]
+              if (closer = {"{" => "}", "(" => ")", "[" => "]"}[opener])
+                depth = 0
+                start = index
+                while index < rest.length
+                  depth += 1 if rest[index] == opener
+                  depth -= 1 if rest[index] == closer
+                  index += 1
+                  break if depth.zero?
+                end
+                regions << [start, rest[start...index]]
+              else
+                break unless opener =~ /\s/ || regions.empty?
+
+                index += 1
+              end
+            end
+            regions
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require_relative "../diagnostics"
+require_relative "../symbols"
+require_relative "../text"
+require_relative "imports"
+require_relative "haml/classes"
+require_relative "haml/completion"
+require_relative "haml/props"
+require_relative "haml/rename"
+
+module Klenod
+  module LSP
+    module Languages
+      # Diagnostics and navigation for Haml component modules.
+      #
+      # The Haml parser reports lines only, so everything here recovers
+      # columns by scanning the original line text.
+      class Haml
+        include ImportNavigation
+
+        COMPONENT_TAG = /%(?<name>[A-Z][A-Za-z0-9_]*(?:::[A-Z][A-Za-z0-9_]*)*)/
+
+        def diagnostics(analysis, workspace = nil, index = nil)
+          diagnostics = Diagnostics.for_analysis(analysis)
+          diagnostics.concat(Classes.diagnostics(analysis, workspace, index)) if workspace && index
+          diagnostics.concat(Props.diagnostics(analysis, workspace, index)) if workspace && index
+          diagnostics.concat(unused_binding_diagnostics(analysis))
+        end
+
+        def completion(analysis, position, workspace, index = nil)
+          Completion.call(analysis, position, workspace, index)
+        end
+
+        def definition(analysis, position, workspace, index = nil)
+          occurrence = index && Classes.occurrence_at(analysis.lines, position)
+          return Classes.definition(occurrence, analysis, workspace, index) if occurrence
+
+          super(analysis, position, workspace)
+        end
+
+        def hover(analysis, position, workspace, index = nil)
+          occurrence = index && Classes.occurrence_at(analysis.lines, position)
+          return Classes.hover(occurrence, analysis, workspace, index) if occurrence
+
+          super(analysis, position, workspace)
+        end
+
+        def document_symbols(analysis)
+          Symbols.haml_document_symbols(analysis.source)
+        end
+
+        def rename_spans(analysis, name)
+          Rename.spans(analysis.source, name)
+        end
+
+        # The import literal or `%Component` tag under the cursor.
+        def target_at(analysis, position)
+          line_text = analysis.lines[position.line]
+          return nil unless line_text
+
+          Imports.target_at(line_text, position, syntax: syntax) || component_target_at(line_text, position, analysis.lines)
+        end
+
+        # `%Details` compiles to the constant `Details`, bound by an import in
+        # the leading `:ruby` filter such as `Details = import("/components/Details")`.
+        def self.bindings(lines)
+          Imports.bindings(lines)
+        end
+
+        private
+
+        def component_target_at(line_text, position, lines)
+          Text.each_match(line_text, position.line, COMPONENT_TAG, group: :name) do |match, span|
+            next unless span.include?(position)
+
+            constant_name = match[:name].split("::").first
+            specifier = self.class.bindings(lines)[constant_name]
+            return specifier && Imports::Target.new(kind: :component, name: match[:name], specifier: specifier, span: span)
+          end
+
+          nil
+        end
+      end
+    end
+  end
+end