@ca-plant-list/ca-plant-list 0.3.7 → 0.4.0

package/scripts/build-ebook.js

@@ -1,50 +1,23 @@
 #!/usr/bin/env node
 
 import { Config } from "../lib/config.js";
+import { ErrorLog } from "../lib/errorlog.js";
 import { Files } from "../lib/files.js";
 import { PlantBook } from "../lib/ebook/plantbook.js";
-import { TaxaProcessor } from "../lib/taxaprocessor.js";
-import { CommandProcessor } from "../lib/commandprocessor.js";
+import { Program } from "../lib/program.js";
+import { Taxa } from "../lib/taxa.js";
 
-const OPTION_DEFS = [{ name: "locationsdir", type: String }];
+const program = Program.getProgram();
+program
+    .option("-l, --locationsdir <dir>", "directory containing location data")
+    .action(build);
 
-const OPTION_HELP = [
-    {
-        name: "locationsdir",
-        type: String,
-        typeLabel: "{underline path}",
-        description:
-            "If this option is specified, multiple ebooks will be generated. {bold locationsdir} must be a subdirectory" +
-            " of the current directory, and each subdirectory of {bold locationsdir} is processed in turn to generate an ebook." +
-            " Each ebook is placed in a subdirectory of {bold outputdir}.",
-    },
-];
-
-class BookCommand extends CommandProcessor {
-    constructor() {
-        super(
-            "ca-plant-book",
-            "A tool to generate an ebook with local plant data.",
-            OPTION_DEFS,
-            OPTION_HELP
-        );
-    }
-}
+await program.parseAsync();
 
 /**
- * @param {TaxaProcessor} tp
+ * @param {import("commander").OptionValues} options
  */
-async function commandRunner(tp) {
-    const options = tp.getOptions();
-    const ebook = new PlantBook(
-        options.outputdir,
-        new Config(options.datadir),
-        tp.getTaxa()
-    );
-    await ebook.create();
-}
-
-async function generateEBooks(options) {
+async function build(options) {
     const locationsDir = options.locationsdir;
 
     // If there is a "locations" directory, generate a book for all subdirectories.
@@ -57,21 +30,39 @@ async function generateEBooks(options) {
             const suffix = "/" + subdir;
             const path = locationsDir + suffix;
             if (Files.isDir(path)) {
-                options.datadir = path;
-                options.outputdir = outputBase + suffix;
-                const gen = new TaxaProcessor(options);
-                await gen.process(commandRunner);
+                await buildBook(
+                    outputBase + suffix,
+                    path,
+                    options.showFlowerErrors
+                );
             }
         }
     } else {
         // Otherwise use the default directory.
-        const gen = new TaxaProcessor(options);
-        await gen.process(commandRunner);
+        await buildBook(
+            options.outputdir,
+            options.datadir,
+            options.showFlowerErrors
+        );
     }
 }
 
-const cmd = new BookCommand();
-const options = cmd.getOptions();
-if (!options.help) {
-    await generateEBooks(options);
+/**
+ * @param {string} outputDir
+ * @param {string} dataDir
+ * @param {boolean} showFlowerErrors
+ */
+async function buildBook(outputDir, dataDir, showFlowerErrors) {
+    const errorLog = new ErrorLog(outputDir + "/errors.tsv");
+
+    const taxa = new Taxa(
+        Program.getIncludeList(dataDir),
+        errorLog,
+        showFlowerErrors
+    );
+
+    const config = new Config(dataDir);
+    const ebook = new PlantBook(outputDir, config, taxa);
+    await ebook.create();
+    errorLog.write();
 }

package/scripts/build-site.js

@@ -4,14 +4,21 @@ import * as child_process from "node:child_process";
 import * as path from "node:path";
 import { Config } from "../lib/config.js";
 import { PageRenderer } from "../lib/pagerenderer.js";
-import { CommandAndTaxaProcessor } from "../lib/commandandtaxaprocessor.js";
 import { Files } from "../lib/files.js";
+import { Program } from "../lib/program.js";
+import { Taxa } from "../lib/taxa.js";
+import { ErrorLog } from "../lib/errorlog.js";
 
 class JekyllRenderer {
     #srcDir = "./output";
     #destDir = "./public";
 
     async renderPages() {
+        /**
+         * @param {string[]} configFiles
+         * @param {string} dir
+         * @param {string} name
+         */
         function addConfigFile(configFiles, dir, name) {
             const fullPath = path.join(dir, name);
             if (Files.exists(fullPath)) {
@@ -30,6 +37,7 @@ class JekyllRenderer {
         ];
 
         // Find out what config files are available.
+        /** @type {string[]} */
         const configFiles = [];
         addConfigFile(configFiles, this.#srcDir, "_config.yml");
         addConfigFile(configFiles, this.#srcDir, "_config-local.yml");
@@ -43,23 +51,26 @@ class JekyllRenderer {
     }
 }
 
-async function generateSite(taxaProcessor) {
-    const options = taxaProcessor.getOptions();
-
-    PageRenderer.render(
-        options.outputdir,
-        new Config(options.datadir),
-        taxaProcessor.getTaxa()
+/**
+ * @param {import("commander").OptionValues} options
+ */
+async function build(options) {
+    Files.rmDir(options.outputdir);
+    const errorLog = new ErrorLog(options.outputdir + "/errors.tsv");
+    const taxa = new Taxa(
+        Program.getIncludeList(options.datadir),
+        errorLog,
+        options.showFlowerErrors
     );
+    PageRenderer.render(options.outputdir, new Config(options.datadir), taxa);
+    errorLog.write();
 
     console.log("generating site");
     const r = new JekyllRenderer();
     await r.renderPages();
 }
 
-const gen = new CommandAndTaxaProcessor(
-    "ca-plant-list",
-    "A tool to generate a website with local plant data.",
-    generateSite
-);
-await gen.process(generateSite);
+const program = Program.getProgram();
+program.action(build);
+
+await program.parseAsync();

package/types/classes.d.ts

@@ -1,26 +1,154 @@
+declare class CommandLineOptions {
+    datadir: string;
+    outputdir: string;
+    "show-flower-errors": boolean;
+}
+
+declare class Config {
+    getConfigValue(
+        prefix: string,
+        name: string,
+        subcategory?: string,
+        defaultValue?: string
+    ): string;
+    getCountyCodes(): string[];
+    getLabel(name: string, dflt: string): string;
+}
+
 declare class ErrorLog {
     log(...args: string[]): void;
+    write();
+}
+
+declare class Families {
+    getFamilies(): Family[];
+    getFamily(name: string): Family;
+    renderPages(outputDir: string, cols?: TaxaCol[]);
+}
+
+declare class Family {
+    getFileName(): string;
+    getName(): string;
+    getSectionName(): string;
+    getTaxa(): Taxon[];
+}
+
+declare class FlowerColor {
+    getColorCode(): string;
+    getColorName(upperCase?: boolean): string;
+    getFileName(): string;
+    getTaxa(): Taxon[];
+}
+
+declare class Genera {
+    addTaxon(Taxon);
+    getGenus(name: string): Genus;
+}
+
+declare class Genus {
+    getFamily(): Family;
+    getTaxa(): Taxon[];
 }
 
-declare class Families {}
+declare class GlossaryEntry {
+    getMarkdown(): string;
+    getTermName(): string;
+}
 
-declare class Genera {}
+declare class Images {
+    getTaxonImages(name: string): TaxonImage[];
+}
+
+declare class InatObsOptions {
+    coords?: [number, number];
+    project_id?: string;
+    subview?: "grid" | "list" | "map";
+    taxon_id?: string;
+}
+
+declare class SiteGenerator {
+    copyIllustrations(flowerColors: FlowerColor[]);
+    mkdir(path: string);
+    writeTemplate(
+        content: string,
+        attributes: Object<string, string>,
+        filename: string
+    );
+}
+
+declare class SynonymData {
+    Current: string;
+    Former: string;
+    Type: string;
+}
+
+declare class Taxa {
+    getFamilies(): Families;
+    getFlowerColors(): FlowerColor[];
+    getTaxon(name: string): Taxon;
+    getTaxonList(): Taxon[];
+}
+
+declare class TaxaCol {
+    class?: string;
+    data: Object<string, Taxon>;
+    title: string;
+}
 
 declare class Taxon {
     constructor(data: TaxonData, genera: Genera, meta: any);
-    getBloomEnd(): number;
-    getBloomStart(): number;
-    getCESA(): string;
+    getBaseFileName(): string;
+    getBloomEnd(): number | undefined;
+    getBloomStart(): number | undefined;
+    getCalfloraName(): string;
+    getCalfloraTaxonLink(): string | undefined;
+    getCESA(): string | undefined;
     getCommonNames(): string[];
-    getFESA(): string;
+    getFamily(): Family;
+    getFESA(): string | undefined;
     getFileName(): string;
-    getFlowerColors(): string[];
+    getFlowerColors(): string[] | undefined;
+    getGenus(): Genus;
+    getGenusName(): string;
     getHTMLLink(
         href: boolean | string | undefined,
-        includeRPI: boolean
+        includeRPI?: boolean
     ): string;
+    getINatID(): string;
+    getINatName(): string;
+    getINatTaxonLink(): string;
+    getJepsonID(): string;
     getLifeCycle(): string;
     getName(): string;
+    getRPIRank(): string;
     getRPIRankAndThreat(): string;
     getRPIRankAndThreatTooltip(): string;
+    getRPITaxonLink(): string;
+    getStatusDescription(config: Config): string;
+    getSynonyms(): string[];
+    isNative(): boolean;
+}
+
+declare class TaxonData {
+    bloom_end: string;
+    bloom_start: string;
+    calrecnum: string;
+    CESA: string;
+    "common name": string;
+    CRPR: string;
+    FESA: string;
+    flower_color: string;
+    GRank: string;
+    "inat id": string;
+    "jepson id": string;
+    life_cycle: string;
+    "RPI ID": string;
+    SRank: string;
+    status: string;
+    taxon_name: string;
+}
+
+declare class TaxonImage {
+    getCaption(): string | undefined;
+    getSrc(): string;
 }

package/lib/commandandtaxaprocessor.js

@@ -1,25 +0,0 @@
-import { CommandProcessor } from "./commandprocessor.js";
-import { Files } from "./files.js";
-import { TaxaProcessor } from "./taxaprocessor.js";
-
-class CommandAndTaxaProcessor extends CommandProcessor {
-
-    #taxaProcessor;
-
-    constructor( commandName, commandDesc, optionDefs = [], optionHelp = [], commandHelp = [], taxaLoaderClass ) {
-        super( commandName, commandDesc, optionDefs, optionHelp, commandHelp );
-        this.#taxaProcessor = new TaxaProcessor( this.getOptions(), taxaLoaderClass );
-    }
-
-    async process( commandRunner ) {
-        if ( this.helpShown() ) {
-            return;
-        }
-        Files.rmDir( this.getOptions().outputdir );
-
-        await this.#taxaProcessor.process( commandRunner );
-    }
-
-}
-
-export { CommandAndTaxaProcessor };

package/lib/commandprocessor.js

@@ -1,108 +0,0 @@
-import commandLineArgs from "command-line-args";
-import commandLineUsage from "command-line-usage";
-
-const OPTION_DEFS = [
-    { name: "datadir", type: String, defaultValue: "./data" },
-    { name: "help", type: Boolean },
-    { name: "outputdir", type: String, defaultValue: "./output" },
-    { name: "show-flower-errors", type: Boolean },
-];
-
-const OPTION_HELP = [
-    {
-        name: "datadir",
-        type: String,
-        typeLabel: "{underline path}",
-        description: "The directory in which the data files for the local plant list are located. Defaults to {bold ./data}."
-
-    },
-    {
-        name: "outputdir",
-        type: String,
-        typeLabel: "{underline path}",
-        description: "The directory in which the output files should be written. Any files or subdirectories originally" +
-            " in this directory will be deleted. Defaults to {bold ./output}."
-
-    },
-    {
-        name: "show-flower-errors",
-        type: Boolean,
-        description: "Include flower color and flowering time errors in errors.tsv."
-    },
-    {
-        name: "help",
-        type: Boolean,
-        description: "Print this usage guide."
-    },
-];
-
-class CommandProcessor {
-
-    #commandName;
-    #commandDesc;
-
-    #optionHelp;
-    #commandHelp;
-
-    #options;
-
-    #helpShown = false;
-
-    /**
-     * @param {String} commandName 
-     * @param {String} commandDesc 
-     * @param {*} optionDefs An array of command line options to be added to the standard options.
-     * @param {*} optionHelp An array of help descriptions to be added to the standard options in the first section.
-     * @param {*} commandHelp An array of help sections to be appended to the first option section in the help display.
-     */
-    constructor( commandName, commandDesc, optionDefs = [], optionHelp = [], commandHelp = [] ) {
-
-        this.#commandName = commandName;
-        this.#commandDesc = commandDesc;
-
-        this.#optionHelp = optionHelp;
-        this.#commandHelp = commandHelp;
-
-        this.#options = commandLineArgs( OPTION_DEFS.concat( optionDefs ) );
-
-        if ( this.#options.help ) {
-            this.showHelp();
-        }
-
-    }
-
-    getOptions() {
-        return this.#options;
-    }
-
-    helpShown() {
-        return this.#helpShown;
-    }
-
-    showHelp() {
-
-        if ( this.#helpShown ) {
-            return;
-        }
-
-        this.#helpShown = true;
-
-        const mainOptions = OPTION_HELP.concat( this.#optionHelp );
-        mainOptions.sort( ( a, b ) => a.name.localeCompare( b.name ) );
-
-        const help = [
-            {
-                header: this.#commandName,
-                content: this.#commandDesc
-            },
-            {
-                header: "Options",
-                optionList: mainOptions
-            }
-        ];
-        console.log( commandLineUsage( help.concat( this.#commandHelp ) ) );
-    }
-
-}
-
-export { CommandProcessor };

package/lib/generictaxaloader.js

@@ -1,48 +0,0 @@
-import { ErrorLog } from "./errorlog.js";
-
-class GenericTaxaLoader {
-    #options;
-    #errorLog;
-    /** @type {import("./index.js").Taxa|undefined}*/
-    #taxa;
-
-    /**
-     * @param {*} options
-     */
-    constructor(options) {
-        this.#options = options;
-        this.#errorLog = new ErrorLog(options.outputdir + "/errors.tsv");
-    }
-
-    /**
-     * @returns {ErrorLog}
-     */
-    getErrorLog() {
-        return this.#errorLog;
-    }
-
-    getOptions() {
-        return this.#options;
-    }
-
-    getTaxa() {
-        return this.#taxa;
-    }
-
-    async load() {
-        this.#taxa = await this.loadTaxa();
-    }
-
-    /**
-     * @return {Promise<import("./index.js").Taxa>}
-     */
-    async loadTaxa() {
-        throw new Error("must be implemented by subclass");
-    }
-
-    writeErrorLog() {
-        this.#errorLog.write();
-    }
-}
-
-export { GenericTaxaLoader };

package/lib/taxaloader.js

@@ -1,50 +0,0 @@
-import { CSV } from "./csv.js";
-import { Files } from "./files.js";
-import { GenericTaxaLoader } from "./generictaxaloader.js";
-import { Taxa } from "./taxa.js";
-
-class TaxaLoader extends GenericTaxaLoader {
-    /**
-     * @param {*} options
-     */
-    constructor(options) {
-        super(options);
-    }
-
-    /**
-     * @return {Promise<Taxa>}
-     */
-    async loadTaxa() {
-        /**
-         *
-         * @param {string} dataDir
-         * @returns
-         */
-        function getIncludeList(dataDir) {
-            // Read inclusion list.
-            const includeFileName = "taxa_include.csv";
-            const includeFilePath = dataDir + "/" + includeFileName;
-            if (!Files.exists(includeFilePath)) {
-                console.log(includeFilePath + " not found; loading all taxa");
-                return true;
-            }
-            /**@type { import("./index.js").TaxonData[]} */
-            const includeCSV = CSV.parseFile(dataDir, includeFileName);
-            /** @type {Object<string,import("./index.js").TaxonData>} */
-            const include = {};
-            for (const row of includeCSV) {
-                include[row["taxon_name"]] = row;
-            }
-            return include;
-        }
-
-        const options = this.getOptions();
-        return new Taxa(
-            getIncludeList(options.datadir),
-            this.getErrorLog(),
-            options["show-flower-errors"]
-        );
-    }
-}
-
-export { TaxaLoader };

package/lib/taxaprocessor.js

@@ -1,34 +0,0 @@
-import { TaxaLoader } from "./taxaloader.js";
-
-class TaxaProcessor {
-    #options;
-    #taxaLoaderClass;
-    #taxaLoader;
-
-    constructor(options, taxaLoaderClass = TaxaLoader) {
-        this.#options = options;
-        this.#taxaLoaderClass = taxaLoaderClass;
-    }
-
-    getErrorLog() {
-        return this.#taxaLoader.getErrorLog();
-    }
-
-    getOptions() {
-        return this.#options;
-    }
-
-    getTaxa() {
-        return this.#taxaLoader.getTaxa();
-    }
-
-    async process(commandRunner) {
-        console.log("loading data");
-        this.#taxaLoader = new this.#taxaLoaderClass(this.#options);
-        await this.#taxaLoader.load();
-        await commandRunner(this);
-        this.#taxaLoader.writeErrorLog();
-    }
-}
-
-export { TaxaProcessor };