tenseleyflow/fackr / 0c15f94

+# LSP Test 1: Hover Information (F1)

+# ===================================

+#

+# Instructions:

+# 1. Place cursor on any symbol below

+# 2. Press F1 to see hover information

+# 3. Press Escape to dismiss the hover popup

+#

+# Try hovering over:

+# - Function names (greet, calculate_area)

+# - Variable names (message, radius)

+# - Built-in functions (print, len, range)

+# - Type names (str, int, float, list)

+

+def greet(name: str) -> str:

+    """Return a greeting message for the given name."""

+    message = f"Hello, {name}!"

+    return message

+

+

+def calculate_area(radius: float) -> float:

+    """Calculate the area of a circle given its radius."""

+    import math

+    return math.pi * radius ** 2

+

+

+class Person:

+    """A simple Person class for testing hover."""

+

+    def __init__(self, name: str, age: int):

+        self.name = name

+        self.age = age

+

+    def introduce(self) -> str:

+        """Return an introduction string."""

+        return f"I'm {self.name}, {self.age} years old."

+

+

+# Test area - place cursor on these and press F1:

+result = greet("World")

+area = calculate_area(5.0)

+person = Person("Alice", 30)

+intro = person.introduce()

+

+numbers = [1, 2, 3, 4, 5]

+length = len(numbers)

+

+for i in range(10):

+    print(i)

+# LSP Test 2: Code Completion (Ctrl+Space)

+# =========================================

+#

+# Instructions:

+# 1. Place cursor after a dot or partial word

+# 2. Press Ctrl+Space to trigger completion

+# 3. Use Up/Down arrows to navigate suggestions

+# 4. Press Enter or Tab to accept a completion

+# 5. Press Escape to dismiss without completing

+#

+# Try completing at the marked positions below:

+

+import os

+import json

+from pathlib import Path

+

+# Test 1: Module completions

+# Place cursor after "os." and press Ctrl+Space

+path = os.  # <- complete here (try: getcwd, path, environ)

+

+# Test 2: String method completions

+# Place cursor after "text." and press Ctrl+Space

+text = "hello world"

+upper = text.  # <- complete here (try: upper, lower, split, strip)

+

+# Test 3: List method completions

+numbers = [3, 1, 4, 1, 5]

+numbers.  # <- complete here (try: append, sort, reverse, pop)

+

+# Test 4: Dict method completions

+data = {"name": "test", "value": 42}

+keys = data.  # <- complete here (try: keys, values, items, get)

+

+# Test 5: Path object completions

+p = Path("/tmp")

+p.  # <- complete here (try: exists, is_file, read_text, mkdir)

+

+# Test 6: Partial word completion

+# Type "pri" and press Ctrl+Space to complete to "print"

+# pri  # <- uncomment and complete

+

+# Test 7: Import completion

+# from pathlib import P  # <- complete after P (Path, PurePath, etc.)

+

+

+class MyClass:

+    def __init__(self):

+        self.value = 100

+        self.name = "test"

+

+    def process(self):

+        # Test 8: Self completions

+        return self.  # <- complete here (try: value, name)

+

+

+obj = MyClass()

+obj.  # <- complete here (try: value, name, process)

+# LSP Test 3: Diagnostics (Automatic)

+# ====================================

+#

+# Instructions:

+# 1. Diagnostics appear automatically as you edit

+# 2. Look for underlined/highlighted code indicating errors or warnings

+# 3. Errors and warnings should appear in the editor

+# 4. The status bar may show diagnostic counts

+#

+# This file contains intentional errors for testing:

+

+# Error 1: Undefined variable

+result = undefined_variable + 10

+

+# Error 2: Type mismatch (if using type checker)

+def add_numbers(a: int, b: int) -> int:

+    return a + b

+

+wrong_type = add_numbers("hello", "world")

+

+# Error 3: Import error

+from nonexistent_module import something

+

+# Error 4: Syntax-like issues

+def broken_function(x, y)  # Missing colon - uncomment to test

+    return x + y

+

+# Error 5: Unused variable (warning)

+unused_var = 42

+

+# Error 6: Undefined name in expression

+value = some_undefined_function()

+

+# Error 7: Wrong number of arguments

+def takes_two(a, b):

+    return a + b

+

+takes_two(1)  # Missing argument

+takes_two(1, 2, 3)  # Too many arguments

+

+# Error 8: Attribute error

+my_string = "hello"

+my_string.nonexistent_method()

+

+# Error 9: Invalid operation

+result = "string" + 42

+

+# Error 10: Redefinition (warning in some linters)

+def duplicate():

+    pass

+

+def duplicate():  # Redefined function

+    pass

+

+

+# Working code for comparison - this should have no errors:

+def working_function(name: str) -> str:

+    """This function works correctly."""

+    return f"Hello, {name}!"

+

+greeting = working_function("World")

+print(greeting)

+# LSP Test 4: Go to Definition (F12 or Ctrl+Click)

+# =================================================

+#

+# Instructions:

+# 1. Place cursor on a symbol (function, class, variable)

+# 2. Press F12 to jump to its definition

+# 3. This works for:

+#    - Functions defined in this file

+#    - Classes defined in this file

+#    - Imported modules/functions

+#    - Variables (jumps to assignment)

+#

+# Try going to definition on the marked symbols:

+

+

+def helper_function(x: int) -> int:

+    """A helper function defined at the top of the file."""

+    return x * 2

+

+

+class DataProcessor:

+    """A class for processing data."""

+

+    def __init__(self, data: list):

+        self.data = data

+

+    def process(self) -> list:

+        """Process the data and return results."""

+        return [self.transform(item) for item in self.data]

+

+    def transform(self, item):

+        """Transform a single item."""

+        return item * 2

+

+

+# Test 1: Go to function definition

+# Place cursor on "helper_function" and press F12

+result = helper_function(42)  # <- F12 on helper_function

+

+# Test 2: Go to class definition

+# Place cursor on "DataProcessor" and press F12

+processor = DataProcessor([1, 2, 3])  # <- F12 on DataProcessor

+

+# Test 3: Go to method definition

+# Place cursor on "process" and press F12

+output = processor.process()  # <- F12 on process

+

+# Test 4: Go to variable definition

+# Place cursor on "result" below and press F12

+print(result)  # <- F12 on result (should go to line 31)

+

+# Test 5: Go to imported function definition

+# Place cursor on "path" and press F12

+from os import path

+exists = path.exists("/tmp")  # <- F12 on path or exists

+

+# Test 6: Go to standard library

+# Place cursor on "print" and press F12 (may open stdlib)

+print("hello")  # <- F12 on print

+

+

+# Nested definitions for testing

+def outer_function():

+    """Outer function containing nested definitions."""

+

+    def inner_function():

+        """Inner function."""

+        return "inner"

+

+    return inner_function()

+

+

+# Test 7: Go to nested function

+nested_result = outer_function()  # <- F12 on outer_function

+# LSP Test 5: Find References (Shift+F12)

+# ========================================

+#

+# Instructions:

+# 1. Place cursor on a symbol

+# 2. Press Shift+F12 to find all references

+# 3. A list of locations should appear

+# 4. Navigate the list to jump to each reference

+#

+# This file has symbols used multiple times for testing:

+

+

+# A function that is called multiple times

+def calculate(value: int) -> int:

+    """Calculate something with the value."""

+    return value * 2 + 1

+

+

+# Test: Find all references to "calculate"

+# Place cursor on any "calculate" and press Shift+F12

+result1 = calculate(10)

+result2 = calculate(20)

+result3 = calculate(30)

+combined = calculate(result1) + calculate(result2)

+

+

+# A class used in multiple places

+class Counter:

+    """A simple counter class."""

+

+    def __init__(self):

+        self.count = 0

+

+    def increment(self):

+        self.count += 1

+

+    def get_count(self):

+        return self.count

+

+

+# Test: Find all references to "Counter"

+counter1 = Counter()

+counter2 = Counter()

+counters = [Counter(), Counter(), Counter()]

+

+# Test: Find all references to "increment"

+counter1.increment()

+counter1.increment()

+counter2.increment()

+for c in counters:

+    c.increment()

+

+

+# A variable used throughout

+MULTIPLIER = 10

+

+# Test: Find all references to "MULTIPLIER"

+value1 = 5 * MULTIPLIER

+value2 = 3 * MULTIPLIER

+value3 = MULTIPLIER * MULTIPLIER

+

+

+def use_multiplier(x):

+    return x * MULTIPLIER

+

+

+# A parameter used multiple times in a function

+def process_data(data):

+    """Process data in multiple ways."""

+    # Test: Find references to "data" parameter

+    if data is None:

+        return None

+    length = len(data)

+    first = data[0] if data else None

+    last = data[-1] if data else None

+    return {"data": data, "length": length, "first": first, "last": last}

+

+

+# Call the function

+process_data([1, 2, 3])

+process_data(["a", "b", "c"])

+# LSP Test 6: Rename Symbol (F2)

+# ===============================

+#

+# Instructions:

+# 1. Place cursor on a symbol you want to rename

+# 2. Press F2 to start rename

+# 3. Type the new name in the prompt

+# 4. Press Enter to apply the rename

+# 5. All references should be updated automatically

+#

+# WARNING: This modifies the file! You may want to save a backup first.

+# Use Ctrl+Z to undo if needed.

+

+

+# Test 1: Rename a function

+# Place cursor on "old_function_name" and press F2

+# Try renaming it to "new_function_name"

+def old_function_name(x):

+    """A function with a name that should be renamed."""

+    return x + 1

+

+

+result1 = old_function_name(10)

+result2 = old_function_name(20)

+result3 = old_function_name(old_function_name(5))

+

+

+# Test 2: Rename a class

+# Place cursor on "OldClassName" and press F2

+class OldClassName:

+    """A class that should be renamed."""

+

+    def __init__(self, value):

+        self.value = value

+

+

+obj1 = OldClassName(100)

+obj2 = OldClassName(200)

+instances = [OldClassName(i) for i in range(5)]

+

+

+# Test 3: Rename a variable

+# Place cursor on "counter" and press F2

+counter = 0

+counter += 1

+counter += 1

+print(counter)

+if counter > 0:

+    counter = counter * 2

+

+

+# Test 4: Rename a method

+# Place cursor on "old_method" and press F2

+class MyClass:

+    def old_method(self):

+        """Method to be renamed."""

+        return "old"

+

+    def caller(self):

+        return self.old_method()

+

+

+instance = MyClass()

+instance.old_method()

+result = instance.old_method()

+

+

+# Test 5: Rename a parameter

+# Place cursor on "param" and press F2

+def function_with_param(param):

+    """Function with a parameter to rename."""

+    if param is None:

+        return 0

+    return param * 2 + param

+

+

+function_with_param(10)

+function_with_param(param=20)

+

+

+# Test 6: Rename a constant

+# Place cursor on "MAX_VALUE" and press F2

+MAX_VALUE = 100

+

+if result1 < MAX_VALUE:

+    print("Under limit")

+

+threshold = MAX_VALUE // 2

+# LSP Test 7: Code Formatting (Ctrl+Shift+F)

+# ==========================================

+#

+# Instructions:

+# 1. Press Ctrl+Shift+F to format the entire file

+# 2. The LSP server (ruff or black via pylsp) will reformat the code

+# 3. Observe the changes in whitespace, line breaks, etc.

+#

+# This file has intentionally poor formatting for testing:

+

+x=1+2+3

+y    =    4    *    5

+z=x+y

+

+def badly_formatted(   a,b,c   ):

+    return a+b+c

+

+result=badly_formatted(1,2,3)

+

+my_list=[1,2,3,4,5,6,7,8,9,10]

+my_dict={"key1":"value1","key2":"value2","key3":"value3"}

+

+class BadlyFormatted:

+    def __init__(self,x,y):

+        self.x=x

+        self.y=y

+    def method(self):

+        return self.x+self.y

+

+if x>0:

+    print("positive")

+elif x<0:

+    print("negative")

+else:

+    print("zero")

+

+for i in range(10):

+    if i%2==0:

+        print(i)

+

+data=[{"name":"alice","age":30},{"name":"bob","age":25},{"name":"charlie","age":35}]

+

+long_string="this is a very long string that should probably be wrapped or reformatted in some way by the formatter"

+

+# Inconsistent quotes

+single = 'single quotes'

+double = "double quotes"

+mixed = 'mixed' + "quotes"

+

+# Extra blank lines

+

+

+

+# and missing blank lines

+def func1():

+    pass

+def func2():

+    pass

+def func3():

+    pass

+

+# Trailing whitespace on next line (may not be visible):

+x = 1

+

+# Long function call

+result = some_function_with_long_name(argument1, argument2, argument3, argument4, argument5, argument6)

+

+# Lambda

+f=lambda x:x*2

+

+# Comprehension

+squares=[x**2 for x in range(10)if x%2==0]

+# Multi-Cursor Test: Ctrl+D Select Next Match

+# =============================================

+#

+# Instructions:

+# 1. Place cursor on any word (e.g., "value" below)

+# 2. Press Ctrl+D to select that word

+# 3. Press Ctrl+D again to select the next occurrence and add a cursor

+# 4. Keep pressing Ctrl+D to select all occurrences

+# 5. Now type to replace all selected occurrences at once!

+# 6. Press Escape to collapse back to a single cursor

+#

+# Other multi-cursor shortcuts:

+# - Ctrl+Alt+Up: Add cursor above

+# - Ctrl+Alt+Down: Add cursor below

+# - Ctrl+Click: Add/remove cursor at click position

+# - Escape: Collapse to single cursor

+#

+# Test Area - Try selecting "value" with repeated Ctrl+D:

+

+value = 10

+another_value = value * 2

+third_value = value + another_value

+print(f"The value is {value}")

+

+def process_value(value):

+    """Process the value and return a new value."""

+    return value * value

+

+result = process_value(value)

+final_value = result + value

+

+

+# Test with "item" - has many occurrences:

+

+items = ["apple", "banana", "cherry"]

+

+for item in items:

+    print(item)

+    process_item(item)

+    if item == "banana":

+        special_item = item

+

+def process_item(item):

+    """Process a single item."""

+    return item.upper()

+

+first_item = items[0]

+last_item = items[-1]

+

+

+# Test with "count" - various contexts:

+

+count = 0

+max_count = 100

+

+while count < max_count:

+    count += 1

+    if count % 10 == 0:

+        print(f"count = {count}")

+

+final_count = count

+print(f"Final count: {final_count}")

+

+

+# Test with "data" - in a class:

+

+class DataProcessor:

+    def __init__(self, data):

+        self.data = data

+        self.processed_data = None

+

+    def process(self):

+        self.processed_data = self.transform_data(self.data)

+        return self.processed_data

+

+    def transform_data(self, data):

+        return [x * 2 for x in data]

+

+    def get_data(self):

+        return self.data

+

+processor = DataProcessor([1, 2, 3])

+data = processor.get_data()

+new_data = processor.process()

+

+

+# Test with "name" - strings and variables:

+

+name = "Alice"

+user_name = name

+full_name = f"{name} Smith"

+

+def greet_by_name(name):

+    print(f"Hello, {name}!")

+    return f"Greeted {name}"

+

+greet_by_name(name)

+greet_by_name("Bob")  # Different name

+

+names = [name, "Bob", "Charlie"]

+for n in names:

+    print(f"Name: {n}")

+

+

+# Test edge cases:

+

+# Same word at start and end of line

+test test test test test

+

+# Word appears in comments too

+# The word appears here and in code: word = "word"

+word = "word"

+print(word)  # prints the word

+

+

+# Numbers and underscores in identifiers:

+var_1 = 100

+var_2 = var_1 + var_1

+var_3 = var_1 * 2

+

+my_var_1 = var_1

+# LSP Test Files for fackr

+

+This directory contains Python files for testing LSP (Language Server Protocol)

+features in the fackr editor.

+

+## Prerequisites

+

+Make sure you have a Python LSP server installed:

+- `pylsp` (python-lsp-server): `pip install python-lsp-server`

+- `ruff`: `pip install ruff` (for linting/formatting)

+- `pyright`: `pip install pyright` (for type checking)

+

+## Test Files

+

+| File | Feature | Keybinding |

+|------|---------|------------|

+| 01_hover.py | Hover Information | F1 |

+| 02_completion.py | Code Completion | Ctrl+Space |

+| 03_diagnostics.py | Diagnostics | Automatic |

+| 04_goto_definition.py | Go to Definition | F12 |

+| 05_references.py | Find References | Shift+F12 |

+| 06_rename.py | Rename Symbol | F2 |

+| 07_formatting.py | Code Formatting | Ctrl+Shift+F |

+

+## How to Test

+

+1. Open fackr: `fackr test_lsp/01_hover.py`

+2. Follow the instructions in the comments at the top of each file

+3. Each file is self-contained and tests a specific LSP feature

+

+## LSP Keybindings Reference

+

+| Key | Action |

+|-----|--------|

+| F1 | Show hover information |

+| Ctrl+Space | Trigger code completion |

+| F12 | Go to definition |

+| Shift+F12 | Find all references |

+| F2 | Rename symbol |

+| Ctrl+Shift+F | Format document |

+| Alt+M | Open LSP server manager |

+

+## Troubleshooting

+

+- If LSP features don't work, check that the language server is running

+- Use Alt+M to open the server manager and verify server status

+- Some features may take a moment to initialize when first opening a file