tpl
/
obsidian-sample-plugin
Template
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Removed the parser method prefixes like _l1s3_.... which were a residue of early development stage naming allowing clear ordering of these functions in the code. No longer needed

This commit is contained in:
SebastianMC 2022-09-29 19:18:52 +02:00
parent 13f76cc623
commit 4f0937c925
2 changed files with 48 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
src/custom-sort/sorting-spec-processor.spec.ts
View File

@ -1158,71 +1158,71 @@ describe('convertPlainStringSortingGroupSpecToArraySpec', () => {
}); });
it('should recognize infix', () => { it('should recognize infix', () => {
const s = 'Advanced adv...ed, etc. and so on' const s = 'Advanced adv...ed, etc. and so on'
expect(processor._l2s2_convertPlainStringSortingGroupSpecToArraySpec(s)).toEqual([ expect(processor.convertPlainStringSortingGroupSpecToArraySpec(s)).toEqual([
'Advanced adv', '...', 'ed, etc. and so on' 'Advanced adv', '...', 'ed, etc. and so on'
]) ])
}) })
it('should recognize suffix', () => { it('should recognize suffix', () => {
const s = 'Advanced... ' const s = 'Advanced... '
expect(processor._l2s2_convertPlainStringSortingGroupSpecToArraySpec(s)).toEqual([ expect(processor.convertPlainStringSortingGroupSpecToArraySpec(s)).toEqual([
'Advanced', '...' 'Advanced', '...'
]) ])
}) })
it('should recognize prefix', () => { it('should recognize prefix', () => {
const s = ' ...tion. !!!' const s = ' ...tion. !!!'
expect(processor._l2s2_convertPlainStringSortingGroupSpecToArraySpec(s)).toEqual([ expect(processor.convertPlainStringSortingGroupSpecToArraySpec(s)).toEqual([
'...', 'tion. !!!' '...', 'tion. !!!'
]) ])
}) })
it('should recognize some edge case', () => { it('should recognize some edge case', () => {
const s = 'Edge...... ... ..... ... eee?' const s = 'Edge...... ... ..... ... eee?'
expect(processor._l2s2_convertPlainStringSortingGroupSpecToArraySpec(s)).toEqual([ expect(processor.convertPlainStringSortingGroupSpecToArraySpec(s)).toEqual([
'Edge', '...', '... ... ..... ... eee?' 'Edge', '...', '... ... ..... ... eee?'
]) ])
}) })
it('should recognize some other edge case', () => { it('should recognize some other edge case', () => {
const s = 'Edge... ... ... ..... ... eee?' const s = 'Edge... ... ... ..... ... eee?'
expect(processor._l2s2_convertPlainStringSortingGroupSpecToArraySpec(s)).toEqual([ expect(processor.convertPlainStringSortingGroupSpecToArraySpec(s)).toEqual([
'Edge', '...', ' ... ... ..... ... eee?' 'Edge', '...', ' ... ... ..... ... eee?'
]) ])
}) })
it('should recognize another edge case', () => { it('should recognize another edge case', () => {
const s = '...Edge ... ... ... ..... ... eee? ...' const s = '...Edge ... ... ... ..... ... eee? ...'
expect(processor._l2s2_convertPlainStringSortingGroupSpecToArraySpec(s)).toEqual([ expect(processor.convertPlainStringSortingGroupSpecToArraySpec(s)).toEqual([
'...', 'Edge ... ... ... ..... ... eee? ...' '...', 'Edge ... ... ... ..... ... eee? ...'
]) ])
}) })
it('should recognize yet another edge case', () => { it('should recognize yet another edge case', () => {
const s = '. .. ... ...' const s = '. .. ... ...'
const result = processor._l2s2_convertPlainStringSortingGroupSpecToArraySpec(s) const result = processor.convertPlainStringSortingGroupSpecToArraySpec(s)
expect(result).toEqual([ expect(result).toEqual([
'. .. ... ', '...' // Edge case -> splitting here is neutral, syntax error should be raised later on '. .. ... ', '...' // Edge case -> splitting here is neutral, syntax error should be raised later on
]) ])
}) })
it('should recognize tricky edge case', () => { it('should recognize tricky edge case', () => {
const s = '... ...' const s = '... ...'
const result = processor._l2s2_convertPlainStringSortingGroupSpecToArraySpec(s) const result = processor.convertPlainStringSortingGroupSpecToArraySpec(s)
expect(result).toEqual([ expect(result).toEqual([
'...', ' ...' // Edge case -> splitting here is neutral, syntax error should be raised later on '...', ' ...' // Edge case -> splitting here is neutral, syntax error should be raised later on
]) ])
}) })
it('should recognize a variant of tricky edge case', () => { it('should recognize a variant of tricky edge case', () => {
const s = '......' const s = '......'
const result = processor._l2s2_convertPlainStringSortingGroupSpecToArraySpec(s) const result = processor.convertPlainStringSortingGroupSpecToArraySpec(s)
expect(result).toEqual([ expect(result).toEqual([
'...', '...' // Edge case -> splitting here is neutral, syntax error should be raised later on '...', '...' // Edge case -> splitting here is neutral, syntax error should be raised later on
]) ])
}) })
it('edge case behavior', () => { it('edge case behavior', () => {
const s = ' ...... .......... ' const s = ' ...... .......... '
const result = processor._l2s2_convertPlainStringSortingGroupSpecToArraySpec(s) const result = processor.convertPlainStringSortingGroupSpecToArraySpec(s)
expect(result).toEqual([ expect(result).toEqual([
'...', '... ..........' // Edge case -> splitting here is neutral, syntax error should be raised later on '...', '... ..........' // Edge case -> splitting here is neutral, syntax error should be raised later on
]) ])
}) })
it('intentional edge case parsing', () => { it('intentional edge case parsing', () => {
const s = ' Abc......def..........ghi ' const s = ' Abc......def..........ghi '
const result = processor._l2s2_convertPlainStringSortingGroupSpecToArraySpec(s) const result = processor.convertPlainStringSortingGroupSpecToArraySpec(s)
expect(result).toEqual([ expect(result).toEqual([
'Abc', '...', '...def..........ghi' // Edge case -> splitting here is neutral, syntax error should be raised later on 'Abc', '...', '...def..........ghi' // Edge case -> splitting here is neutral, syntax error should be raised later on
]) ])
@ -1232,7 +1232,7 @@ describe('convertPlainStringSortingGroupSpecToArraySpec', () => {
'... ', '... ',
' ...' ' ...'
])('should not split >%s< and only trim', (s: string) => { ])('should not split >%s< and only trim', (s: string) => {
const result = processor._l2s2_convertPlainStringSortingGroupSpecToArraySpec(s) const result = processor.convertPlainStringSortingGroupSpecToArraySpec(s)
expect(result).toEqual([s.trim()]) expect(result).toEqual([s.trim()])
}) })
}) })

72
src/custom-sort/sorting-spec-processor.ts
View File

@ -430,18 +430,18 @@ export class SortingSpecProcessor {
success = false // Empty lines and comments are OK, that's why setting so late success = false // Empty lines and comments are OK, that's why setting so late
const attr: ParsedSortingAttribute | null = this._l1s1_parseAttribute(entryLine); const attr: ParsedSortingAttribute | null = this.parseAttribute(entryLine);
if (attr) { if (attr) {
success = this._l1s2_processParsedSortingAttribute(attr); success = this.processParsedSortingAttribute(attr);
this.ctx.previousValidEntryWasTargetFolderAttr = success && (attr.attribute === Attribute.TargetFolder) this.ctx.previousValidEntryWasTargetFolderAttr = success && (attr.attribute === Attribute.TargetFolder)
} else if (!this.problemAlreadyReportedForCurrentLine && !this._l1s3_checkForRiskyAttrSyntaxError(entryLine)) { } else if (!this.problemAlreadyReportedForCurrentLine && !this.checkForRiskyAttrSyntaxError(entryLine)) {
let group: ParsedSortingGroup | null = this._l1s4_parseSortingGroupSpec(entryLine); let group: ParsedSortingGroup | null = this.parseSortingGroupSpec(entryLine);
if (!this.problemAlreadyReportedForCurrentLine && !group) { if (!this.problemAlreadyReportedForCurrentLine && !group) {
// Default for unrecognized syntax: treat the line as exact name (of file or folder) // Default for unrecognized syntax: treat the line as exact name (of file or folder)
group = {plainSpec: trimmedEntryLine} group = {plainSpec: trimmedEntryLine}
} }
if (group) { if (group) {
success = this._l1s5_processParsedSortGroupSpec(group); success = this.processParsedSortGroupSpec(group);
} }
this.ctx.previousValidEntryWasTargetFolderAttr = undefined this.ctx.previousValidEntryWasTargetFolderAttr = undefined
} }
@ -456,7 +456,7 @@ export class SortingSpecProcessor {
if (success) { if (success) {
if (this.ctx.specs.length > 0) { if (this.ctx.specs.length > 0) {
for (let spec of this.ctx.specs) { for (let spec of this.ctx.specs) {
this._l1s6_postprocessSortSpec(spec) this.postprocessSortSpec(spec)
} }
let sortspecByWildcard: FolderWildcardMatching<CustomSortSpec> | undefined let sortspecByWildcard: FolderWildcardMatching<CustomSortSpec> | undefined
@ -533,7 +533,7 @@ export class SortingSpecProcessor {
// level 1 parser functions defined in order of occurrence and dependency // level 1 parser functions defined in order of occurrence and dependency
private _l1s1_parseAttribute = (line: string): ParsedSortingAttribute | null => { private parseAttribute = (line: string): ParsedSortingAttribute | null => {
const lineTrimmedStart: string = line.trimStart() const lineTrimmedStart: string = line.trimStart()
const nestingLevel: number = line.length - lineTrimmedStart.length const nestingLevel: number = line.length - lineTrimmedStart.length
@ -575,7 +575,7 @@ export class SortingSpecProcessor {
return null; // Seemingly not an attribute or not a valid attribute expression (respective syntax error could have been logged) return null; // Seemingly not an attribute or not a valid attribute expression (respective syntax error could have been logged)
} }
private _l1s2_processParsedSortingAttribute(attr: ParsedSortingAttribute): boolean { private processParsedSortingAttribute(attr: ParsedSortingAttribute): boolean {
if (attr.attribute === Attribute.TargetFolder) { if (attr.attribute === Attribute.TargetFolder) {
if (attr.nesting === 0) { // root-level attribute causing creation of new spec or decoration of a previous one if (attr.nesting === 0) { // root-level attribute causing creation of new spec or decoration of a previous one
if (this.ctx.previousValidEntryWasTargetFolderAttr) { if (this.ctx.previousValidEntryWasTargetFolderAttr) {
@ -583,10 +583,10 @@ export class SortingSpecProcessor {
this.ctx.currentSpec.targetFoldersPaths.push(attr.value) this.ctx.currentSpec.targetFoldersPaths.push(attr.value)
} else { } else {
// Should never reach this execution path, yet for sanity and clarity: // Should never reach this execution path, yet for sanity and clarity:
this.ctx.currentSpec = this._l2s2_putNewSpecForNewTargetFolder(attr.value) this.ctx.currentSpec = this.putNewSpecForNewTargetFolder(attr.value)
} }
} else { } else {
this.ctx.currentSpec = this._l2s2_putNewSpecForNewTargetFolder(attr.value) this.ctx.currentSpec = this.putNewSpecForNewTargetFolder(attr.value)
} }
return true return true
} else { } else {
@ -596,7 +596,7 @@ export class SortingSpecProcessor {
} else if (attr.attribute === Attribute.OrderAsc || attr.attribute === Attribute.OrderDesc || attr.attribute === Attribute.OrderStandardObsidian) { } else if (attr.attribute === Attribute.OrderAsc || attr.attribute === Attribute.OrderDesc || attr.attribute === Attribute.OrderStandardObsidian) {
if (attr.nesting === 0) { if (attr.nesting === 0) {
if (!this.ctx.currentSpec) { if (!this.ctx.currentSpec) {
this.ctx.currentSpec = this._l2s2_putNewSpecForNewTargetFolder() this.ctx.currentSpec = this.putNewSpecForNewTargetFolder()
} }
if (this.ctx.currentSpec.defaultOrder) { if (this.ctx.currentSpec.defaultOrder) {
const folderPathsForProblemMsg: string = this.ctx.currentSpec.targetFoldersPaths.join(' :: '); const folderPathsForProblemMsg: string = this.ctx.currentSpec.targetFoldersPaths.join(' :: ');
@ -627,7 +627,7 @@ export class SortingSpecProcessor {
return false; return false;
} }
private _l1s3_checkForRiskyAttrSyntaxError = (line: string): boolean => { private checkForRiskyAttrSyntaxError = (line: string): boolean => {
const lineTrimmedStart: string = line.trimStart() const lineTrimmedStart: string = line.trimStart()
const lineTrimmedStartLowerCase: string = lineTrimmedStart.toLowerCase() const lineTrimmedStartLowerCase: string = lineTrimmedStart.toLowerCase()
// no space present, check for potential syntax errors // no space present, check for potential syntax errors
@ -646,7 +646,7 @@ export class SortingSpecProcessor {
return false return false
} }
private _l1s4_parseSortingGroupSpec = (line: string): ParsedSortingGroup | null => { private parseSortingGroupSpec = (line: string): ParsedSortingGroup | null => {
const s: string = line.trim() const s: string = line.trim()
if (hasMoreThanOneNumericSortingSymbol(s)) { if (hasMoreThanOneNumericSortingSymbol(s)) {
@ -692,27 +692,27 @@ export class SortingSpecProcessor {
return null; return null;
} }
private _l1s5_processParsedSortGroupSpec(group: ParsedSortingGroup): boolean { private processParsedSortGroupSpec(group: ParsedSortingGroup): boolean {
if (!this.ctx.currentSpec) { if (!this.ctx.currentSpec) {
this.ctx.currentSpec = this._l2s2_putNewSpecForNewTargetFolder() this.ctx.currentSpec = this.putNewSpecForNewTargetFolder()
} }
if (group.plainSpec) { if (group.plainSpec) {
group.arraySpec = this._l2s2_convertPlainStringSortingGroupSpecToArraySpec(group.plainSpec) group.arraySpec = this.convertPlainStringSortingGroupSpecToArraySpec(group.plainSpec)
delete group.plainSpec delete group.plainSpec
} }
if (group.itemToHide) { if (group.itemToHide) {
if (!this._l2s3_consumeParsedItemToHide(group)) { if (!this.consumeParsedItemToHide(group)) {
this.problem(ProblemCode.ItemToHideNoSupportForThreeDots, 'For hiding of file or folder, the exact name with ext is required and no numeric sorting indicator allowed') this.problem(ProblemCode.ItemToHideNoSupportForThreeDots, 'For hiding of file or folder, the exact name with ext is required and no numeric sorting indicator allowed')
return false return false
} else { } else {
return true return true
} }
} else { // !group.itemToHide } else { // !group.itemToHide
const newGroup: CustomSortGroup | null = this._l2s4_consumeParsedSortingGroupSpec(group) const newGroup: CustomSortGroup | null = this.consumeParsedSortingGroupSpec(group)
if (newGroup) { if (newGroup) {
if (this._l2s5_adjustSortingGroupForNumericSortingSymbol(newGroup)) { if (this.adjustSortingGroupForNumericSortingSymbol(newGroup)) {
if (this.ctx.currentSpec) { if (this.ctx.currentSpec) {
this.ctx.currentSpec.groups.push(newGroup) this.ctx.currentSpec.groups.push(newGroup)
this.ctx.currentSpecGroup = newGroup this.ctx.currentSpecGroup = newGroup
@ -729,7 +729,7 @@ export class SortingSpecProcessor {
} }
} }
private _l1s6_postprocessSortSpec(spec: CustomSortSpec): void { private postprocessSortSpec(spec: CustomSortSpec): void {
// clean up to prevent false warnings in console // clean up to prevent false warnings in console
spec.outsidersGroupIdx = undefined spec.outsidersGroupIdx = undefined
spec.outsidersFilesGroupIdx = undefined spec.outsidersFilesGroupIdx = undefined
@ -798,7 +798,7 @@ export class SortingSpecProcessor {
// level 2 parser functions defined in order of occurrence and dependency // level 2 parser functions defined in order of occurrence and dependency
private _l2s1_validateTargetFolderAttrValue = (v: string): string | null => { private validateTargetFolderAttrValue = (v: string): string | null => {
if (v) { if (v) {
const trimmed: string = v.trim(); const trimmed: string = v.trim();
return trimmed ? trimmed : null; // Can't use ?? - it treats '' as a valid value return trimmed ? trimmed : null; // Can't use ?? - it treats '' as a valid value
@ -807,28 +807,28 @@ export class SortingSpecProcessor {
} }
} }
private _l2s1_internal_validateOrderAttrValue = (v: string): CustomSortOrderAscDescPair | null => { private internalValidateOrderAttrValue = (v: string): CustomSortOrderAscDescPair | null => {
v = v.trim(); v = v.trim();
return v ? OrderLiterals[v.toLowerCase()] : null return v ? OrderLiterals[v.toLowerCase()] : null
} }
private _l2s1_validateOrderAscAttrValue = (v: string): RecognizedOrderValue | null => { private validateOrderAscAttrValue = (v: string): RecognizedOrderValue | null => {
const recognized: CustomSortOrderAscDescPair | null = this._l2s1_internal_validateOrderAttrValue(v) const recognized: CustomSortOrderAscDescPair | null = this.internalValidateOrderAttrValue(v)
return recognized ? { return recognized ? {
order: recognized.asc, order: recognized.asc,
secondaryOrder: recognized.secondary secondaryOrder: recognized.secondary
} : null; } : null;
} }
private _l2s1_validateOrderDescAttrValue = (v: string): RecognizedOrderValue | null => { private validateOrderDescAttrValue = (v: string): RecognizedOrderValue | null => {
const recognized: CustomSortOrderAscDescPair | null = this._l2s1_internal_validateOrderAttrValue(v) const recognized: CustomSortOrderAscDescPair | null = this.internalValidateOrderAttrValue(v)
return recognized ? { return recognized ? {
order: recognized.desc, order: recognized.desc,
secondaryOrder: recognized.secondary secondaryOrder: recognized.secondary
} : null; } : null;
} }
private _l2s1_validateSortingAttrValue = (v: string): RecognizedOrderValue | null => { private validateSortingAttrValue = (v: string): RecognizedOrderValue | null => {
// for now only a single fixed lexem // for now only a single fixed lexem
const recognized: boolean = v.trim().toLowerCase() === 'standard' const recognized: boolean = v.trim().toLowerCase() === 'standard'
return recognized ? { return recognized ? {
@ -837,13 +837,13 @@ export class SortingSpecProcessor {
} }
attrValueValidators: { [key in Attribute]: AttrValueValidatorFn } = { attrValueValidators: { [key in Attribute]: AttrValueValidatorFn } = {
[Attribute.TargetFolder]: this._l2s1_validateTargetFolderAttrValue.bind(this), [Attribute.TargetFolder]: this.validateTargetFolderAttrValue.bind(this),
[Attribute.OrderAsc]: this._l2s1_validateOrderAscAttrValue.bind(this), [Attribute.OrderAsc]: this.validateOrderAscAttrValue.bind(this),
[Attribute.OrderDesc]: this._l2s1_validateOrderDescAttrValue.bind(this), [Attribute.OrderDesc]: this.validateOrderDescAttrValue.bind(this),
[Attribute.OrderStandardObsidian]: this._l2s1_validateSortingAttrValue.bind(this) [Attribute.OrderStandardObsidian]: this.validateSortingAttrValue.bind(this)
} }
_l2s2_convertPlainStringSortingGroupSpecToArraySpec = (spec: string): Array<string> => { convertPlainStringSortingGroupSpecToArraySpec = (spec: string): Array<string> => {
spec = spec.trim() spec = spec.trim()
if (isThreeDots(spec)) { if (isThreeDots(spec)) {
return [ThreeDots] return [ThreeDots]
@ -868,7 +868,7 @@ export class SortingSpecProcessor {
return [spec]; return [spec];
} }
private _l2s2_putNewSpecForNewTargetFolder(folderPath?: string): CustomSortSpec { private putNewSpecForNewTargetFolder(folderPath?: string): CustomSortSpec {
const newSpec: CustomSortSpec = { const newSpec: CustomSortSpec = {
targetFoldersPaths: [folderPath ?? this.ctx.folderPath], targetFoldersPaths: [folderPath ?? this.ctx.folderPath],
groups: [] groups: []
@ -883,7 +883,7 @@ export class SortingSpecProcessor {
// Detection of slippery syntax errors which can confuse user due to false positive parsing with an unexpected sorting result // Detection of slippery syntax errors which can confuse user due to false positive parsing with an unexpected sorting result
private _l2s3_consumeParsedItemToHide(spec: ParsedSortingGroup): boolean { private consumeParsedItemToHide(spec: ParsedSortingGroup): boolean {
if (spec.arraySpec?.length === 1) { if (spec.arraySpec?.length === 1) {
const theOnly: string = spec.arraySpec[0] const theOnly: string = spec.arraySpec[0]
if (!isThreeDots(theOnly)) { if (!isThreeDots(theOnly)) {
@ -903,7 +903,7 @@ export class SortingSpecProcessor {
return false return false
} }
private _l2s4_consumeParsedSortingGroupSpec = (spec: ParsedSortingGroup): CustomSortGroup | null => { private consumeParsedSortingGroupSpec = (spec: ParsedSortingGroup): CustomSortGroup | null => {
if (spec.outsidersGroup) { if (spec.outsidersGroup) {
return { return {
type: CustomSortGroupType.Outsiders, type: CustomSortGroupType.Outsiders,
@ -985,7 +985,7 @@ export class SortingSpecProcessor {
} }
// Returns true if no numeric sorting symbol (hence no adjustment) or if correctly adjusted with regex // Returns true if no numeric sorting symbol (hence no adjustment) or if correctly adjusted with regex
private _l2s5_adjustSortingGroupForNumericSortingSymbol = (group: CustomSortGroup) => { private adjustSortingGroupForNumericSortingSymbol = (group: CustomSortGroup) => {
switch (group.type) { switch (group.type) {
case CustomSortGroupType.ExactPrefix: case CustomSortGroupType.ExactPrefix:
const numSymbolInPrefix = convertPlainStringWithNumericSortingSymbolToRegex(group.exactPrefix, RegexpUsedAs.Prefix) const numSymbolInPrefix = convertPlainStringWithNumericSortingSymbolToRegex(group.exactPrefix, RegexpUsedAs.Prefix)