feat: add code href that links to the rule

- adds an href to the rule in the lsp which makes it possible to show
  a link to in the linting error that can take you to the code

Author: benfdking

sqlmesh/core/linter/rule.py

@@ -8,11 +8,20 @@
 
 import typing as t
 
+from sqlmesh.utils.pydantic import PydanticModel
+
 
 if t.TYPE_CHECKING:
     from sqlmesh.core.context import GenericContext
 
 
+class RuleLocation(PydanticModel):
+    """The location of a rule in a file."""
+
+    file_path: str
+    start_line: t.Optional[int] = None
+
+
 class _Rule(abc.ABCMeta):
     def __new__(cls: Type[_Rule], clsname: str, bases: t.Tuple, attrs: t.Dict) -> _Rule:
         attrs["name"] = clsname.lower()
@@ -40,6 +49,31 @@ def violation(self, violation_msg: t.Optional[str] = None) -> RuleViolation:
         """Create a RuleViolation instance for this rule"""
         return RuleViolation(rule=self, violation_msg=violation_msg or self.summary)
 
+    def get_definition_location(self) -> RuleLocation:
+        """Return the file path and position information for this rule.
+
+        This method returns information about where this rule is defined,
+        which can be used in diagnostics to link to the rule's documentation.
+
+        Returns:
+            A dictionary containing file path and position information.
+        """
+        import inspect
+
+        # Get the file where the rule class is defined
+        file_path = inspect.getfile(self.__class__)
+
+        try:
+            # Get the source code and line number
+            source_lines, start_line = inspect.getsourcelines(self.__class__)
+            return RuleLocation(
+                file_path=file_path,
+                start_line=start_line,
+            )
+        except (IOError, TypeError):
+            # Fall back to just returning the file path if we can't get source lines
+            return RuleLocation(file_path=file_path)
+
     def __repr__(self) -> str:
         return self.name
 

sqlmesh/lsp/main.py

@@ -293,6 +293,12 @@ def _diagnostic_to_lsp_diagnostic(
             return None
         with open(diagnostic.model._path, "r", encoding="utf-8") as file:
             lines = file.readlines()
+
+        # Get rule definition location for diagnostics link
+        rule_location = diagnostic.rule.get_definition_location()
+        rule_uri = f"file://{rule_location.file_path}#L{rule_location.start_line}"
+
+        # Use URI format to create a link for "related information"
         return types.Diagnostic(
             range=types.Range(
                 start=types.Position(line=0, character=0),
@@ -302,6 +308,9 @@ def _diagnostic_to_lsp_diagnostic(
             severity=types.DiagnosticSeverity.Error
             if diagnostic.violation_type == "error"
             else types.DiagnosticSeverity.Warning,
+            source="sqlmesh",
+            code=diagnostic.rule.name,
+            code_description=types.CodeDescription(href=rule_uri),
         )
 
     @staticmethod

tests/core/test_rule.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+import inspect
+import typing as t
+from unittest.mock import MagicMock
+
+import pytest
+from sqlmesh.core.model import Model
+from sqlmesh.core.linter.rule import Rule, RuleViolation
+
+
+class TestRule(Rule):
+    """A test rule for testing the get_definition_location method."""
+
+    def check_model(self, model: Model) -> t.Optional[RuleViolation]:
+        """The evaluation function that'll check for a violation of this rule."""
+        return None
+
+
+def test_get_definition_location():
+    """Test the get_definition_location method returns correct file and line information."""
+    # Create a mock context
+    mock_context = MagicMock()
+    rule = TestRule(mock_context)
+
+    # Get the expected location using the inspect module
+    expected_file = inspect.getfile(TestRule)
+    expected_source, expected_start_line = inspect.getsourcelines(TestRule)
+    expected_end_line = expected_start_line + len(expected_source) - 1
+
+    # Get the location using the Rule method
+    location = rule.get_definition_location()
+
+    # Assert the file path matches
+    assert location["file_path"] == expected_file
+
+    # Assert the line numbers match
+    assert location["start_line"] == expected_start_line
+    assert location["end_line"] == expected_end_line
+
+    # Test the fallback case for a class without source
+    with pytest.MonkeyPatch.context() as mp:
+        # Mock inspect.getsourcelines to raise an exception
+        def mock_getsourcelines(*args, **kwargs):
+            raise IOError("Mock error")
+
+        mp.setattr(inspect, "getsourcelines", mock_getsourcelines)
+
+        # Get the location with the mocked function
+        fallback_location = rule.get_definition_location()
+
+        # It should still have the file path
+        assert "file_path" in fallback_location
+        assert fallback_location["file_path"] == expected_file
+
+        # But not the line numbers
+        assert "start_line" not in fallback_location
+        assert "end_line" not in fallback_location