@larsgw/formica 0.6.0 → 0.6.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@larsgw/formica",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "description": "SDK and tools for data from the Library of Identification Resources",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -8,7 +8,8 @@
     "loir-validate-catalog": "./lib/bin/validate-catalog.js",
     "loir-validate-resources": "./lib/bin/validate-resources-text.js",
     "loir-resources-process": "./lib/bin/process-resources.js",
-    "loir-resources-index": "./lib/bin/process-resources-index.js"
+    "loir-resources-index": "./lib/bin/process-resources-index.js",
+    "loir-catalog-clean-links": "./lib/bin/clean-links.js"
   },
   "scripts": {
     "test": "node --test --test-reporter spec",

package/src/bin/clean-links.ts

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+
+import { promises as fs } from 'fs'
+import * as path from 'path'
+import * as util from 'util'
+
+import { catalog, csv } from '../index'
+
+const LINKS: Record<string, { sheet: string, cleanField: string }> = {
+    author: { sheet: 'authors', cleanField: 'main_full_name' },
+    publisher: { sheet: 'publishers', cleanField: 'full_name' },
+}
+
+function replaceLink (value: string, data: catalog.Entities, cleanField: string): string {
+    const entity = data.get(value)
+    return entity.get(cleanField) as string ?? value
+}
+
+function save (sheet: catalog.Entities, path: string): Promise<void> {
+    return fs.writeFile(path, csv.formatCsv(sheet.toTable()))
+}
+
+async function main (): Promise<void> {
+    const args = util.parseArgs({ allowPositionals: true })
+
+    const files: Record<string, { path: string, sheet: catalog.Entities }> = {}
+    for (const arg of args.positionals) {
+        const filePath = path.resolve(arg)
+        const file = await fs.readFile(filePath, 'utf8')
+        const sheet = path.basename(filePath, '.csv')
+        files[sheet] = {
+            path: filePath,
+            sheet: catalog.loadData(file, sheet),
+        }
+    }
+
+    if (!files.catalog) {
+        throw new Error('Catalog file must be provided')
+    }
+
+    for (const field in LINKS) {
+        const { sheet, cleanField } = LINKS[field]
+        const indexField = catalog.getTypeInfo(sheet)[1]
+        const used = new Set()
+
+        if (!files[sheet]) {
+            continue
+        }
+
+        // Update works
+        for (const work of files.catalog.sheet.entities) {
+            const value = work.get(field)
+
+            if (value === undefined) {
+                continue
+            } else if (Array.isArray(value)) {
+                work.fields[field] = value.map(value => {
+                    value = replaceLink(value, files[sheet].sheet, cleanField)
+                    used.add(value)
+                    return value
+                })
+            } else {
+                work.fields[field] = replaceLink(value, files[sheet].sheet, cleanField)
+                used.add(work.fields[field])
+            }
+        }
+
+        // Filter unused values
+        const entities = []
+        for (const entity of files[sheet].sheet.entities) {
+            const oldKey = entity.get(indexField) as string
+
+            if (entity.has(cleanField)) {
+                entity.fields[indexField] = entity.get(cleanField) as Value
+                delete entity.fields[cleanField]
+            }
+
+            const newKey = entity.get(indexField) as string
+
+            if (used.has(newKey) && (newKey === oldKey || !files[sheet].sheet.index[newKey])) {
+                entities.push(entity)
+            }
+        }
+
+        // Save new file
+        await save(new catalog.Entities(entities, indexField), files[sheet].path)
+    }
+
+    // Save catalog
+    await save(files.catalog.sheet, files.catalog.path)
+}
+
+main().catch((error: Error) => {
+    console.error(error)
+    process.exit(1)
+})

package/src/catalog/entities.ts

@@ -50,7 +50,7 @@ export class Entities {
         if (this.entities.length === 0) {
             return [[]]
         }
-        const header = Object.keys(this.entities[0].fields)
+        const header = Object.keys(this.entities[0].schema)
         const table = this.entities.map((entity: Entity) => {
             return header.map((field: string): string => {
                 const value = entity.get(field) || ''

package/src/catalog/index.ts

@@ -13,7 +13,7 @@ function getTypeInfo (type: string): [typeof Entity, string] {
     }
 }
 
-export { Entities, Entity }
+export { Entities, Entity, getTypeInfo }
 
 export function loadData (file: string, type: string): Entities {
     const [subClass, indexField] = getTypeInfo(type)

package/src/resources/parse-text.ts

@@ -245,8 +245,8 @@ function parseName (name: string, rank: Rank, parent: WorkingTaxon): WorkingTaxo
     }
 
     // Hybrids
-    if (rank === 'species' && /^x /.test(name)) {
-        name = '\u00D7' + name.slice(2)
+    if (rank === 'species' && /(^| )x /.test(name)) {
+        name = name.replace(/(^| )x /, '\u00D7')
     }
 
     // Divide the name into the main scientific name (only the epithet for taxa

package/test/resources.js

@@ -124,4 +124,16 @@ Microdynerus Thomson, 1874
 `, 'T1')
         assert.strictEqual(resource.taxa['T1:1:3'].scientificName, 'Microdynerus microdynerus (Dalla Torre, 1889)')
     })
+
+    await t.test('parses hybrids', (t) => {
+        const [resource] = resources.parseTextFile(`---
+levels: [species]
+---
+
+Rumex conglomeratus x maritimus
+Tilia x vulgaris
+`, 'T1')
+        assert.strictEqual(resource.taxa['T1:1:1'].scientificName, 'Rumex conglomeratus×maritimus')
+        assert.strictEqual(resource.taxa['T1:1:2'].scientificName, 'Tilia ×vulgaris')
+    })
 })