@larsgw/formica 0.8.5 → 0.8.6

package/src/resources/parse-name.ts

@@ -1,3 +1,12 @@
+export class RecoverableSyntaxError<Result> extends SyntaxError {
+    result: Result
+
+    constructor (message: string, result: Result) {
+        super(message)
+        this.result = result
+    }
+}
+
 export const RANKS: Rank[] = [
     'phylum',
     'subphylum',
@@ -138,10 +147,8 @@ function getSynonymRank (name: string, rank: Rank): Rank {
     const rankPrefix = rest.match(/^(?: |^)(st|r|ab|f|var|ssp|subsp)\. /)
     if (rankPrefix) {
         return RANK_LABELS_REVERSE[rankPrefix[1]] as string
-    } else if (SUBGENUS_PATTERN.test(name)) {
-        return 'subgenus'
     } else if (!BINAME_PATTERN.test(name)) {
-        return rank
+        return SUBGENUS_PATTERN.test(name) ? 'subgenus' : rank
     } else if (/^ (?!sensu)[a-z0-9-]+($| )/.test(rest)) {
         return 'subspecies'
     } else {
@@ -280,29 +287,32 @@ export function parseName (name: string, rank: Rank, parent: WorkingTaxon): Work
     item.scientificNameAuthorship = capitalizeAuthors(citation)
     item.taxonRemarks = notes
     item.taxonRank = rank
+    item.genericName = undefined
+    item.infragenericEpithet = undefined
+    item.specificEpithet = undefined
+    item.infraspecificEpithet = undefined
 
-    // @ts-expect-error TS1501: This regular expression flag is only available when targeting 'es6' or later.
     if (/[^\p{L}0-9\u{00D7}\- ]/u.test(taxon)) {
-        throw new Error(`Taxon name contains unexpected characters: "${taxon}"`)
+        throw new RecoverableSyntaxError(`Taxon name contains unexpected characters: "${taxon}"`, item)
     }
 
     // Validate names and recompose binomial and trinomial names
     if (compareRanks('genus', rank) > 0) {
         item.scientificName = capitalize(taxon)
         if (taxon[0].toUpperCase() !== taxon[0]) {
-            throw new Error(`Taxon name (${rank}) should be capitalized: "${taxon}"`)
+            throw new RecoverableSyntaxError(`Taxon name (${rank}) should be capitalized: "${taxon}"`, item)
         }
     } else if (rank === 'genus') {
         item.scientificName = capitalizeGenericName(taxon)
         if (taxon[0].toUpperCase() !== taxon[0] || (taxon[0] === HYBRID_SIGN && taxon[1].toUpperCase() !== taxon[1])) {
-            throw new Error(`Generic epithet should be capitalized: "${taxon}"`)
+            throw new RecoverableSyntaxError(`Generic epithet should be capitalized: "${taxon}"`, item)
         }
     } else if (compareRanks('group', rank) > 0) {
         item.genericName = parentContext.genus
         item.infragenericEpithet = parentContext.subgenus
         item.scientificName = capitalize(taxon)
         if (taxon[0].toUpperCase() !== taxon[0]) {
-            throw new Error(`Infrageneric epithet should be capitalized: "${taxon}"`)
+            throw new RecoverableSyntaxError(`Infrageneric epithet should be capitalized: "${taxon}"`, item)
         }
     } else if (rank === 'group') {
         item.genericName = parentContext.genus
@@ -310,8 +320,7 @@ export function parseName (name: string, rank: Rank, parent: WorkingTaxon): Work
         const specificEpithet = taxon.toLowerCase().replace(/(-group)?$/, '')
         item.scientificName = `${item.genericName} ${specificEpithet}-group`
         if (taxon.toLowerCase() !== taxon) {
-            console.log(item, taxon)
-            throw new Error(`Group name should be lowercase: "${taxon}"`)
+            throw new RecoverableSyntaxError(`Group name should be lowercase: "${taxon}"`, item)
         }
     } else if (rank === 'subgroup') {
         item.genericName = parentContext.genus
@@ -319,8 +328,7 @@ export function parseName (name: string, rank: Rank, parent: WorkingTaxon): Work
         const specificEpithet = taxon.toLowerCase().replace(/(-subgroup)?$/, '')
         item.scientificName = `${item.genericName} ${specificEpithet}-subgroup`
         if (taxon.toLowerCase() !== taxon) {
-            console.log(item, taxon)
-            throw new Error(`Subgroup name should be lowercase: "${taxon}"`)
+            throw new RecoverableSyntaxError(`Subgroup name should be lowercase: "${taxon}"`, item)
         }
     } else if (compareRanks('species', rank) > 0) {
         item.genericName = parentContext.genus
@@ -328,15 +336,13 @@ export function parseName (name: string, rank: Rank, parent: WorkingTaxon): Work
         const specificEpithet = taxon.toLowerCase()
         item.scientificName = `${item.genericName} ${specificEpithet}`
         if (specificEpithet !== taxon) {
-            console.log(item, taxon)
-            throw new Error(`Subgroup name should be lowercase: "${taxon}"`)
+            throw new RecoverableSyntaxError(`Taxon name should be lowercase: "${taxon}"`, item)
         }
     } else if (rank === 'species') {
         item.genericName = parentContext.genus
         item.infragenericEpithet = parentContext.subgenus
         if (taxon.toLowerCase() !== taxon && !/^[A-Z][a-z]+ [a-z]+\xD7[A-Z][a-z]+ [a-z]+$/.test(taxon)) {
-            console.log(item, taxon)
-            throw new Error(`Specific epithet should be lowercase: "${taxon}"`)
+            throw new RecoverableSyntaxError(`Specific epithet should be lowercase: "${taxon}"`, item)
         }
         item.specificEpithet = taxon
         item.scientificName = `${item.genericName} ${item.specificEpithet}`
@@ -359,8 +365,7 @@ export function parseName (name: string, rank: Rank, parent: WorkingTaxon): Work
         item.scientificName = nameParts.join(' ')
 
         if (item.infraspecificEpithet !== taxon) {
-            console.log(item, taxon)
-            throw new Error(`Infraspecific epithet should be lowercase: "${taxon}"`)
+            throw new RecoverableSyntaxError(`Infraspecific epithet should be lowercase: "${taxon}"`, item)
         }
     }
 
@@ -371,4 +376,4 @@ export function parseName (name: string, rank: Rank, parent: WorkingTaxon): Work
     }
 
     return item
-}
+}

package/src/resources/parse-text.ts

@@ -1,7 +1,7 @@
 import * as yaml from 'js-yaml'
 import { WorkResource } from './resource'
 import { createDiff, ResourceDiffType } from './diff-resource'
-import { parseName, RANKS } from './parse-name'
+import { parseName, RANKS, RecoverableSyntaxError } from './parse-name'
 
 const MAIN_RANKS: Rank[] = [
     'kingdom',
@@ -144,7 +144,7 @@ function parseResourceContent (content: ResourceDiff, resource: Resource, oldIds
     let lineNumber = offsetLine
 
     const parents: Array<TaxonId | null> = []
-    const previous = { id: '', indent: 0, group: { isLeaf: false, indent: 0 } }
+    const previous = { id: '', indent: 0, group: { isLeaf: false, indent: 0 }, errors: <SyntaxError[]>[] }
 
     for (const line of content) {
         const hasOriginalId = line.type !== ResourceDiffType.Added && !/^\s*(\[indet\]|> )/.test(line.original ?? line.text as string)
@@ -170,7 +170,6 @@ function parseResourceContent (content: ResourceDiff, resource: Resource, oldIds
             continue
         } else if (lineIndent <= previous.group.indent && (data[previous.id] && !previous.group.isLeaf)) {
             errors.push(makeParseError('Missing leaf taxon', lineNumber - 1))
-            continue
         }
 
         // Update parentage
@@ -198,20 +197,28 @@ function parseResourceContent (content: ResourceDiff, resource: Resource, oldIds
         // Do not process "indet" lines further, as they only serve to indicate
         // that subtaxa are explicitely omitted
         if (name.startsWith('[indet]')) {
+            errors.push(...previous.errors)
+            previous.errors.length = 0
             previous.group.isLeaf = lineIndent / INDENT >= leafTaxonIndex
             continue
         }
 
         const parentId = parents.reduce((grandparent, parent) => parent ?? grandparent, null)
         const parent = parentId === null ? {} as WorkingTaxon : data[parentId]
-        const rank = resource.metadata.levels[parents.length]
         let item
+        const itemErrors = []
 
         try {
+            const rank = resource.metadata.levels[parents.length]
             item = parseName(name, rank, parent)
         } catch (error) {
-            errors.push(makeParseError(error.message, lineNumber))
-            continue
+            if (error instanceof RecoverableSyntaxError) {
+                itemErrors.push(makeParseError(error.message, lineNumber))
+                item = error.result
+            } else {
+                errors.push(makeParseError(error.message, lineNumber))
+                continue
+            }
         }
 
         // Add higher classification info
@@ -236,12 +243,26 @@ function parseResourceContent (content: ResourceDiff, resource: Resource, oldIds
 
         // Amend "parent" with corrections, exit
         if (item.taxonomicStatus === 'incorrect') {
+            if (parent.incorrect) {
+                errors.push(makeParseError('Cannot apply a correction to a previous correction', lineNumber))
+                continue
+            } else if (parentId === null) {
+                errors.push(makeParseError('Cannot apply a correction to nothing', lineNumber))
+                continue
+            }
+
             parent.incorrect = { ...parent }
             for (const key in item) {
                 if (key !== 'taxonomicStatus' && key !== 'verbatimIdentification') {
                     parentAsObject[key] = itemAsObject[key]
                 }
             }
+
+            // If "parent" is corrected, its errors can be dropped
+            previous.errors.length = 0
+            // ...but errors associated with the corrected name are added immediately
+            errors.push(...itemErrors)
+
             continue
         }
 
@@ -267,6 +288,8 @@ function parseResourceContent (content: ResourceDiff, resource: Resource, oldIds
         data[item.scientificNameID] = item
 
         // Update loop state
+        errors.push(...previous.errors)
+        previous.errors = itemErrors
         previous.id = item.scientificNameID
         if (item.taxonomicStatus === 'accepted') {
             previous.group.indent = previous.indent
@@ -274,6 +297,7 @@ function parseResourceContent (content: ResourceDiff, resource: Resource, oldIds
         }
     }
 
+    errors.push(...previous.errors)
     if (errors.length) {
         throw mergeParserErrors(errors)
     }

package/test/resources.js

@@ -257,4 +257,66 @@ Polistes Latreille, 1802
         assert.strictEqual(resource.taxa['T1:1:2'].scientificName, 'Polistes Latreille, 1802')
         assert.strictEqual(resource.taxa['T1:1:2'].genericName, 'Polistes')
     })
+
+    await test('parses invalid but corrected name', (t) => {
+        const [resource] = resources.parseTextFile(`---
+levels: [species]
+---
+
+Crabro Kiesenwetteri A. Morawitz. 1866
+  > Crabro kiesenwetteri A. Morawitz. 1866
+`, 'T1')
+        assert.strictEqual(resource.taxa['T1:1:1'].scientificName, 'Crabro kiesenwetteri A. Morawitz. 1866')
+        assert.strictEqual(resource.taxa['T1:1:1'].scientificNameAuthorship, 'A. Morawitz. 1866')
+        assert.strictEqual(resource.taxa['T1:1:1'].verbatimIdentification, 'Crabro Kiesenwetteri A. Morawitz. 1866')
+    })
+
+    await test('parses children of invalid but corrected name', (t) => {
+        const [resource] = resources.parseTextFile(`---
+levels: [genus, species]
+---
+
+Pirus L.
+  > Pyrus L.
+  aucuparia Gaertn.
+  Pirus domestica Sm.
+  Pirus aria Ehrh.
+    > Pyrus aria Ehrh.
+`, 'T1')
+        assert.strictEqual(resource.taxa['T1:1:2'].scientificName, 'Pyrus aucuparia Gaertn.')
+        assert.strictEqual(resource.taxa['T1:1:3'].scientificName, 'Pyrus domestica Sm.')
+        assert.strictEqual(resource.taxa['T1:1:4'].scientificName, 'Pyrus aria Ehrh.')
+    })
+
+    await test('does not keep parts of invalid but corrected name', (t) => {
+        const [resource] = resources.parseTextFile(`---
+levels: [species]
+---
+
+Scolia 5-punctata FABRICIUS, 1781
+  > Scolia quinquepunctata FABRICIUS, 1781
+`, 'T1')
+        assert.strictEqual(resource.taxa['T1:1:1'].scientificName, 'Scolia quinquepunctata Fabricius, 1781')
+        assert.strictEqual(resource.taxa['T1:1:1'].verbatimIdentification, 'Scolia 5-punctata FABRICIUS, 1781')
+    })
+
+    await test('make correct diff when last line changes', (t) => {
+        const newText = `---
+levels: [species]
+---
+
+Bittacus Hageni Brauer
+  > Bittacus hageni Brauer
+`
+        const oldText = `---
+levels: [genus, species]
+---
+
+Bittacus hageni Brauer
+`
+
+        const [resource] = resources.parseTextFile(newText, 'T1', { txt: oldText, dwc: [[null, ['T:1:1'], ['T:1:2']]] })
+        assert.strictEqual(resource.taxa['T1:1:1'].scientificName, 'Bittacus hageni Brauer')
+        assert.strictEqual(resource.taxa['T1:1:1'].verbatimIdentification, 'Bittacus Hageni Brauer')
+    })
 })

package/tsconfig.json

@@ -1,11 +1,14 @@
 {
   "compilerOptions": {
     "outDir": "./lib",
-    "target": "es5",
+    "target": "es6",
 
     "noImplicitAny": true,
     "strictNullChecks": true,
     "noImplicitThis": true,
+
+    "module": "commonjs",
+    "moduleResolution": "node10",
     "esModuleInterop": true
   },
   "include": ["./src/**/*"]