@larsgw/formica 0.2.0 → 0.3.0

package/src/module.d.ts

@@ -1,8 +1,8 @@
 type Schema = Record<string, FieldSpecification>
 type FieldSpecification = {
-  required: boolean,
-  multiple: boolean | FieldSpecificationCallbackMultiple
-  format?: string[] | RegExp | FieldSpecificationCallbackFormat
+    required: boolean,
+    multiple: boolean | FieldSpecificationCallbackMultiple
+    format?: string[] | RegExp | FieldSpecificationCallbackFormat
 }
 
 type Value = string[] | string
@@ -11,12 +11,12 @@ type FieldSpecificationCallbackMultiple = (entry: Record<string, Value>) => bool
 type FieldSpecificationCallbackFormat = (value: SingleValue) => boolean;
 
 interface FieldError {
-  field: string,
-  error: string
+    field: string,
+    error: string
 }
 
 interface WorkError extends FieldError {
-  entity: WorkId
+    entity: WorkId
 }
 
 type Rank = string
@@ -28,59 +28,59 @@ type ResourceId = string
 type WorkId = string
 
 interface WorkingTaxon {
-  scientificNameID?: TaxonId,
-  scientificName?: string,
-  scientificNameAuthorship?: string,
-  genericName?: string,
-  infragenericEpithet?: string,
-  specificEpithet?: string,
-  intraspecificEpithet?: string,
-
-  taxonRank?: Rank,
-  taxonRemarks?: string,
-  collectionCode?: ResourceId,
-
-  taxonomicStatus?: TaxonStatus,
-  acceptedNameUsageID?: TaxonId,
-  acceptedNameUsage?: string,
-
-  parentNameUsageID?: TaxonId,
-  parentNameUsage?: string,
-  kingdom?: string,
-  phylum?: string,
-  class?: string,
-  order?: string,
-  family?: string,
-  subfamily?: string,
-  genus?: string,
-  subgenus?: string,
-  higherClassification?: string,
-
-  // Non-standard
-  scientificNameOnly?: string,
-  incorrect?: WorkingTaxon
+    scientificNameID?: TaxonId,
+    scientificName?: string,
+    scientificNameAuthorship?: string,
+    genericName?: string,
+    infragenericEpithet?: string,
+    specificEpithet?: string,
+    intraspecificEpithet?: string,
+
+    taxonRank?: Rank,
+    taxonRemarks?: string,
+    collectionCode?: ResourceId,
+
+    taxonomicStatus?: TaxonStatus,
+    acceptedNameUsageID?: TaxonId,
+    acceptedNameUsage?: string,
+
+    parentNameUsageID?: TaxonId,
+    parentNameUsage?: string,
+    kingdom?: string,
+    phylum?: string,
+    class?: string,
+    order?: string,
+    family?: string,
+    subfamily?: string,
+    genus?: string,
+    subgenus?: string,
+    higherClassification?: string,
+
+    // Non-standard
+    scientificNameOnly?: string,
+    incorrect?: WorkingTaxon
 }
 
 interface Taxon extends WorkingTaxon {
-  scientificNameID: TaxonId,
-  scientificName: string,
-  taxonRank: Rank,
-  collectionCode: ResourceId,
-  taxonomicStatus: string
+    scientificNameID: TaxonId,
+    scientificName: string,
+    taxonRank: Rank,
+    collectionCode: ResourceId,
+    taxonomicStatus: string
 }
 
 interface ResourceMetadata {
-  levels: Rank[],
-  scope: string[],
-  catalog?: object
+    levels: Rank[],
+    scope: string[],
+    catalog?: object
 }
 
 interface Resource {
-  id: string,
-  file: string,
-  workId: string,
-  metadata: ResourceMetadata,
-  taxa: Record<TaxonId, Taxon>
+    id: string,
+    file: string,
+    workId: string,
+    metadata: ResourceMetadata,
+    taxa: Record<TaxonId, Taxon>
 }
 
 interface ResourceHistory {
@@ -103,3 +103,23 @@ declare enum ResourceDiffType {
     Modified = '~',
     Unchanged = '='
 }
+
+interface AmendedTaxon extends Taxon {
+    colTaxonID?: string,
+    colAcceptedTaxonID?: string,
+    gbifTaxonID?: string,
+    gbifAcceptedTaxonID?: string
+}
+
+interface AmendedResource extends Resource {
+    taxa: Record<TaxonId, AmendedTaxon>
+}
+
+interface TaxonMatch {
+    source: number,
+    id: string,
+    currentId?: string,
+    classificationPath: string[]
+}
+
+type GroupedNameMatches = Record<string, Record<string, Record<TaxonId, TaxonMatch>>>

package/src/resources/parse-text.ts

@@ -31,6 +31,16 @@ const RANKS: Rank[] = [
     'stirps' // not ICZN
 ]
 
+const MAIN_RANKS: Rank[] = [
+    'kingdom',
+    'phylum',
+    'class',
+    'order',
+    'family',
+    'genus',
+    'species'
+]
+
 const DWC_RANKS: DwcRank[] = [
     'kingdom',
     'phylum',
@@ -360,11 +370,7 @@ function parseHeader (header: string): ResourceMetadata {
     return metadata
 }
 
-function parseResource (resource: string): [ResourceMetadata, string] {
-    const [header, _, ...rest] = resource.split(/(\n---\n+)/)
-    const config = parseHeader(header)
-    const content = rest.join('')
-
+function validateResource (config: ResourceMetadata, content: string) {
     // Check for too much indentation
     const longerIndent = new RegExp(`^(  ){${config.levels.length - 1}}(?!  [+=>] ) `, 'm')
     const longerIndentMatch = content.match(longerIndent)
@@ -377,15 +383,25 @@ ${content.slice(offset).split('\n', 1)}
     }
 
     // Check for missing leaf taxa
-    const missingLeafTaxa = new RegExp(`^(  ){0,${config.levels.length - 2}}(?![+=>] ).*\\n(?!\\1  )`, 'm')
-    const missingLeafTaxaMatch = content.match(missingLeafTaxa)
-    if (missingLeafTaxaMatch !== null) {
-        const offset = missingLeafTaxaMatch.index
-        const line = (content.slice(0, offset).match(/\n/g) || []).length + 1
-        throw new SyntaxError(`Missing leaf taxon at ${line}:0
+    const leafTaxonRank = config.levels.filter(rank => MAIN_RANKS.includes(rank)).pop() as string
+    const leafTaxonParentIndent = config.levels.indexOf(leafTaxonRank) - 1
+    if (leafTaxonRank && leafTaxonParentIndent >= 0) {
+        const missingLeafTaxa = new RegExp(`^((?:  ){0,${leafTaxonParentIndent}})(?![+=> ] ).*\\n(\\1(  )+[+=>].*\\n)*(?!\\1  )`, 'm')
+        const missingLeafTaxaMatch = content.match(missingLeafTaxa)
+        if (missingLeafTaxaMatch !== null) {
+            const offset = missingLeafTaxaMatch.index
+            const line = (content.slice(0, offset).match(/\n/g) || []).length + 1
+            throw new SyntaxError(`Missing leaf taxon at ${line}:0
 ${content.slice(offset).split('\n', 1)}
 ^`)
+        }
     }
+}
+
+function parseResource (resource: string): [ResourceMetadata, string] {
+    const [header, _, ...rest] = resource.split(/(\n---\n+)/)
+    const config = parseHeader(header)
+    const content = rest.join('')
 
     return [config, content]
 }
@@ -499,6 +515,7 @@ export function parseFile (file: string, id: WorkId, old?: ResourceHistory): Res
     const oldResources = old ? splitResources(old.txt) : []
     return splitResources(file).map((resource, index) => {
         const [config, content] = parseResource(resource)
+        validateResource(config, content)
         const template: Resource = {
             id: `${id}:${index + 1}`,
             file: `${id}-${index + 1}`,

package/src/taxon-names/index.ts

@@ -0,0 +1,79 @@
+const MINIMUM_PREFIX_LENGTH = 3
+const VALID_COMMON_PREFIXES = new Set([
+    'Plantae|Tracheophyta',
+    'Fungi',
+    'Fungi|Ascomycota',
+    'Fungi|Basidiomycota',
+    'Fungi|Zygomycota'
+])
+
+function getCommonPrefix (a: string[], b: string[]): string[] {
+    for (let i = 0; i < Math.max(a.length, b.length); i++) {
+        if (a[i] !== b[i]) {
+            return a.slice(0, i)
+        }
+    }
+    return a.slice()
+}
+
+function isValidPrefix (a: string[], b: string[]): boolean {
+    const prefix = getCommonPrefix(a, b)
+    return VALID_COMMON_PREFIXES.has(prefix.join('|')) || prefix.length >= MINIMUM_PREFIX_LENGTH
+}
+
+export function groupNameMatches (results: Record<TaxonId, TaxonMatch[]>): GroupedNameMatches {
+    const prefixes: Record<string, [string[], Record<TaxonId, TaxonMatch>][]> = {}
+
+    for (const scientificNameID in results) {
+        for (const result of results[scientificNameID]) {
+            if (!prefixes[result.source]) {
+                prefixes[result.source] = []
+            }
+
+            let prefix = prefixes[result.source].find(prefix => isValidPrefix(prefix[0], result.classificationPath))
+
+            if (!prefix) {
+                prefix = [result.classificationPath, {}]
+                prefixes[result.source].push(prefix)
+            } else {
+                prefix[0] = getCommonPrefix(prefix[0], result.classificationPath)
+            }
+
+            if (scientificNameID in prefix[1]) {
+                continue
+            }
+
+            prefix[1][scientificNameID] = result
+        }
+    }
+
+    const groupedNameMatches: GroupedNameMatches = {}
+    for (const source in prefixes) {
+        groupedNameMatches[source] = prefixes[source]
+            .sort((a, b) => Object.keys(b[1]).length - Object.keys(a[1]).length)
+            .reduce((map: Record<string, Record<TaxonId, TaxonMatch>>, [prefix, taxa]) => {
+                map[prefix.join('|')] = taxa
+                return map
+            }, {})
+    }
+
+    return groupedNameMatches
+}
+
+export function amendResource (resource: AmendedResource, source: string, matches: Record<TaxonId, TaxonMatch>) {
+    for (const id in matches) {
+        const match = matches[id]
+
+        if (source === '1') {
+            resource.taxa[id].colTaxonID = match.id
+            if (match.currentId) {
+                resource.taxa[id].colAcceptedTaxonID = match.currentId
+            }
+        } else if (source === '11') {
+            resource.taxa[id].gbifTaxonID = match.id
+            if (match.currentId) {
+                resource.taxa[id].gbifAcceptedTaxonID = match.currentId
+            }
+        }
+    }
+}