Skip to content

Commit 1fbeeaa

Browse files
mProjectsCodemProjectsCode
committed
more merge fixes
1 parent d9e0a22 commit 1fbeeaa

File tree

7 files changed

+113
-111
lines changed

7 files changed

+113
-111
lines changed

‎exampleVault/examples fg.md‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -3,7 +3,7 @@ rating: 31
33
title: test title test test
44
completed: false
55
toggle1: true
6-
slider1: 24
6+
slider1: 8
77
slider2: 8
88
text1: Testa
99
text_area1: test test test
@@ -103,7 +103,7 @@ INPUT[editor:editor]
103103
> `INPUT[slider(addLabels, minValue(1), maxValue(10)):slider1]`
104104
105105
## Nested data
106-
`INPUT[text:nested.object]`
106+
`INPUT[text:nested["object"]]`
107107

108108
---
109109

‎exampleVault/other note.md‎

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -7,7 +7,6 @@ time: 19:20
77
multi-select:
88
- option a
99
- option b
10-
- option c
1110
---
1211

1312
## This is another note

‎src/InputFieldMarkdownRenderChild.ts‎

Lines changed: 11 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -24,26 +24,23 @@ export class InputFieldMarkdownRenderChild extends MarkdownRenderChild {
2424
type: InputFieldMarkdownRenderChildType;
2525

2626
fullDeclaration: string;
27-
inputFieldDeclaration: InputFieldDeclaration | undefined;
27+
inputFieldDeclaration: InputFieldDeclaration;
2828
bindTargetFile: TFile | undefined;
2929
bindTargetMetadataPath: string[] | undefined;
3030

3131
intervalCounter: number;
3232
metadataValueUpdateQueue: any[];
3333
inputFieldValueUpdateQueue: any[];
3434

35-
constructor(
36-
containerEl: HTMLElement,
37-
type: InputFieldMarkdownRenderChildType,
38-
declaration: InputFieldDeclaration,
39-
plugin: MetaBindPlugin,
40-
filePath: string,
41-
uuid: string,
42-
error?: string
43-
) {
35+
constructor(containerEl: HTMLElement, type: InputFieldMarkdownRenderChildType, declaration: InputFieldDeclaration, plugin: MetaBindPlugin, filePath: string, uuid: string) {
4436
super(containerEl);
4537

46-
this.error = error || '';
38+
if (!declaration.error) {
39+
this.error = '';
40+
} else {
41+
this.error = declaration.error instanceof Error ? declaration.error.message : declaration.error;
42+
}
43+
4744
this.filePath = filePath;
4845
this.uuid = uuid;
4946
this.plugin = plugin;
@@ -55,7 +52,7 @@ export class InputFieldMarkdownRenderChild extends MarkdownRenderChild {
5552
this.intervalCounter = 0;
5653
this.inputFieldDeclaration = declaration;
5754

58-
if (!error) {
55+
if (!this.error) {
5956
try {
6057
if (this.inputFieldDeclaration.isBound) {
6158
this.parseBindTarget();
@@ -158,8 +155,8 @@ export class InputFieldMarkdownRenderChild extends MarkdownRenderChild {
158155
}
159156

160157
getArguments(name: InputFieldArgumentType): AbstractInputFieldArgument[] {
161-
if (!this.inputFieldDeclaration) {
162-
throw new MetaBindInternalError('inputFieldDeclaration is undefined, can not retrieve arguments');
158+
if (this.inputFieldDeclaration.error) {
159+
throw new MetaBindInternalError('inputFieldDeclaration has errors, can not retrieve arguments');
163160
}
164161

165162
return this.inputFieldDeclaration.argumentContainer.arguments.filter(x => x.identifier === name);

‎src/MetadataManager.ts‎

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -53,7 +53,6 @@ export class MetadataManager {
5353
this.plugin.app.vault.cachedRead(file).then(value => {
5454
c.metadata = getMetaDataFromFileContent(value);
5555
console.log(`meta-bind | MetadataManager >> loaded metadata for file ${file.path}`, c.metadata);
56-
debugger;
5756
this.notifyListeners(c);
5857
});
5958

‎src/main.ts‎

Lines changed: 6 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
import { CachedMetadata, editorEditorField, MarkdownPostProcessorContext, Plugin, TFile } from 'obsidian';
1+
import { Plugin, TFile } from 'obsidian';
22
import { DEFAULT_SETTINGS, MetaBindPluginSettings, MetaBindSettingTab } from './settings/Settings';
33
import { InputFieldMarkdownRenderChild, InputFieldMarkdownRenderChildType } from './InputFieldMarkdownRenderChild';
44
import { getFileName, isPath, removeFileEnding } from './utils/Utils';
@@ -68,22 +68,13 @@ export default class MetaBindPlugin extends Plugin {
6868
container: HTMLElement,
6969
renderType: InputFieldMarkdownRenderChildType = InputFieldMarkdownRenderChildType.INLINE_CODE_BLOCK
7070
): InputFieldMarkdownRenderChild {
71-
let error: string | undefined;
72-
73-
try {
74-
if (typeof declaration === 'string') {
75-
declaration = InputFieldDeclarationParser.parseString(declaration);
76-
} else {
77-
declaration = InputFieldDeclarationParser.parseDeclaration(declaration);
78-
}
79-
} catch (e: any) {
80-
if (e instanceof Error) {
81-
error = e.message;
82-
console.warn(e);
83-
}
71+
if (typeof declaration === 'string') {
72+
declaration = InputFieldDeclarationParser.parseString(declaration);
73+
} else {
74+
declaration = InputFieldDeclarationParser.parseDeclaration(declaration);
8475
}
8576

86-
return new InputFieldMarkdownRenderChild(container, renderType, declaration as InputFieldDeclaration, this, sourcePath, crypto.randomUUID(), error);
77+
return new InputFieldMarkdownRenderChild(container, renderType, declaration, this, sourcePath, crypto.randomUUID());
8778
}
8879

8980
/**

‎src/parsers/InputFieldDeclarationParser.ts‎

Lines changed: 82 additions & 66 deletions
Original file line numberDiff line numberDiff line change
@@ -71,6 +71,8 @@ export interface InputFieldDeclaration {
7171
* A collection of the input field arguments.
7272
*/
7373
argumentContainer: InputFieldArgumentContainer;
74+
75+
error?: Error | string;
7476
}
7577

7678
export interface Template {
@@ -98,36 +100,43 @@ export class InputFieldDeclarationParser {
98100
// field type check
99101
fullDeclaration.inputFieldType = InputFieldDeclarationParser.getInputFieldType(fullDeclaration.inputFieldType);
100102

101-
// template check:
102-
let useTemplate: boolean = isTruthy(templateName);
103-
if (useTemplate) {
104-
InputFieldDeclarationParser.applyTemplate(fullDeclaration, templateName);
105-
}
103+
try {
104+
// template check:
105+
let useTemplate: boolean = isTruthy(templateName);
106+
if (useTemplate) {
107+
InputFieldDeclarationParser.applyTemplate(fullDeclaration, templateName);
108+
}
106109

107-
if (fullDeclaration.inputFieldType === InputFieldType.INVALID) {
108-
throw new MetaBindParsingError(`unknown input field type`);
109-
}
110+
if (fullDeclaration.inputFieldType === InputFieldType.INVALID) {
111+
throw new MetaBindParsingError(`unknown input field type`);
112+
}
110113

111-
// arguments check:
112-
fullDeclaration.argumentContainer = new InputFieldArgumentContainer();
113-
if (inputFieldArguments) {
114-
for (const inputFieldArgumentIdentifier in Object.keys(inputFieldArguments)) {
115-
const inputFieldArgument: AbstractInputFieldArgument = InputFieldArgumentFactory.createInputFieldArgument(inputFieldArgumentIdentifier);
114+
// arguments check:
115+
fullDeclaration.argumentContainer = new InputFieldArgumentContainer();
116+
if (inputFieldArguments) {
117+
for (const inputFieldArgumentIdentifier in Object.keys(inputFieldArguments)) {
118+
const inputFieldArgument: AbstractInputFieldArgument = InputFieldArgumentFactory.createInputFieldArgument(inputFieldArgumentIdentifier);
116119

117-
if (!inputFieldArgument.isAllowed(fullDeclaration.inputFieldType)) {
118-
throw new MetaBindParsingError(
119-
`argument \'${inputFieldArgumentIdentifier}\' is only applicable to ${inputFieldArgument.getAllowedInputFieldsAsString()} input fields`
120-
);
121-
}
120+
if (!inputFieldArgument.isAllowed(fullDeclaration.inputFieldType)) {
121+
throw new MetaBindParsingError(
122+
`argument \'${inputFieldArgumentIdentifier}\' is only applicable to ${inputFieldArgument.getAllowedInputFieldsAsString()} input fields`
123+
);
124+
}
125+
126+
if (inputFieldArgument.requiresValue) {
127+
inputFieldArgument.parseValue((inputFieldArguments as Record<InputFieldArgumentType, string>)[inputFieldArgumentIdentifier as InputFieldArgumentType]);
128+
}
122129

123-
if (inputFieldArgument.requiresValue) {
124-
inputFieldArgument.parseValue((inputFieldArguments as Record<InputFieldArgumentType, string>)[inputFieldArgumentIdentifier as InputFieldArgumentType]);
130+
fullDeclaration.argumentContainer.add(inputFieldArgument);
125131
}
126132

127-
fullDeclaration.argumentContainer.add(inputFieldArgument);
133+
fullDeclaration.argumentContainer.validate();
134+
}
135+
} catch (e) {
136+
if (e instanceof Error) {
137+
fullDeclaration.error = e;
138+
console.warn(e);
128139
}
129-
130-
fullDeclaration.argumentContainer.validate();
131140
}
132141

133142
return fullDeclaration;
@@ -136,57 +145,64 @@ export class InputFieldDeclarationParser {
136145
static parseString(fullDeclaration: string): InputFieldDeclaration {
137146
let inputFieldDeclaration: InputFieldDeclaration = {} as InputFieldDeclaration;
138147

139-
let useTemplate = false;
140-
let templateName = '';
141-
142-
// declaration
143-
inputFieldDeclaration.fullDeclaration = fullDeclaration;
144-
const temp = ParserUtils.getInBetween(fullDeclaration, InputFieldDeclarationParser.squareBracesPair);
145-
if (Array.isArray(temp)) {
146-
if (temp.length === 2) {
147-
useTemplate = true;
148-
templateName = temp[0];
149-
inputFieldDeclaration.declaration = temp[1];
148+
try {
149+
let useTemplate = false;
150+
let templateName = '';
151+
152+
// declaration
153+
inputFieldDeclaration.fullDeclaration = fullDeclaration;
154+
const temp = ParserUtils.getInBetween(fullDeclaration, InputFieldDeclarationParser.squareBracesPair);
155+
if (Array.isArray(temp)) {
156+
if (temp.length === 2) {
157+
useTemplate = true;
158+
templateName = temp[0];
159+
inputFieldDeclaration.declaration = temp[1];
160+
} else {
161+
throw new MetaBindParsingError('invalid input field declaration');
162+
}
150163
} else {
151-
throw new MetaBindParsingError('invalid input field declaration');
164+
inputFieldDeclaration.declaration = temp;
152165
}
153-
} else {
154-
inputFieldDeclaration.declaration = temp;
155-
}
156166

157-
// declaration parts
158-
const declarationParts: string[] = ParserUtils.split(inputFieldDeclaration.declaration, ':', InputFieldDeclarationParser.squareBracesPair);
159-
160-
// bind target
161-
inputFieldDeclaration.bindTarget = declarationParts[1] ?? '';
162-
inputFieldDeclaration.isBound = isTruthy(inputFieldDeclaration.bindTarget);
163-
164-
// input field type and arguments
165-
const inputFieldTypeWithArguments: string = declarationParts[0];
166-
if (inputFieldTypeWithArguments) {
167-
// input field type
168-
const inputFieldTypeString = ParserUtils.removeInBetween(inputFieldTypeWithArguments, InputFieldDeclarationParser.roundBracesPair);
169-
inputFieldDeclaration.inputFieldType = InputFieldDeclarationParser.getInputFieldType(inputFieldTypeString);
170-
171-
// arguments
172-
const inputFieldArgumentsString: string = ParserUtils.getInBetween(inputFieldTypeWithArguments, InputFieldDeclarationParser.roundBracesPair) as string;
173-
// console.log(inputFieldArgumentsString);
174-
if (inputFieldArgumentsString) {
175-
inputFieldDeclaration.argumentContainer = InputFieldDeclarationParser.parseArguments(inputFieldArgumentsString, inputFieldDeclaration.inputFieldType);
167+
// declaration parts
168+
const declarationParts: string[] = ParserUtils.split(inputFieldDeclaration.declaration, ':', InputFieldDeclarationParser.squareBracesPair);
169+
170+
// bind target
171+
inputFieldDeclaration.bindTarget = declarationParts[1] ?? '';
172+
inputFieldDeclaration.isBound = isTruthy(inputFieldDeclaration.bindTarget);
173+
174+
// input field type and arguments
175+
const inputFieldTypeWithArguments: string = declarationParts[0];
176+
if (inputFieldTypeWithArguments) {
177+
// input field type
178+
const inputFieldTypeString = ParserUtils.removeInBetween(inputFieldTypeWithArguments, InputFieldDeclarationParser.roundBracesPair);
179+
inputFieldDeclaration.inputFieldType = InputFieldDeclarationParser.getInputFieldType(inputFieldTypeString);
180+
181+
// arguments
182+
const inputFieldArgumentsString: string = ParserUtils.getInBetween(inputFieldTypeWithArguments, InputFieldDeclarationParser.roundBracesPair) as string;
183+
// console.log(inputFieldArgumentsString);
184+
if (inputFieldArgumentsString) {
185+
inputFieldDeclaration.argumentContainer = InputFieldDeclarationParser.parseArguments(inputFieldArgumentsString, inputFieldDeclaration.inputFieldType);
186+
} else {
187+
inputFieldDeclaration.argumentContainer = new InputFieldArgumentContainer();
188+
}
176189
} else {
190+
inputFieldDeclaration.inputFieldType = InputFieldType.INVALID;
177191
inputFieldDeclaration.argumentContainer = new InputFieldArgumentContainer();
178192
}
179-
} else {
180-
inputFieldDeclaration.inputFieldType = InputFieldType.INVALID;
181-
inputFieldDeclaration.argumentContainer = new InputFieldArgumentContainer();
182-
}
183193

184-
if (useTemplate) {
185-
InputFieldDeclarationParser.applyTemplate(inputFieldDeclaration, templateName);
186-
}
194+
if (useTemplate) {
195+
InputFieldDeclarationParser.applyTemplate(inputFieldDeclaration, templateName);
196+
}
187197

188-
if (inputFieldDeclaration.inputFieldType === InputFieldType.INVALID) {
189-
throw new MetaBindParsingError(`unknown input field type`);
198+
if (inputFieldDeclaration.inputFieldType === InputFieldType.INVALID) {
199+
throw new MetaBindParsingError(`unknown input field type`);
200+
}
201+
} catch (e) {
202+
if (e instanceof Error) {
203+
inputFieldDeclaration.error = e;
204+
console.warn(e);
205+
}
190206
}
191207

192208
return inputFieldDeclaration;

‎tests/InputFieldDeclarationParser.test.ts‎

Lines changed: 12 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,6 @@
1-
import { MetaBindParsingError } from '../src/utils/Utils';
21
import { InputFieldArgumentContainer } from '../src/inputFieldArguments/InputFieldArgumentContainer';
32
import { InputFieldArgumentType, InputFieldDeclaration, InputFieldDeclarationParser, InputFieldType } from '../src/parsers/InputFieldDeclarationParser';
3+
import { MetaBindParsingError } from '../src/utils/MetaBindErrors';
44

55
test('placeholder', () => {
66
expect(true).toEqual(true);
@@ -10,29 +10,29 @@ describe('apply template', () => {
1010
test('found', () => {
1111
InputFieldDeclarationParser.templates = [
1212
{
13-
identifier: "Test",
13+
identifier: 'Test',
1414
template: {
1515
isBound: true,
16-
bindTarget: "Test#Target",
17-
argumentContainer: new InputFieldArgumentContainer()
18-
} as InputFieldDeclaration
19-
}
16+
bindTarget: 'Test#Target',
17+
argumentContainer: new InputFieldArgumentContainer(),
18+
} as InputFieldDeclaration,
19+
},
2020
];
2121

22-
const inputFieldDeclaration: InputFieldDeclaration = InputFieldDeclarationParser.parseString("INPUT[toggle(class(a))]");
23-
InputFieldDeclarationParser.applyTemplate(inputFieldDeclaration, "Test");
22+
const inputFieldDeclaration: InputFieldDeclaration = InputFieldDeclarationParser.parseString('INPUT[toggle(class(a))]');
23+
InputFieldDeclarationParser.applyTemplate(inputFieldDeclaration, 'Test');
2424

2525
expect(inputFieldDeclaration.isBound).toEqual(true);
26-
expect(inputFieldDeclaration.bindTarget).toEqual("Test#Target");
26+
expect(inputFieldDeclaration.bindTarget).toEqual('Test#Target');
2727
expect(inputFieldDeclaration.inputFieldType).toEqual(InputFieldType.TOGGLE);
2828
expect(inputFieldDeclaration.argumentContainer.arguments[0].identifier).toEqual(InputFieldArgumentType.CLASS);
29-
expect(inputFieldDeclaration.argumentContainer.arguments[0].value).toEqual(["a"]);
29+
expect(inputFieldDeclaration.argumentContainer.arguments[0].value).toEqual(['a']);
3030
});
3131
test('not found', () => {
3232
InputFieldDeclarationParser.templates = [];
3333

34-
const inputFieldDeclaration: InputFieldDeclaration = InputFieldDeclarationParser.parseString("INPUT[toggle(class(a))]");
35-
expect(() => InputFieldDeclarationParser.applyTemplate(inputFieldDeclaration, "Test")).toThrowError(MetaBindParsingError);
34+
const inputFieldDeclaration: InputFieldDeclaration = InputFieldDeclarationParser.parseString('INPUT[toggle(class(a))]');
35+
expect(() => InputFieldDeclarationParser.applyTemplate(inputFieldDeclaration, 'Test')).toThrowError(MetaBindParsingError);
3636
});
3737
});
3838

0 commit comments

Comments
 (0)