@larsgw/formica 0.4.2 → 0.5.0

package/src/resources/parse-text.ts

@@ -1,4 +1,5 @@
 import * as yaml from 'js-yaml'
+import { Work } from '../catalog/tables/work'
 import { createDiff, ResourceDiffType } from './diff-resource'
 
 const RANKS: Rank[] = [
@@ -120,9 +121,9 @@ const NAME_PATTERN = new RegExp(
  *   $1 genus+subgenus (+ trailing space): (?:([A-Z]\S+) (?:\(([A-Z]\S+?)\) )?)?
  *     $1.1 genus: ([A-Z]\S+)
  *     $1.2 subgenus: (?:\(([A-Z]\S+?)\) )?
- *   $2 species: ((?:x )?[a-z0-9-]+)
+ *   $2 species: ((?:x )?[a-z][^\s.]+)
  */
-const BINAME_PATTERN = /^(?:([A-Z]\S+) (?:\(([A-Z]\S+?)\) )?)?((?:x )?[a-z0-9-]+)(?= |$)/
+const BINAME_PATTERN = /^(?:([A-Z]\S+) (?:\(([A-Z]\S+?)\) )?)?((?:x )?[a-z][^\s.]+)(?= |$)/
 
 function compareRanks (a: Rank, b: Rank): number {
     return RANKS.indexOf(a) - RANKS.indexOf(b)
@@ -178,49 +179,67 @@ function parseName (name: string, rank: Rank, parent: WorkingTaxon): WorkingTaxo
         name = name.replace(/^\[(_|\d+)\] /, '')
     }
 
+    // Set verbatim identification after subsequent syntax is removed.
+    item.verbatimIdentification = name
+
     // Parent context is used for parsing and formatting binomial names.
-    const parentContext = { ...parent }
-    if (parent.incorrect) { parentContext.incorrect = { ...parent.incorrect } }
+    // For formatting, it needs to match external databases (i.e. be correct).
+    // For parsing, it needs to match the current file. If relevant parents
+    // (i.e. genus, species) had mistakes that were corrected, the uncorrected
+    // genus and species names need to be used.
+    const parentContext = {
+        genus: parent.genus,
+        subgenus: parent.subgenus,
+        specificEpithet: parent.specificEpithet,
+        incorrect: {
+            genus: parent.incorrect && parent.incorrect.genus,
+            specificEpithet: parent.incorrect && parent.incorrect.specificEpithet
+        }
+    }
 
-    // The parent context should be amended in the two cases where binomial names
-    // are truly accepted: synonyms and species (and below) without parents (resp.
-    // genera and genera and species) to provide parts of the name.
+    // Both contexts should be amended in the two cases where binomial names
+    // are fully used: (1) synonyms and (2) multinomial taxa without parents to
+    // provide parts of the name (e.g. bare species without a genus parent, or
+    // even subspecies without a species or genus parent).
     if (isSynonym || !parentContext.genus || (compareRanks('species', rank) < 0 && !parentContext.specificEpithet)) {
         const [, genus, subgenus, species] = name.match(BINAME_PATTERN) || []
         if (genus) {
-            parentContext.genus = capitalize(genus)
-            if (parentContext.incorrect) parentContext.incorrect.genus = capitalize(genus)
+            parentContext.genus = parentContext.incorrect.genus = capitalize(genus)
         }
         if (subgenus) {
             parentContext.subgenus = capitalize(subgenus)
-            if (parentContext.incorrect) parentContext.incorrect.subgenus = capitalize(subgenus)
         } else if (genus) {
-            // If a genus is given but no subgenus, remove it from the parent context
+            // If a genus is given but no subgenus, remove any existing subgenus
+            // from the parent context.
             delete parentContext.subgenus
-            if (parentContext.incorrect) delete parentContext.incorrect.subgenus
         }
         if (species) {
-            parentContext.specificEpithet = species
-            if (parentContext.incorrect) parentContext.incorrect.specificEpithet = species
+            parentContext.specificEpithet = parentContext.incorrect.specificEpithet = species
         }
     }
 
     // In taxa of group, species or lower, the name should just contain the
-    // (inter)specific epithet and the author information & remarks when processing
+    // (infra)specific epithet and the author information & remarks when processing
     // further.
     if (compareRanks('group', rank) <= 0) {
-        const parseContext = parentContext.incorrect || parentContext
-        if (!parseContext.genus) { parseContext.genus = name.split(' ', 1)[0] }
-        const genusPrefix = new RegExp(`^${parentContext.genus} (\\(.*?\\) )?`, 'i')
-        if (name[0] === (parentContext.genus as string)[0]) {
-            name = name.replace(genusPrefix, '')
+        // Remove genus
+        const genus = parentContext.incorrect.genus || parentContext.genus || ''
+        if (name[0] === genus[0] && name.toLowerCase().startsWith(genus.toLowerCase() + ' ')) {
+            name = name.slice(genus.length + 1)
         }
 
+        // Remove subgenus
+        name = name.replace(/^\(.*?\) /, '')
+
+        // Infraspecific taxa
         if (compareRanks('species', rank) < 0) {
-            const speciesPrefix = parseContext.specificEpithet + ' '
-            if (name.startsWith(speciesPrefix)) {
-                name = name.slice(speciesPrefix.length)
+            // Remove specific epithet
+            const species = parentContext.incorrect.specificEpithet || parentContext.specificEpithet || ''
+            if (name.startsWith(species + ' ')) {
+                name = name.slice(species.length + 1)
             }
+
+            // Remove rank abbreviations
             name = name.replace(/^(st|r|ab|f|var|ssp|subsp)\. /, '')
         }
     }
@@ -236,6 +255,13 @@ function parseName (name: string, rank: Rank, parent: WorkingTaxon): WorkingTaxo
     if (!nameParts) {
         throw new Error(`Taxon "${name}" could not be parsed`)
     }
+
+    // To encode old names with spaces (e.g. "Orsillus pini canariensis Lindberg, 1953")
+    // underscores are used, which are replaced here.
+    if (nameParts[1].includes('_')) {
+        nameParts[1] = nameParts[1].replace(/_/g, ' ')
+    }
+
     const [_, taxon, citation = '', notes] = nameParts
     item.scientificNameAuthorship = capitalizeAuthors(citation)
     item.taxonRemarks = notes
@@ -282,23 +308,23 @@ function parseName (name: string, rank: Rank, parent: WorkingTaxon): WorkingTaxo
         item.genericName = parentContext.genus
         item.infragenericEpithet = parentContext.subgenus
         item.specificEpithet = parentContext.specificEpithet
-        item.intraspecificEpithet = taxon.toLowerCase()
+        item.infraspecificEpithet = taxon.toLowerCase()
 
         // If possible, names below species should have abbreviations for ranks,
         // like "subsp."
         const nameParts = [
             item.genericName,
             item.specificEpithet,
-            item.intraspecificEpithet
+            item.infraspecificEpithet
         ]
         if (item.taxonRank in RANK_LABELS) {
             nameParts.splice(2, 0, RANK_LABELS[item.taxonRank])
         }
         item.scientificName = nameParts.join(' ')
 
-        if (item.intraspecificEpithet !== taxon) {
+        if (item.infraspecificEpithet !== taxon) {
             console.log(item, taxon)
-            throw new Error(`Intraspecific epithet should be lowercase: "${taxon}"`)
+            throw new Error(`Infraspecific epithet should be lowercase: "${taxon}"`)
         }
     }
 
@@ -341,13 +367,8 @@ function parseHeader (header: string): ResourceMetadata {
         levels = config.levels
     }
 
-    let scope
-    if (!('scope' in config)) {
-        scope = []
-    } else if (!Array.isArray(config.scope)) {
-        throw new SyntaxError('"scope" should be an array')
-    } else {
-        scope = config.scope
+    if ('scope' in config) {
+        throw new SyntaxError('"scope" data should go in "catalog"')
     }
 
     // No taxon ranks
@@ -361,10 +382,29 @@ function parseHeader (header: string): ResourceMetadata {
         throw new SyntaxError(`"levels" contains invalid values: ${invalidTaxonRanks.join(', ')}`)
     }
 
-    const metadata: ResourceMetadata = { levels, scope }
+    const metadata: ResourceMetadata = { levels }
 
     if ('catalog' in config && typeof config.catalog === 'object' && config.catalog !== null) {
-        metadata.catalog = config.catalog
+        const catalog: Record<string, string> = {}
+        for (const key in config.catalog) {
+            const value = config.catalog[key as keyof object]
+            if (typeof value === 'number') {
+                catalog[key] = (value as number).toString()
+            } else if (typeof value === 'string') {
+                catalog[key] = value
+            } else {
+                throw new SyntaxError(`"catalog" should contain only strings ("${key}")`)
+            }
+        }
+        const work = new Work(catalog)
+        const errors = work.validate().filter(({ error }) => error !== 'Value(s) required but missing')
+        if (errors.length > 0) {
+            throw new SyntaxError(`"catalog" contains errors: ${errors.map(({ field, error }) => `[${field}] ${error}`).join('; ')}`)
+        }
+        metadata.catalog = {}
+        for (const key in work.fields) {
+            metadata.catalog[key] = work.get(key) as Value
+        }
     }
 
     return metadata

package/test/resources.js

@@ -90,4 +90,38 @@ Drymus
 `, 'T1')
         assert.strictEqual(resource.taxa['T1:1:1'].scientificName, 'Drymus')
     })
+
+    await t.test('parses names containing non-ASCII characters', (t) => {
+        const [resource] = resources.parseTextFile(`---
+levels: [species]
+---
+
+Nematus fåhraei Thomson
+`, 'T1')
+        assert.strictEqual(resource.taxa['T1:1:1'].scientificName, 'Nematus fåhraei Thomson')
+    })
+
+    await t.test('parses synonyms in different genera', (t) => {
+        const [resource] = resources.parseTextFile(`---
+levels: [species]
+---
+
+Katamenes arbustorum subsp. burlinii
+  > arbustorum subsp. burlinii
+  = Eumenes arbustorum var. burlinii
+`, 'T1')
+        assert.strictEqual(resource.taxa['T1:1:2'].scientificName, 'Eumenes arbustorum var. burlinii')
+    })
+
+    await t.test('parses species without generic names', (t) => {
+        const [resource] = resources.parseTextFile(`---
+levels: [genus, subgenus, species]
+---
+
+Microdynerus Thomson, 1874
+  Alastorynerus Blüthgen, 1938
+    microdynerus (Dalla Torre, 1889)
+`, 'T1')
+        assert.strictEqual(resource.taxa['T1:1:3'].scientificName, 'Microdynerus microdynerus (Dalla Torre, 1889)')
+    })
 })