431 lines
12 KiB
TypeScript
431 lines
12 KiB
TypeScript
import { expect } from "chai";
|
|
import { documentContext, inline } from "./testUtils";
|
|
import { limitScopeByIndentation } from "./limitScopeByIndentation";
|
|
|
|
describe("postprocess", () => {
|
|
describe("limitScopeByIndentation: default config", () => {
|
|
let limitScopeByIndentationDefault = (context) => {
|
|
return limitScopeByIndentation(context, { experimentalKeepBlockScopeWhenCompletingLine: false });
|
|
};
|
|
it("should drop multiline completions, when the suffix have meaningful chars in the current line.", () => {
|
|
const context = {
|
|
...documentContext`
|
|
let error = new Error("Something went wrong");
|
|
console.log(║message);
|
|
`,
|
|
language: "javascript",
|
|
};
|
|
const completion = inline`
|
|
├message);
|
|
throw error;┤
|
|
`;
|
|
expect(limitScopeByIndentationDefault(context)(completion)).to.be.null;
|
|
});
|
|
|
|
it("should allow singleline completions, when the suffix have meaningful chars in the current line.", () => {
|
|
const context = {
|
|
...documentContext`
|
|
let error = new Error("Something went wrong");
|
|
console.log(║message);
|
|
`,
|
|
language: "javascript",
|
|
};
|
|
const completion = inline`
|
|
├error, ┤
|
|
`;
|
|
expect(limitScopeByIndentationDefault(context)(completion)).to.eq(completion);
|
|
});
|
|
|
|
it("should allow multiline completions, when the suffix only have auto-closed chars that will be replaced in the current line, such as `)]}`.", () => {
|
|
const context = {
|
|
...documentContext`
|
|
function findMax(arr) {║}
|
|
`,
|
|
language: "javascript",
|
|
};
|
|
const completion = inline`
|
|
├
|
|
let max = arr[0];
|
|
for (let i = 1; i < arr.length; i++) {
|
|
if (arr[i] > max) {
|
|
max = arr[i];
|
|
}
|
|
}
|
|
return max;
|
|
}┤
|
|
`;
|
|
expect(limitScopeByIndentationDefault(context)(completion)).to.eq(completion);
|
|
});
|
|
|
|
it("should limit scope at sentence end, when completion is continuing uncompleted sentence in the prefix.", () => {
|
|
const context = {
|
|
...documentContext`
|
|
let a =║
|
|
`,
|
|
language: "javascript",
|
|
};
|
|
const completion = inline`
|
|
├ 1;
|
|
let b = 2;┤
|
|
`;
|
|
const expected = inline`
|
|
├ 1;┤
|
|
`;
|
|
expect(limitScopeByIndentationDefault(context)(completion)).to.eq(expected);
|
|
});
|
|
|
|
it("should limit scope at sentence end, when completion is continuing uncompleted sentence in the prefix.", () => {
|
|
const context = {
|
|
...documentContext`
|
|
function safeParse(json) {
|
|
try {
|
|
console.log║
|
|
} catch (error) {
|
|
console.error(error);
|
|
return null;
|
|
}
|
|
}
|
|
`,
|
|
language: "javascript",
|
|
};
|
|
const completion = inline`
|
|
├("Parsing", { json });
|
|
return JSON.parse(json);
|
|
} catch (e) {
|
|
return null;
|
|
}
|
|
}┤
|
|
`;
|
|
const expected = inline`
|
|
├("Parsing", { json });┤
|
|
`;
|
|
expect(limitScopeByIndentationDefault(context)(completion)).to.eq(expected);
|
|
});
|
|
|
|
it("should limit scope at next indent level, including closing line, when completion is starting a new indent level in next line.", () => {
|
|
const context = {
|
|
...documentContext`
|
|
function findMax(arr) {║}
|
|
`,
|
|
language: "javascript",
|
|
};
|
|
const completion = inline`
|
|
├
|
|
let max = arr[0];
|
|
for (let i = 1; i < arr.length; i++) {
|
|
if (arr[i] > max) {
|
|
max = arr[i];
|
|
}
|
|
}
|
|
return max;
|
|
}
|
|
console.log(findMax([1, 2, 3, 4, 5]));┤
|
|
`;
|
|
const expected = inline`
|
|
├
|
|
let max = arr[0];
|
|
for (let i = 1; i < arr.length; i++) {
|
|
if (arr[i] > max) {
|
|
max = arr[i];
|
|
}
|
|
}
|
|
return max;
|
|
}┤
|
|
`;
|
|
expect(limitScopeByIndentationDefault(context)(completion)).to.eq(expected);
|
|
});
|
|
|
|
it("should limit scope at next indent level, including closing line, when completion is continuing uncompleted sentence in the prefix, and starting a new indent level in next line.", () => {
|
|
const context = {
|
|
...documentContext`
|
|
function findMax(arr) {
|
|
let max = arr[0];
|
|
for║
|
|
}
|
|
`,
|
|
language: "javascript",
|
|
};
|
|
const completion = inline`
|
|
├ (let i = 1; i < arr.length; i++) {
|
|
if (arr[i] > max) {
|
|
max = arr[i];
|
|
}
|
|
}
|
|
return max;
|
|
}
|
|
console.log(findMax([1, 2, 3, 4, 5]));┤
|
|
`;
|
|
const expected = inline`
|
|
├ (let i = 1; i < arr.length; i++) {
|
|
if (arr[i] > max) {
|
|
max = arr[i];
|
|
}
|
|
}┤
|
|
┴┴
|
|
`;
|
|
expect(limitScopeByIndentationDefault(context)(completion)).to.eq(expected);
|
|
});
|
|
|
|
it("should limit scope at current indent level, exclude closing line, when completion starts new sentences at same indent level.", () => {
|
|
const context = {
|
|
...documentContext`
|
|
function findMax(arr) {
|
|
let max = arr[0];║
|
|
}
|
|
`,
|
|
language: "javascript",
|
|
};
|
|
const completion = inline`
|
|
├
|
|
for (let i = 1; i < arr.length; i++) {
|
|
if (arr[i] > max) {
|
|
max = arr[i];
|
|
}
|
|
}
|
|
return max;
|
|
}┤
|
|
`;
|
|
const expected = inline`
|
|
├
|
|
for (let i = 1; i < arr.length; i++) {
|
|
if (arr[i] > max) {
|
|
max = arr[i];
|
|
}
|
|
}
|
|
return max;┤
|
|
┴┴
|
|
`;
|
|
expect(limitScopeByIndentationDefault(context)(completion)).to.eq(expected);
|
|
});
|
|
|
|
it("should allow only one level closing bracket", () => {
|
|
const context = {
|
|
...documentContext`
|
|
function safeParse(json) {
|
|
try {
|
|
return JSON.parse(json);
|
|
} catch (e) {
|
|
return null;║
|
|
`,
|
|
language: "javascript",
|
|
};
|
|
const completion = inline`
|
|
├
|
|
}
|
|
}┤
|
|
`;
|
|
const expected = inline`
|
|
├
|
|
}┤
|
|
┴┴
|
|
`;
|
|
expect(limitScopeByIndentationDefault(context)(completion)).to.eq(expected);
|
|
});
|
|
|
|
it("should allow level closing bracket at current line, it looks same as starts new sentences", () => {
|
|
const context = {
|
|
...documentContext`
|
|
function helloworld() {
|
|
console.log("hello");
|
|
║
|
|
`,
|
|
language: "javascript",
|
|
};
|
|
const completion = inline`
|
|
├}┤
|
|
`;
|
|
expect(limitScopeByIndentationDefault(context)(completion)).to.be.eq(completion);
|
|
});
|
|
|
|
it("should not allow level closing bracket, when the suffix lines have same indent level", () => {
|
|
const context = {
|
|
...documentContext`
|
|
function helloworld() {
|
|
console.log("hello");║
|
|
console.log("world");
|
|
}
|
|
`,
|
|
language: "javascript",
|
|
};
|
|
const completion = inline`
|
|
├
|
|
}┤
|
|
`;
|
|
const expected = inline`
|
|
├┤`;
|
|
expect(limitScopeByIndentationDefault(context)(completion)).to.be.eq(expected);
|
|
});
|
|
|
|
it("should use indent level of previous line, when current line is empty.", () => {
|
|
const context = {
|
|
...documentContext`
|
|
function safeParse(json) {
|
|
try {
|
|
║
|
|
}
|
|
}
|
|
`,
|
|
language: "javascript",
|
|
};
|
|
const completion = inline`
|
|
├return JSON.parse(json);
|
|
} catch (e) {
|
|
return null;
|
|
}
|
|
}┤
|
|
`;
|
|
const expected = inline`
|
|
├return JSON.parse(json);
|
|
} catch (e) {
|
|
return null;┤
|
|
┴┴
|
|
`;
|
|
expect(limitScopeByIndentationDefault(context)(completion)).to.eq(expected);
|
|
});
|
|
});
|
|
|
|
describe("limitScopeByIndentation: bad cases", () => {
|
|
let limitScopeByIndentationDefault = (context) => {
|
|
return limitScopeByIndentation(context, { experimentalKeepBlockScopeWhenCompletingLine: false });
|
|
};
|
|
it("cannot handle the case of indent that does'nt have a close line, e.g. chaining call", () => {
|
|
const context = {
|
|
...documentContext`
|
|
function sortWords(input) {
|
|
const output = input.trim()
|
|
.split("\n")
|
|
.map((line) => line.split(" "))
|
|
║
|
|
}
|
|
`,
|
|
language: "javascript",
|
|
};
|
|
const completion = inline`
|
|
├.flat()
|
|
.sort()
|
|
.join(" ");
|
|
console.log(output);
|
|
return output;
|
|
}
|
|
sortWord("world hello");┤
|
|
`;
|
|
const expected = inline`
|
|
├.flat()
|
|
.sort()
|
|
.join(" ");
|
|
console.log(output);
|
|
return output;
|
|
};┤
|
|
`;
|
|
expect(limitScopeByIndentationDefault(context)(completion)).not.to.eq(expected);
|
|
});
|
|
|
|
it("cannot handle the case of indent that does'nt have a close line, e.g. python def function", () => {
|
|
const context = {
|
|
...documentContext`
|
|
def findMax(arr):
|
|
║
|
|
`,
|
|
language: "python",
|
|
};
|
|
const completion = inline`
|
|
├max = arr[0]
|
|
for i in range(1, len(arr)):
|
|
if arr[i] > max:
|
|
max = arr[i]
|
|
return max
|
|
findMax([1, 2, 3, 4, 5])┤
|
|
`;
|
|
const expected = inline`
|
|
├max = arr[0]
|
|
for i in range(1, len(arr)):
|
|
if arr[i] > max:
|
|
max = arr[i]
|
|
return max┤
|
|
`;
|
|
expect(limitScopeByIndentationDefault(context)(completion)).not.to.eq(expected);
|
|
});
|
|
});
|
|
|
|
describe("limitScopeByIndentation: with experimentalKeepBlockScopeWhenCompletingLine on", () => {
|
|
let limitScopeByIndentationKeepBlock = (context) => {
|
|
return limitScopeByIndentation(context, { experimentalKeepBlockScopeWhenCompletingLine: true });
|
|
};
|
|
|
|
it("should limit scope at block end, when completion is continuing uncompleted sentence in the prefix.", () => {
|
|
const context = {
|
|
...documentContext`
|
|
let a =║
|
|
`,
|
|
language: "javascript",
|
|
};
|
|
const completion = inline`
|
|
├ 1;
|
|
let b = 2;┤
|
|
`;
|
|
expect(limitScopeByIndentationKeepBlock(context)(completion)).to.eq(completion);
|
|
});
|
|
|
|
it("should limit scope at block end, when completion is continuing uncompleted sentence in the prefix.", () => {
|
|
const context = {
|
|
...documentContext`
|
|
function safeParse(json) {
|
|
try {
|
|
console.log║
|
|
}
|
|
}
|
|
`,
|
|
language: "javascript",
|
|
};
|
|
const completion = inline`
|
|
├("Parsing", { json });
|
|
return JSON.parse(json);
|
|
} catch (e) {
|
|
return null;
|
|
}
|
|
}┤
|
|
`;
|
|
const expected = inline`
|
|
├("Parsing", { json });
|
|
return JSON.parse(json);
|
|
} catch (e) {
|
|
return null;┤
|
|
┴┴
|
|
`;
|
|
expect(limitScopeByIndentationKeepBlock(context)(completion)).to.eq(expected);
|
|
});
|
|
|
|
it("should limit scope at same indent level, including closing line, when completion is continuing uncompleted sentence in the prefix, and starting a new indent level in next line.", () => {
|
|
const context = {
|
|
...documentContext`
|
|
function findMax(arr) {
|
|
let max = arr[0];
|
|
for║
|
|
}
|
|
`,
|
|
language: "javascript",
|
|
};
|
|
const completion = inline`
|
|
├ (let i = 1; i < arr.length; i++) {
|
|
if (arr[i] > max) {
|
|
max = arr[i];
|
|
}
|
|
}
|
|
return max;
|
|
}
|
|
console.log(findMax([1, 2, 3, 4, 5]));┤
|
|
`;
|
|
const expected = inline`
|
|
├ (let i = 1; i < arr.length; i++) {
|
|
if (arr[i] > max) {
|
|
max = arr[i];
|
|
}
|
|
}
|
|
return max;┤
|
|
┴┴
|
|
`;
|
|
expect(limitScopeByIndentationKeepBlock(context)(completion)).to.eq(expected);
|
|
});
|
|
});
|
|
});
|