352 |
353 | int main()
354 | {
355 | int number = 2;
356 |
357 | switch (number)
358 | {
359 | case 1:
360 | printf("Number is 1\n");
361 | break;
362 | case 2:
363 | printf("Number is 2\n");
364 | break;
365 | case 3:
366 | printf("Number is 3\n");
367 | break;
368 | default:
369 | printf("Number is not 1, 2, or 3\n");
370 | break;
371 | }
372 |
373 | return 0;
374 | }
--------------------------------------------------------------------------------
/src/playgrounds/playground.cproj:
--------------------------------------------------------------------------------
1 | // Method 1: Regular method
2 | public void MyMethod()
3 | {
4 | // Method body
5 | }
6 |
7 | // Method 2: Static method
8 | public static void MyStaticMethod()
9 | {
10 | // Method body
11 | }
12 |
13 | // Method 3: Method with parameters
14 | public void MyMethodWithParameters(int param1, string param2)
15 | {
16 | // Method body
17 | }
18 |
19 |
20 | // Method 5: Expression-bodied method
21 | public int MyExpressionBodiedMethod() => 42;
22 |
23 | // Method 6: Local function
24 | void MyLocalFunction()
25 | {
26 | // Method body
27 | }
--------------------------------------------------------------------------------
/src/playgrounds/playground.css:
--------------------------------------------------------------------------------
1 | :root {
2 | --base-size: 16px;
3 | }
4 |
5 | .element {
6 | font-size: calc(var(--base-size) * 2);
7 | transition-duration: 0.5s;
8 | image-resolution: 300dpi;
9 | animation-timing-function: steps(4, end);
10 | transform: rotate(45deg);
11 | width: 50%;
12 | width: calc(100% - 50px);
13 | color: var(--main-color);
14 | content: attr(data-content);
15 | display: none;
16 | position: absolute;
17 | background-image: url('path/to/image.jpg');
18 | color: #ff0000;
19 | background-color: rgb(255, 0, 0);
20 | border-color: rgba(255, 0, 0, 0.5);
21 | color: hsl(0, 100%, 50%);
22 | color: hsla(0, 100%, 50%, 0.5);
23 | width: 100px;
24 | font-size: 1.5em;
25 | margin: 10%;
26 | opacity: 0.75;
27 | z-index: 10;
28 | content: 'Hello, World!';
29 | }
30 |
--------------------------------------------------------------------------------
/src/playgrounds/playground.go:
--------------------------------------------------------------------------------
1 | // this is a comment
2 | // this is a comment
3 | // this is a comment
4 | // this is a comment
5 | // this is a comment
6 |
7 | package main
8 |
9 | import (
10 | "fmt"
11 | )
12 |
13 | const h = 3
14 |
15 | var (
16 | e = 3
17 | fdg int = 3
18 | )
19 |
20 | var f int = 3
21 |
22 | const fl int = 3
23 |
24 | type St struct {
25 | A int
26 | }
27 |
28 | func main() {
29 | c := St{
30 | A: 4,
31 | }
32 |
33 | b, err := func() (int, error) {
34 | return 3, nil
35 | }()
36 |
37 | _ = "this is an string to make testing easier"
38 |
39 | f := func() {
40 |
41 | }
42 | _ = f
43 | fmt.Errorf("err: %v", err)
44 |
45 | fd := retA(5)
46 |
47 | fn := retFunc(func() any {
48 | return 3
49 | })
50 |
51 | _ = b
52 | _ = fn
53 | _ = fd
54 | _ = c
55 | }
56 |
57 | func callOther() string {
58 | fmt.Printf("hellot")
59 | fmt.Printf("hellot")
60 | fmt.Printf("hellot")
61 | fmt.Printf("hellot")
62 | fmt.Printf("hellot")
63 | fmt.Printf("hellot")
64 | return ""
65 | }
66 |
67 | type b struct {
68 | In int
69 | Out string
70 | }
71 |
72 | func (f *b) Call(a int) string {
73 | e = 4
74 |
75 | g := []int{1, 2, 3}
76 | g = []int{1, 2, 3}
77 | _ = g
78 |
79 | if a == 3 {
80 | fmt.Printf("Hello i")
81 | fmt.Printf("alskjdfklsjdf")
82 | fmt.Printf("Hello ii")
83 | fmt.Printf("Hello ")
84 | } else if a == 4 {
85 |
86 | fmt.Printf("Hello there")
87 | fmt.Printf("Hello there")
88 | //this is a cmment
89 | } else {
90 |
91 | //comment
92 | }
93 |
94 | fmt.Printf("%d", a)
95 | for i := range 10 {
96 | fmt.Println(i, i, i)
97 | fmt.Println(i)
98 | fmt.Println(i)
99 | }
100 |
101 | switch a {
102 | case 4:
103 | fmt.Println("he")
104 | break
105 | case 5:
106 | fmt.Println("he")
107 | break
108 |
109 | }
110 |
111 | asdf := retA(4)
112 | _ = asdf
113 | return "this is a full line to help with testing"
114 | }
115 |
116 | func retFunc(f func() any) func() any {
117 | return f
118 | }
119 |
120 | func retA(b int) int {
121 | return 3
122 | }
123 |
124 | func checkParam(s string, c []byte) {
125 | }
126 |
--------------------------------------------------------------------------------
/src/playgrounds/playground.java:
--------------------------------------------------------------------------------
1 | // // 1. Regular method
2 | // public void myFunction() {
3 | // // code
4 | // }
5 |
6 | // //this is a type
7 | // public interface MyInterface {
8 | // void myInterfaceMethod();
9 | // }
10 |
11 | // // 8. Anonymous class method
12 | // Runnable runnable = new Runnable() {
13 | // @Override
14 | // public void run() {
15 | // // code
16 | // // code
17 | // }
18 | // };
19 |
20 | // // 9. Lambda expression (Java 8+)
21 | // Runnable lambda = () -> {
22 | // // code
23 | // // code
24 | // };
25 |
26 | // // 10. Method reference (Java 8+)
27 | // public abstract class MyClass {
28 | // public static void myMethod() {
29 | // // code
30 | // }
31 | // }
32 |
33 | // Runnable methodRef = MyClass::myMethod;
34 |
35 |
36 | // import java.io.IOException;
37 | // import java.util.Optional;
38 |
39 |
40 |
41 |
42 | // if (othercondition) System.out.println();
43 |
44 |
45 |
46 | // if (condition){ System.out.println("hello world"); }
47 |
48 | // else if (condition) {System.out.println("hello world");}
49 | // else {System.out.println("hello world");}
50 |
51 |
52 | // switch (variable) {
53 | // case value1:
54 | // case value2:
55 | // // code to be executed if variable equals value2
56 | // break;
57 | // // you can have any number of case statements
58 | // default:
59 | // // code to be executed if variable doesn't match any case
60 | // }
61 |
62 | // variable = (condition) ? valueIfTrue : valueIfFalse;
63 |
64 | // String multiLineTextBlock = """
65 | // t Hello,
66 | // World!
67 | // This is a multiline string.
68 | // """;
69 |
70 | // multiLineTextBlock = """hello"""
71 |
72 | // char myChar = 'A';
73 |
74 |
75 | // // This is a single-line comment
76 |
77 | // /*
78 | // * This is a multi-line comment
79 | // * that spans multiple lines.
80 | // */
81 |
82 | // /**
83 | // * This is a Javadoc comment.
84 | // * It is used to describe the class, method, or field.
85 | // *
86 | // * @param paramName Description of the parameter
87 | // * @return Description of the return value
88 | // */
89 | // public class Example {
90 | // // Single-line comment inside a method
91 | // public int method() {
92 | // /* Multi-line comment inside a method */
93 | // return 4;
94 |
95 | // }
96 | // }
97 |
98 |
99 | // for (int i = 0; i < 5; i++) {
100 | // System.out.println(i);
101 | // }
102 |
103 | // int[] arr = {1, 2, 3, 4, 5};
104 | // for (int num : arr) {
105 | // System.out.println(num);
106 | // }
107 |
108 | // int i = 0;
109 | // while (i < 5) {
110 | // System.out.println(i);
111 | // i++;
112 | // }
113 |
114 | // Example ex = new Example();
115 |
116 | // int e = ex.method();
117 |
118 | // int i = 0;
119 | // do {
120 | // System.out.println(i);
121 | // i++;
122 | // } while (i < 5);
123 |
124 |
125 | // import java.util.*;
126 |
127 | // import java.util.Arrays;
128 |
129 | // int[] arr = {1, 2, 3, 4, 5};
130 |
131 |
132 | // Arrays.stream(arr) .forEach(System.out::println);
133 |
134 |
135 | // MyClass obj = new MyClass() {
136 | // void display() {
137 | // System.out.println("Anonymous class object");
138 | // }
139 | // };
140 |
141 | // class MyClassOter implements Serializable {
142 | // transient int transientVar = 100; // Transient variable
143 | // }
144 |
145 |
146 | // public class Main {
147 | // // public static int func(IntSupplier fn) {
148 | // // return fn.get();
149 | // // }
150 |
151 | // public static void main(String[] args) {
152 | // // Using a lambda expression
153 | // IntSupplier lambda = () -> 42;
154 |
155 | // int d = func(lambda);
156 |
157 |
158 | // System.out.println("Result from lambda: " + func(lambda)); // Output: Result from lambda: 42
159 |
160 |
161 | // // Using a method reference
162 | // IntSupplier methodRef = Main::exampleFunction;
163 | // // System.out.println("Result from method reference: " + func(methodRef)); // Output: Result from method reference: 100
164 |
165 | // // Using an anonymous class
166 | // IntSupplier anonymousClass = new IntSupplier() {
167 | // @Override
168 | // public int get() {
169 | // return 84;
170 | // }
171 | // };
172 | // // System.out.println("Result from anonymous class: " + func(anonymousClass)); // Output: Result from anonymous class: 84
173 | // }
174 |
175 | // public static int exampleFunction() {
176 | // try {
177 | // } catch(err Exception) {
178 | // }
179 |
180 | // return 100;
181 | // }
182 | // }
183 |
184 | public class Count {
185 | public boolean has(int[] haystack, int needle, int count) {
186 | if (count >= haystack.length ){
187 | return false;
188 | } else if (haystack[count] === needle) {
189 | return true
190 | } else {
191 | return has(haystack, needle, count++);
192 | }
193 | }
194 |
195 | public int count(int[] haystack, int needle, int count ) {
196 | if (!has(haystack, needle, count) || count >= haystack.length) {
197 | return 0;
198 | }
199 | int c= 0;
200 | if (array[count] == needle) {
201 | c++;
202 | }
203 | c += count(haystack, needle, count);
204 | return c;
205 | }
206 |
207 | }
208 | public static void main (String[] args) {
209 | int[] haystack = {2,3,5,6,9,7,8,8,9};
210 | Count co = new Count();
211 | System.out.println(co.count(haystack,5,0));
212 | }
213 |
--------------------------------------------------------------------------------
/src/playgrounds/playground.js:
--------------------------------------------------------------------------------
1 | export function a(b, c) {
2 | console.log(b);
3 | function d() {
4 | console.log(b);
5 | function e() {
6 | console.log(c);
7 | }
8 | }
9 | console.log('this');
10 | }
11 |
12 | export const d = function () {};
13 |
14 | let g = {
15 | db: 3,
16 | };
17 |
18 | g = {
19 | db: 5,
20 | };
21 |
22 | function b() {
23 | console.log('');
24 | }
25 |
26 | function c() {}
27 |
28 | a(3, 'asdfadf');
29 |
30 | export class M {
31 | static asopidfj = 34;
32 | }
33 |
34 | import assert from 'assert';
35 | import * as vscode from 'vscode';
36 | import { closestPos, nextPosition, previousPosition } from '../parsing/position';
37 | import { getConfig } from '../config';
38 |
39 | const strRegex = /['"`]/;
40 |
41 | export function withInnerStringModifier(command) {
42 | const next = command.end;
43 |
44 | command.end = function (context, range) {
45 | if (!range) {
46 | return;
47 | }
48 | const start = range.start;
49 | const end = range.end;
50 | const line = context.editor.getRange(start.line, start.character, end.line, end.character);
51 |
52 | if (line.match(strRegex)) {
53 | range = new vscode.Range(
54 | new vscode.Position(range.start.line, range.start.character + 1),
55 | new vscode.Position(range.end.line, range.end.character - 1)
56 | );
57 | }
58 |
59 | assert(context.editor, 'editor is undefined');
60 | assert(
61 | typeof context.editor.selectRange === 'function',
62 | 'range selection is not a function, received:' + typeof context.editor.selectRange
63 | );
64 |
65 | next(context, range);
66 | };
67 | return command;
68 | }
69 | export function withMatchFunc(command, func) {
70 | command.onMatch = func;
71 | return command;
72 | }
73 |
74 | export function createSelectNext(scope, name) {
75 | return {
76 | name,
77 | scope,
78 | direction: 'next',
79 | selectors: {},
80 | currentSelector: undefined,
81 | action: 'select',
82 | pos: closestPos,
83 | end: (ctx, range) => {
84 | assert(ctx.editor && typeof ctx.editor.selectRange === 'function', 'is this running another way');
85 | ctx.editor.selectRange(ctx, range);
86 | },
87 | };
88 | }
89 |
--------------------------------------------------------------------------------
/src/playgrounds/playground.json:
--------------------------------------------------------------------------------
1 | {
2 | "outerarray": ["one", "two"],
3 | "innerarray": ["one", "two"],
4 | "outerstr": "string",
5 | "obj": {
6 | "outerarray": ["one", "two"],
7 | "innerarray": ["one", "two"],
8 | "outerstr": "string"
9 | }
10 | }
11 |
--------------------------------------------------------------------------------
/src/playgrounds/playground.jsonc:
--------------------------------------------------------------------------------
1 | {
2 | "outerarray": ["one", "two"],
3 | "innerarray": ["one", "two"],
4 | "outerstr": "string",
5 | "obj": {
6 | "outerarray": ["one", "two"],
7 | "innerarray": ["one", "two"],
8 | "outerstr": "string"
9 | }
10 | }
11 |
--------------------------------------------------------------------------------
/src/playgrounds/playground.jsx:
--------------------------------------------------------------------------------
1 | const b = 3;
2 |
3 | const s = 'ao;sidjfaoijdf';
4 |
5 | (() => {})();
6 |
7 | console.log('asdofjasodifj');
8 |
9 | function a() {}
10 |
--------------------------------------------------------------------------------
/src/playgrounds/playground.lua:
--------------------------------------------------------------------------------
1 |
2 | -- Function declaration using the function keyword
3 | -- Function declaration using the function keyword
4 | -- Function declaration using the function keyword
5 | function myFunction()
6 | print("Hello, World!")
7 | end
8 |
9 |
10 | -- Function declaration with local scope
11 | local function myLocalFunction()
12 | print("Hello, Local World!")
13 | end
14 |
15 | -- Anonymous function assigned to a variable
16 | myanonymousfunction = function()
17 | print("hello, anonymous world!")
18 | end
19 |
20 | -- Function as a table field
21 | myTable = {
22 | myTableFunction = function()
23 | print("Hello, Table World!")
24 | end
25 | }
26 |
27 | myTable.myTableFunction = function()
28 |
29 | end
30 | -- Function with parameterlocal
31 | function myFunctionWithParams(param1, param2)
32 | print(param1, param2)
33 | end
34 |
35 | -- Function with return value
36 | function myFunctionWithReturn()
37 | return "Hello, Return World!"
38 | end
39 |
40 | function MyClass(value)
41 | local self = {}
42 | self = {}
43 | local privateValue = value
44 |
45 | function self:getValue()
46 | return privateValue
47 | end
48 |
49 | return self
50 | end
51 |
52 | local condition = true
53 |
54 |
55 |
56 | local inte = 3
57 |
58 | if inte ==1 then
59 | -- hello
60 | print("hello there")
61 | else
62 | print("hello there")
63 | -- hello
64 | end
65 |
66 |
67 | if inte == 1 then
68 | print("hello")
69 |
70 | elseif inte == 2 then
71 | print("bye")
72 | end
73 |
74 | while condition do
75 | inte = 2
76 | inte = 4
77 | -- code to execute as long as condition is true
78 | end
79 |
80 | repeat
81 |
82 | inte = 2
83 | inte = 4
84 | -- code to execute at least once and then repeatedly until condition is true
85 | until condition
86 |
87 | for i = 1, 10, 1 do
88 | print(i)
89 | end
90 |
91 | for key, value in pairs(table) do
92 | -- code to execute for each key-value pair in the table
93 | end
94 |
95 | local i = 1
96 | while i <= 10 do
97 | print(i)
98 | i = i + 1
99 | end
100 |
101 |
102 | local x = 10
103 |
104 | local yy = 20
105 |
106 | local key = function ()
107 | print('content')
108 | end
109 |
110 | local t = {
111 |
112 | b = function ()
113 | print("hello worlld")
114 | end
115 | }
116 |
117 | local function add(a, b)
118 | return a + b
119 | end
120 |
121 | local result = add(5, 7)
122 | print(result) -- Output: 12
123 |
124 | local array = {1, 2, 3, 4, 5}
125 | array = {1, 2, 3, 4, 5}
126 | local array2 = {
127 | thing1 = 'other'
128 | }
129 | array2 = {
130 | thing1 = 'other'
131 | }
132 |
--------------------------------------------------------------------------------
/src/playgrounds/playground.php:
--------------------------------------------------------------------------------
1 |
12 |
16 | //function calls
17 | ?>
18 |
21 | greet($name, $age);
22 |
23 | ?>
24 |
25 |
49 |
50 |
69 |
70 | = 18) {
74 | // echo "Adult";
75 | // }
76 |
77 | if ($age >= 18) {
78 | echo "Adult";
79 | } else
80 | echo "Minor";
81 |
82 | ?>
83 | = 18) ? "Adult" : "Minort";
85 | ?>
86 | = 18):
104 | echo "Adult";
105 | else:
106 | echo "Minor";
107 | endif;
108 |
109 | $username = $inputUsername ?: "Guest";
110 |
111 | ?>
112 | = 90 => 'A',
116 | $score >= 75 => 'B',
117 | $score >= 60 => 'C',
118 | default => 'F',
119 | };
120 |
121 | ?>
122 |
123 |
128 |
135 |
141 |
148 | "Hello, $name";
150 | ?>
151 |
166 |
167 |
172 | $fruit) {
181 | echo "$index: $fruit";
182 | }
183 |
184 |
185 | ?>
186 |
194 |
195 |
203 |
204 | "Rodrigo", "age" => 30]; ?>
205 |
206 |
214 |
220 |
221 |
--------------------------------------------------------------------------------
/src/playgrounds/playground.py:
--------------------------------------------------------------------------------
1 | def f(param1, two):
2 | print("second")
3 |
4 | def second():
5 | print("second")
6 |
7 |
8 | add = lambda x, y: x + y
9 |
10 |
11 | class MyClass:
12 | def my_method(self):
13 | print("This is a method inside a class.")
14 |
15 |
16 | class OtherClass:
17 | @staticmethod
18 | def my_static_method():
19 | print("This is a static method.")
20 |
21 |
22 | class MyClass2:
23 | @classmethod
24 | def my_class_method(cls):
25 | print("This is a class method.")
26 |
27 |
28 | name = "Josh"
29 |
30 | def my_generator():
31 | yield 1
32 |
33 | yield c2
34 | yield 3
35 |
36 |
37 | async def my_async_function():
38 | print("Async function completed")
39 |
40 |
41 | i = 1
42 | i = 2
43 |
44 |
45 | # htis is a comment
46 | # this is anoterh
47 |
48 | """
49 | this is a docstring for python
50 | """
51 |
52 |
53 | str = "3"
54 |
55 |
56 | fruits = ["on1", "tw2", "thr3", "fou4"]
57 |
58 | count = 0
59 |
60 | while count < 5:
61 | if count == 3:
62 | print("the count is 4")
63 | print("the count is 4")
64 | elif count == 4:
65 | print("the count is 4")
66 | else:
67 | print("the count is 4")
68 | count += 1
69 |
70 |
71 | my_dict = {"a": 1, "b": 2, "c": 3}
72 |
73 |
74 | result = "x is less than 5" if my_dict["c"] < 5 else "x is 5 or greater"
75 | x = 4
76 |
77 | result = {"x is less than 5"} if x < 5 else {"x is 5 or greater"}
78 |
79 |
80 | my_dict.a = 3
81 | for key, value in my_dict.items():
82 | print(f"Key: {key}, Value: {value}")
83 |
84 | squares = [x**2 for x in range(10)]
85 |
86 |
87 | arrr = [1, 2, 3, 4]
88 |
89 | d = {"name": "hogh"}
90 |
91 |
92 | def func(fn):
93 | return fn()
94 |
95 |
96 | # Example function to be passed as an argument
97 | def example_function():
98 | return 42
99 |
100 |
101 | # Using a lambda function
102 | lambda_function = lambda: 100
103 |
104 | # Using the func function with example_function
105 | result = func(example_function)
106 | print(
107 | "Result from example_function:", result
108 | ) # Output: Result from example_function: 42
109 |
110 | # Using the func function with a lambda function
111 | lambda_result = func(lambda_function)
112 | print(
113 | "Result from lambda_function:", lambda_result
114 | ) # Output: Result from lambda_function: 100
115 |
116 | # Using the func function with an anonymous lambda function directly
117 | anonymous_lambda_result = func(lambda: 84)
118 | print(
119 | "Result from anonymous lambda:", anonymous_lambda_result
120 | ) # Output: Result from anonymous lambda: 84
121 |
122 | # Complex nested syntax example
123 | result = (
124 | lambda x: (
125 | (lambda a, b: a(b))(
126 | lambda y: [z for z in y if z % 2 == 0],
127 | (
128 | lambda q: sorted(
129 | [w**2 for w in q if w > 10], key=lambda n: -1 * (n % 5)
130 | )
131 | )(list(range(x))),
132 | )
133 | )
134 | )(50)
135 |
136 | # A highly nested data structure with mixed types
137 | data_structure = {
138 | "key1": [
139 | [1, 2, {"inner_key": [100, 200, 300]}],
140 | [4, 5, 6],
141 | ],
142 | "key2": {
143 | "subkey1": [{"id": idx, "value": (lambda x: x**2)(idx)} for idx in range(5)],
144 | "subkey2": tuple((lambda y: y + (lambda z: z / 2)(y))(i) for i in range(1, 4)),
145 | },
146 | }
147 |
148 | # Obscure generator chained into a dictionary comprehension
149 | gen_chain = {
150 | f"item_{i}": sum(y for y in (x**2 for x in range(i * 2)) if y % 3 == 0)
151 | for i in range(1, 5)
152 | }
153 |
154 |
155 | def perform_extremely_complex_operations_no_comprehensions(input_data):
156 | data = []
157 | sorted_input = sorted(set(input_data), key=lambda x: -x)
158 | for item in sorted_input:
159 | transformed = []
160 | for k, v in enumerate([x**2 for x in range(item) if x % 3 == 0]):
161 | value = 0
162 | transformed.append({"key": k, "value": value})
163 |
164 | for i in range(v):
165 | if i % 2 == 0 and len(str(i)) % 2 == 0:
166 | value += i**2
167 | data.append({"original": item, "transformed": transformed})
168 |
169 | final_result = []
170 | for data in data:
171 | if "transformed" in data:
172 | if isinstance(data["transformed"], list):
173 | for entry in data["transformed"]:
174 | if entry["value"] % 5 == 0:
175 | extra_value = entry["value"]
176 | if extra_value % 7 != 0:
177 | extra_value *= 2
178 | final_result.append(
179 | {
180 | "key": entry["key"],
181 | "value": entry["value"] ** 0.5,
182 | "original": data["original"],
183 | "extra": extra_value,
184 | }
185 | )
186 |
187 | summary = {}
188 | for i in range(len(input_data)):
189 | values = []
190 | for entry in final_result:
191 | if entry["key"] == i:
192 | values.append(entry["value"])
193 | if isinstance(values, list):
194 | if values:
195 | summary[str(i)] = values[0] + sum(values[1:])
196 | else:
197 | summary[str(i)] = -1
198 | else:
199 | summary[str(i)] = -1
200 |
201 | nested_transformations = []
202 | for entry in final_result:
203 | extra = entry["extra"]
204 | if isinstance(extra, int):
205 | range_list = list(range(extra))
206 | else:
207 | range_list = [1, 2, 3]
208 | for v in range_list:
209 | if v % 2 == 0:
210 | nested_transformations.append(v**2)
211 | else:
212 | nested_transformations.append(v**3)
213 |
214 | return {
215 | "processed_data": data,
216 | "final_result": final_result,
217 | "summary": summary,
218 | "nested_transformations": nested_transformations,
219 | }
220 |
221 | def transform( itea):
222 | transformed = []
223 | for k, v in enumerate([x**2 for x in range(item) if x % 3 == 0]):
224 | value = 0
225 |
226 | transformed.append({"key": k, "value": value})
227 |
228 | for i in range(v):
229 | if i % 2 == 0 and len(str(i)) % 2 == 0:
230 | value += i**2
231 | return {"original": item, "transformed": transformed}
232 |
233 |
234 |
235 |
--------------------------------------------------------------------------------
/src/playgrounds/playground.toml:
--------------------------------------------------------------------------------
1 | names = ["Alice", "Bob", "Charlie"]
2 |
3 | basic_string = "Hello, World!"
4 |
5 | multiline_basic_string = """This is a
6 | multiline string."""
7 |
8 | literal_string = 'This is a literal string with special characters like \n and \t but they are not escaped.'
9 |
10 | multiline_literal_string = '''This is a
11 | multiline literal string.'''
12 |
13 | escaped_string = "This string contains a newline character:\nAnd a tab character:\tTab"
14 |
15 |
16 | [person]
17 | name = "Alice"
18 | age = 30
19 | is_student = false
20 |
21 |
22 | person = { name = "Alice", age = 30, is_student = false }
23 |
24 |
25 |
26 | othername= "Alice"
27 | greeting = 'Hello, World!'
28 | multiline_string = """This is a
29 | multiline string."""
30 | multiline_literal_string = '''This is a
31 | multiline literal string.'''
32 | ageo = 30
33 | price = 19.99
34 | date = 2024-10-20
35 | time = 13:45:30
36 | iois_student = false
37 |
38 | datetime = 2024-10-20T13:45:30
39 | datetime_offset = 2024-10-20T13:45:30Z
40 | numbers = [1, 2, 3, 4, 5]
41 |
42 | # This is a multi-line comment
43 | # that explains the following
44 | # configuration settings.
45 |
--------------------------------------------------------------------------------
/src/playgrounds/playground.tsx:
--------------------------------------------------------------------------------
1 | import React from 'react';
2 |
3 | const b = 3
4 |
5 | function c(param: object) {
6 | }
7 |
8 | export const Function = (other: object) => {
9 | return (
10 |
11 | {
12 | ((param) => {
13 | return 1
14 | })({
15 | s: () => {
16 | }
17 |
18 | }) === 1 ? (
) : (
)
19 |
20 |
21 | }
22 | {1 === Math.random() ? (
23 |
24 | ) : (
25 | <>
26 | )}
27 |
Version 0.2.0 is Live
42 |
43 |
44 | This is a big one 🎊🎊🎊! We added a new motion specification, new way to configure and generate your keybindings and migration to the new model!
45 |
46 |
47 | New motion specification: Position
48 |
49 | This was a big thing that was missing in the initial release. A way for you to explicitelly go to the end of an object, either forwards or backwards.
50 |
51 | For now only the go to motion has this hability, but if theres a community want for this, we can add it to all the other ones.
52 |
53 | To migrate your old configuration to the new configuration, either accept the migration prompt, or execute the command vscode-textobjects.migrateVimPositionals.
54 |
55 | A New way to configure and generate your keybindings
56 |
57 | There was a lot to improve in the keybinds and configuration department. If you wanted to change a motion key you had to update all the motions to update the one keystroke. Now you can update your settings with commands!
58 |
59 | to change a specific key, use the vscode-textobjects.keybindings. Then if you are not using the vim extension, use the command Generate Keybindings. It will open a new window with all your new keybindings for you to paste in your keyboard json config. To see that configuration, press CTRL+SHIFT+P and type Preferences: Open Keyboard shortcuts (JSON).
60 |
61 | if you are using the Vim extension. Alter your keys in vscode-textobjects.vimKeybindings, then use the command Generate Vim Keybinds. It will now show a window with your new keybindings that you can paste in your vim settings
62 |
63 | Contribute
64 |
65 | If you enjoy how the extension has been coming along, please consider contributing! I love developing tools and this helps me a ton!
66 |
67 |
69 |
70 | 
71 |
72 |
73 |
74 |
75 |
76 | `;
77 | }
78 |
--------------------------------------------------------------------------------
/src/types/global.d.ts:
--------------------------------------------------------------------------------
1 | import { Position, Range } from 'vscode';
2 | import Parser, { Language, QueryMatch } from 'web-tree-sitter';
3 | import { Editor } from '../editor/editor';
4 | import { Languages } from '../parsing/parser';
5 | import { EditorContext } from '../editor/editorContext';
6 |
7 | export {};
8 |
9 | declare global {
10 | export type SupportedLanguages = keyof typeof Languages;
11 | export type CommandNames =
12 | | 'function'
13 | | 'comment'
14 | | 'type'
15 | | 'call'
16 | | 'parameters'
17 | | 'loop'
18 | | 'conditional'
19 | | 'variable'
20 | | 'rhs'
21 | | 'lhs'
22 | | 'class'
23 | | 'array'
24 | | 'object'
25 | | 'node'
26 | | 'string';
27 |
28 | export type CommandScope = 'inner' | 'outer';
29 | export type CommandDirection = 'next' | 'previous';
30 | export type CommandAction = 'select' | 'goTo' | 'delete' | 'yank' | 'change';
31 |
32 | export type Context = {
33 | editor: Editor;
34 | parsing: {
35 | parser: Parsing | undefined;
36 | };
37 | command: Command | null;
38 | extensionContext: EditorContext | null;
39 | };
40 |
41 | export type Parsing = {
42 | module: string;
43 | language: Language;
44 | parser: Parser;
45 | };
46 | export type CommandPosition = 'start' | 'end';
47 |
48 | export type Command = {
49 | selectors: Partial>;
50 | currentSelector: Selector | undefined;
51 | name: CommandNames;
52 | scope: CommandScope;
53 | direction: CommandDirection;
54 | position: CommandPosition;
55 | action: CommandAction;
56 | onMatch?: OnMatchFunc;
57 | end: OnFinish;
58 | pos: GetPositionFunc;
59 | };
60 |
61 | export interface Selector {
62 | language: SupportedLanguages;
63 | query: string;
64 | }
65 |
66 | export type OnMatchFunc = (ctx: Context, matches: QueryMatch[]) => QueryMatch[];
67 | export type GetPositionFunc = (points: Range[], index: Position) => Range | undefined;
68 |
69 | export type OnFinish = (Ctx: Context, range: Range | undefined) => unknown;
70 |
71 | export type JoinedPoint = {
72 | start: Parser.Point;
73 | end: Parser.Point;
74 | };
75 |
76 | export type EditorCommand = {
77 | command: string;
78 | title: string;
79 | when: string;
80 | f: () => void;
81 | };
82 |
83 | type KeyboardConfig = {
84 | array: string;
85 | call: string;
86 | class: string;
87 | comment: string;
88 | conditional: string;
89 | function: string;
90 | lhs: string;
91 | loop: string;
92 | node: string;
93 | object: string;
94 | rhs: string;
95 | parameters: string;
96 | string: string;
97 | type: string;
98 | variable: string;
99 | };
100 |
101 | type VimMotionConfig = {
102 | select: string;
103 | change: string;
104 | delete: string;
105 | yank: string;
106 | };
107 |
108 | type ScopeConfig = {
109 | inner: string;
110 | outer: string;
111 | };
112 |
113 | type VimKeyboardConfig = {
114 | 'go to next start': string;
115 | 'go to next end': string;
116 | 'go to previous start': string;
117 | 'go to previous end': string;
118 | } & KeyboardConfig &
119 | VimMotionConfig &
120 | ScopeConfig;
121 |
122 | type KeyboardMotionConfig = {
123 | 'go to start': 'f';
124 | 'go to end': 't';
125 | 'select inner': 'n';
126 | 'select outer': 's';
127 | 'delete outer': 'd';
128 | 'delete inner': 'x';
129 | 'yank outer': 'y';
130 | };
131 |
132 | type DefaultKeyboardConfig = KeyboardMotionConfig & KeyboardConfig;
133 |
134 | export type KeyboardKeybind = {
135 | command: string;
136 | when: string;
137 | mac?: string;
138 | key?: string;
139 | };
140 |
141 | export type VimKeybinding = { before: string[]; commands: string[] };
142 | }
143 |
--------------------------------------------------------------------------------
/src/utils.ts:
--------------------------------------------------------------------------------
1 | import assert from 'assert';
2 | import * as vscode from 'vscode';
3 | import { getContext } from './context/context';
4 |
5 | export function visualize(start: vscode.Range): void {
6 | assert(start, 'start needs to be defined');
7 |
8 | const ctx = getContext();
9 | assert(ctx, 'context is not defined');
10 |
11 | const editor = ctx.editor.getEditor();
12 | assert(editor, 'editor is not present');
13 |
14 | editor.revealRange(start);
15 | editor.selection = new vscode.Selection(start.start, start.end); // Move cursor to that position
16 | }
17 |
18 | export class NodePool {
19 | size: number;
20 | private nodes: T[];
21 | private createFunc: () => T;
22 | constructor(createFunc: () => T) {
23 | this.nodes = new Array();
24 | this.size = 0;
25 | this.createFunc = createFunc;
26 | }
27 | get(): T {
28 | const node = this.nodes.pop();
29 |
30 | if (!node) {
31 | this.size++;
32 | return this.createFunc();
33 | }
34 | this.size--;
35 | return node;
36 | }
37 | retrieveAll(point: T[]) {
38 | while (point.length > 0) {
39 | this.nodes[this.size] = point.pop()!;
40 | this.size++;
41 | }
42 | }
43 | retrieve(point: T) {
44 | this.nodes[this.size] = point;
45 | this.size++;
46 | }
47 | }
48 |
49 | export function closerToZero(a: number, b: number) {
50 | if (Math.abs(a) < Math.abs(b)) {
51 | return a;
52 | } else if (Math.abs(b) < Math.abs(a)) {
53 | return b;
54 | } else {
55 | return a; // or return b, since they are equally close to zero
56 | }
57 | }
58 |
--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
1 | {
2 | "compilerOptions": {
3 | "module": "Node16",
4 | "target": "ES2022",
5 | "lib": ["ES2022"],
6 | "sourceMap": true,
7 | "rootDir": "src",
8 | "strict": true /* enable all strict type-checking options */,
9 | // "noEmit": true,
10 | "alwaysStrict": true,
11 |
12 | "noImplicitReturns": true,
13 | "noUnusedParameters": true /* Report errors on unused parameters. */
14 | /* Additional Checks */
15 | // "noImplicitReturns": true, /* Report error when not all code paths in function return a value. */
16 | // "noFallthroughCasesInSwitch": true, /* Report errors for fallthrough cases in switch statement. */
17 | }
18 | }
19 |
--------------------------------------------------------------------------------