@thegetty/quire-cli 1.0.0-rc.35 → 1.0.0-rc.36

package/src/commands/epub.js

@@ -1,12 +1,16 @@
 import Command from '#src/Command.js'
-import { paths, projectRoot  } from '#lib/11ty/index.js'
+import { withOutputModes } from '#lib/commander/index.js'
+import paths, { hasEpubOutput } from '#lib/project/index.js'
+import eleventy from '#lib/11ty/index.js'
 import fs from 'fs-extra'
-import libEpub from '#lib/epub/index.js'
+import generateEpub, { ENGINES } from '#lib/epub/index.js'
 import open from 'open'
-import path from 'node:path'
+import reporter from '#lib/reporter/index.js'
+import testcwd from '#helpers/test-cwd.js'
+import { MissingBuildOutputError } from '#src/errors/index.js'
 
 /**
- * Quire CLI `build epub` Command
+ * Quire CLI `epub` Command
  *
  * Generate EPUB from Eleventy `build` output.
  *
@@ -14,53 +18,78 @@ import path from 'node:path'
  * @extends    {Command}
  */
 export default class EpubCommand extends Command {
-  static definition = {
+  static definition = withOutputModes({
     name: 'epub',
     description: 'Generate publication EPUB',
-    summary: 'run build epub',
+    summary: 'generate EPUB e-book',
+    docsLink: 'quire-commands/#output-files',
+    helpText: `
+Examples:
+  quire epub                        Generate EPUB using default engine
+  quire epub --engine pandoc        Generate EPUB using Pandoc
+  quire epub --open                 Generate and open EPUB
+  quire epub --build                Build site first, then generate EPUB
+  quire epub --output my-book.epub  Generate EPUB with custom output path
+`,
     version: '1.0.0',
-    args: [],
     options: [
+      [ '--build', 'run build first if output is missing' ],
+      [ '--open', 'open EPUB in default application' ],
+      [ '-o, --output <path>', 'output file path (default: {engine}.epub)' ],
       [
-        '--lib <module>', 'use the specified epub library', 'epubjs',
-        { choices: ['epubjs', 'pandoc'], default: 'epubjs' }
+        '--engine <name>', 'EPUB engine to use (default: from config or epubjs)',
+        { choices: ENGINES }
+      ],
+      [
+        '--lib <name>', 'deprecated alias for --engine option',
+        { hidden: true, choices: ENGINES, conflicts: 'engine' }
       ],
-      [ '--open', 'open EPUB in default application' ],
-      [ '--debug', 'run epub with debug output' ],
     ],
-  }
+  })
 
   constructor() {
     super(EpubCommand.definition)
   }
 
   async action(options, command) {
-    if (options.debug) {
-      console.debug('[CLI] Command \'%s\' called with options %o', this.name(), options)
-    }
+    this.debug('called with options %O', options)
 
-    const input = path.join(projectRoot, paths.epub)
+    // Configure reporter for this command
+    reporter.configure({ quiet: options.quiet, verbose: options.verbose })
 
-    if (!fs.existsSync(input)) {
-      console.error(`Unable to find Epub input at ${input}\nPlease first run the 'quire build' command.`)
-      return
+    // Resolve engine: CLI --engine > deprecated --lib > config epubEngine > default
+    if (!options.engine) {
+      if (options.lib) {
+        // Support deprecated --lib option
+        options.engine = options.lib
+      } else {
+        // Use config setting or fallback to default
+        options.engine = this.config.get('epubEngine') || 'epubjs'
+      }
     }
 
-    const output = path.join(projectRoot, `${options.lib}.epub`)
+    // Run build first if --build flag is set and output is missing
+    if (options.build && !hasEpubOutput()) {
+      this.debug('running build before epub generation')
+      reporter.start('Building site...', { showElapsed: true })
+      await eleventy.build({ debug: options.debug })
+    }
 
-    const epubLib = await libEpub(options.lib, { debug: options.debug })
-    await epubLib(input, output)
+    // Check for build output (will throw if missing)
+    // TODO: Add interactive prompt when build output missing and --build not used
+    if (!hasEpubOutput()) {
+      throw new MissingBuildOutputError('EPUB', paths.getEpubDir())
+    }
+
+    // Pass engine as lib (matching lib/pdf interface)
+    // Reporter lifecycle is owned by the façade (lib/epub/index.js)
+    const epubOptions = { ...options, lib: options.engine }
+    const output = await generateEpub(epubOptions)
 
     if (fs.existsSync(output) && options.open) open(output)
   }
 
-  /**
-   * @todo test if build site has already be run and output can be reused
-   */
-  preAction(command) {
-    const options = command.opts()
-    if (options.debug) {
-      console.debug('[CLI] Calling \'epub\' command pre-action with options', options)
-    }
+  preAction(thisCommand, actionCommand) {
+    testcwd(thisCommand)
   }
 }

package/src/commands/epub.spec.js

@@ -0,0 +1,114 @@
+import { Command, Option } from 'commander'
+import program from '#src/main.js'
+import test from 'ava'
+
+/**
+ * Command Contract/Interface Tests
+ *
+ * Verifies the command's public API and Commander.js integration.
+ * @see docs/testing-commands.md
+ */
+
+test.before((t) => {
+  // Get the registered command (from program.commands) once and share across all tests
+  t.context.command = program.commands.find((cmd) => cmd.name() === 'epub')
+})
+
+test('command is registered in CLI program', (t) => {
+  const { command } = t.context
+
+  t.truthy(command, 'command "epub" should be registered in program')
+  t.true(command instanceof Command, 'registered command should be Commander.js Command instance')
+})
+
+test('registered command has correct metadata', (t) => {
+  const { command } = t.context
+
+  t.is(command.name(), 'epub')
+  t.truthy(command.description())
+  t.is(typeof command._actionHandler, 'function', 'command should have action handler')
+})
+
+test('registered command has no arguments', (t) => {
+  const { command } = t.context
+  const registeredArguments = command.registeredArguments
+
+  t.is(registeredArguments.length, 0, 'epub command should have no arguments')
+})
+
+test('registered command has correct options', (t) => {
+  const { command } = t.context
+
+  // Get all options
+  const engineOption = command.options.find((opt) => opt.long === '--engine')
+  const libOption = command.options.find((opt) => opt.long === '--lib')
+  const buildOption = command.options.find((opt) => opt.long === '--build')
+  const openOption = command.options.find((opt) => opt.long === '--open')
+  const quietOption = command.options.find((opt) => opt.long === '--quiet')
+  const verboseOption = command.options.find((opt) => opt.long === '--verbose')
+  const debugOption = command.options.find((opt) => opt.long === '--debug')
+
+  // Verify all options exist
+  t.truthy(engineOption, '--engine option should exist')
+  t.truthy(libOption, '--lib option should exist (deprecated alias)')
+  t.truthy(buildOption, '--build option should exist')
+  t.truthy(openOption, '--open option should exist')
+  t.truthy(quietOption, '--quiet option should exist')
+  t.truthy(verboseOption, '--verbose option should exist')
+  t.truthy(debugOption, '--debug option should exist')
+
+  // Verify they are Option instances
+  t.true(engineOption instanceof Option, '--engine should be Option instance')
+  t.true(libOption instanceof Option, '--lib should be Option instance')
+  t.true(buildOption instanceof Option, '--build should be Option instance')
+  t.true(openOption instanceof Option, '--open should be Option instance')
+  t.true(quietOption instanceof Option, '--quiet should be Option instance')
+  t.true(verboseOption instanceof Option, '--verbose should be Option instance')
+  t.true(debugOption instanceof Option, '--debug should be Option instance')
+
+  // Verify --engine option properties
+  t.is(engineOption.long, '--engine')
+  t.truthy(engineOption.description)
+  t.true(engineOption.required, '--engine should require a value')
+
+  // Verify --lib is hidden (deprecated alias)
+  t.is(libOption.long, '--lib')
+  t.true(libOption.hidden, '--lib should be hidden (deprecated)')
+
+  t.is(buildOption.long, '--build')
+  t.truthy(buildOption.description)
+  t.false(buildOption.required, '--build should not require a value')
+
+  t.is(openOption.long, '--open')
+  t.truthy(openOption.description)
+  t.false(openOption.required, '--open should not require a value')
+
+  t.is(quietOption.long, '--quiet')
+  t.is(quietOption.short, '-q', '--quiet should have -q short flag')
+  t.truthy(quietOption.description)
+  t.false(quietOption.required, '--quiet should not require a value')
+
+  t.is(verboseOption.long, '--verbose')
+  t.is(verboseOption.short, '-v', '--verbose should have -v short flag')
+  t.truthy(verboseOption.description)
+  t.false(verboseOption.required, '--verbose should not require a value')
+
+  t.is(debugOption.long, '--debug')
+  t.truthy(debugOption.description)
+  t.false(debugOption.required, '--debug should not require a value')
+})
+
+test('command options are accessible via public API', (t) => {
+  const { command } = t.context
+
+  // Test that options can be accessed the way Commander.js does
+  const optionNames = command.options.map((opt) => opt.long)
+
+  t.true(optionNames.includes('--engine'))
+  t.true(optionNames.includes('--lib'))  // deprecated alias still exists
+  t.true(optionNames.includes('--build'))
+  t.true(optionNames.includes('--open'))
+  t.true(optionNames.includes('--quiet'))
+  t.true(optionNames.includes('--verbose'))
+  t.true(optionNames.includes('--debug'))
+})